?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: rtl8188eu: Replace function name in string with __func__
[linux/fpc-iii.git] / drivers / net / usb / lan78xx.c
blob60a604cc7647e460539d0482c69f9ffc8f882aa1
1 /*
2 * Copyright (C) 2015 Microchip Technology
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
16 */
17 #include <linux/version.h>
18 #include <linux/module.h>
19 #include <linux/netdevice.h>
20 #include <linux/etherdevice.h>
21 #include <linux/ethtool.h>
22 #include <linux/usb.h>
23 #include <linux/crc32.h>
24 #include <linux/signal.h>
25 #include <linux/slab.h>
26 #include <linux/if_vlan.h>
27 #include <linux/uaccess.h>
28 #include <linux/list.h>
29 #include <linux/ip.h>
30 #include <linux/ipv6.h>
31 #include <linux/mdio.h>
32 #include <linux/phy.h>
33 #include <net/ip6_checksum.h>
34 #include <linux/interrupt.h>
35 #include <linux/irqdomain.h>
36 #include <linux/irq.h>
37 #include <linux/irqchip/chained_irq.h>
38 #include <linux/microchipphy.h>
39 #include <linux/phy.h>
40 #include "lan78xx.h"
41
42 #define DRIVER_AUTHOR "WOOJUNG HUH <woojung.huh@microchip.com>"
43 #define DRIVER_DESC "LAN78XX USB 3.0 Gigabit Ethernet Devices"
44 #define DRIVER_NAME "lan78xx"
45 #define DRIVER_VERSION "1.0.6"
46
47 #define TX_TIMEOUT_JIFFIES (5 * HZ)
48 #define THROTTLE_JIFFIES (HZ / 8)
49 #define UNLINK_TIMEOUT_MS 3
50
51 #define RX_MAX_QUEUE_MEMORY (60 * 1518)
52
53 #define SS_USB_PKT_SIZE (1024)
54 #define HS_USB_PKT_SIZE (512)
55 #define FS_USB_PKT_SIZE (64)
56
57 #define MAX_RX_FIFO_SIZE (12 * 1024)
58 #define MAX_TX_FIFO_SIZE (12 * 1024)
59 #define DEFAULT_BURST_CAP_SIZE (MAX_TX_FIFO_SIZE)
60 #define DEFAULT_BULK_IN_DELAY (0x0800)
61 #define MAX_SINGLE_PACKET_SIZE (9000)
62 #define DEFAULT_TX_CSUM_ENABLE (true)
63 #define DEFAULT_RX_CSUM_ENABLE (true)
64 #define DEFAULT_TSO_CSUM_ENABLE (true)
65 #define DEFAULT_VLAN_FILTER_ENABLE (true)
66 #define TX_OVERHEAD (8)
67 #define RXW_PADDING 2
68
69 #define LAN78XX_USB_VENDOR_ID (0x0424)
70 #define LAN7800_USB_PRODUCT_ID (0x7800)
71 #define LAN7850_USB_PRODUCT_ID (0x7850)
72 #define LAN7801_USB_PRODUCT_ID (0x7801)
73 #define LAN78XX_EEPROM_MAGIC (0x78A5)
74 #define LAN78XX_OTP_MAGIC (0x78F3)
75
76 #define MII_READ 1
77 #define MII_WRITE 0
78
79 #define EEPROM_INDICATOR (0xA5)
80 #define EEPROM_MAC_OFFSET (0x01)
81 #define MAX_EEPROM_SIZE 512
82 #define OTP_INDICATOR_1 (0xF3)
83 #define OTP_INDICATOR_2 (0xF7)
84
85 #define WAKE_ALL (WAKE_PHY | WAKE_UCAST | \
86 WAKE_MCAST | WAKE_BCAST | \
87 WAKE_ARP | WAKE_MAGIC)
88
89 /* USB related defines */
90 #define BULK_IN_PIPE 1
91 #define BULK_OUT_PIPE 2
92
93 /* default autosuspend delay (mSec)*/
94 #define DEFAULT_AUTOSUSPEND_DELAY (10 * 1000)
95
96 /* statistic update interval (mSec) */
97 #define STAT_UPDATE_TIMER (1 * 1000)
98
99 /* defines interrupts from interrupt EP */
100 #define MAX_INT_EP (32)
101 #define INT_EP_INTEP (31)
102 #define INT_EP_OTP_WR_DONE (28)
103 #define INT_EP_EEE_TX_LPI_START (26)
104 #define INT_EP_EEE_TX_LPI_STOP (25)
105 #define INT_EP_EEE_RX_LPI (24)
106 #define INT_EP_MAC_RESET_TIMEOUT (23)
107 #define INT_EP_RDFO (22)
108 #define INT_EP_TXE (21)
109 #define INT_EP_USB_STATUS (20)
110 #define INT_EP_TX_DIS (19)
111 #define INT_EP_RX_DIS (18)
112 #define INT_EP_PHY (17)
113 #define INT_EP_DP (16)
114 #define INT_EP_MAC_ERR (15)
115 #define INT_EP_TDFU (14)
116 #define INT_EP_TDFO (13)
117 #define INT_EP_UTX (12)
118 #define INT_EP_GPIO_11 (11)
119 #define INT_EP_GPIO_10 (10)
120 #define INT_EP_GPIO_9 (9)
121 #define INT_EP_GPIO_8 (8)
122 #define INT_EP_GPIO_7 (7)
123 #define INT_EP_GPIO_6 (6)
124 #define INT_EP_GPIO_5 (5)
125 #define INT_EP_GPIO_4 (4)
126 #define INT_EP_GPIO_3 (3)
127 #define INT_EP_GPIO_2 (2)
128 #define INT_EP_GPIO_1 (1)
129 #define INT_EP_GPIO_0 (0)
130
131 static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {
132 "RX FCS Errors",
133 "RX Alignment Errors",
134 "Rx Fragment Errors",
135 "RX Jabber Errors",
136 "RX Undersize Frame Errors",
137 "RX Oversize Frame Errors",
138 "RX Dropped Frames",
139 "RX Unicast Byte Count",
140 "RX Broadcast Byte Count",
141 "RX Multicast Byte Count",
142 "RX Unicast Frames",
143 "RX Broadcast Frames",
144 "RX Multicast Frames",
145 "RX Pause Frames",
146 "RX 64 Byte Frames",
147 "RX 65 - 127 Byte Frames",
148 "RX 128 - 255 Byte Frames",
149 "RX 256 - 511 Bytes Frames",
150 "RX 512 - 1023 Byte Frames",
151 "RX 1024 - 1518 Byte Frames",
152 "RX Greater 1518 Byte Frames",
153 "EEE RX LPI Transitions",
154 "EEE RX LPI Time",
155 "TX FCS Errors",
156 "TX Excess Deferral Errors",
157 "TX Carrier Errors",
158 "TX Bad Byte Count",
159 "TX Single Collisions",
160 "TX Multiple Collisions",
161 "TX Excessive Collision",
162 "TX Late Collisions",
163 "TX Unicast Byte Count",
164 "TX Broadcast Byte Count",
165 "TX Multicast Byte Count",
166 "TX Unicast Frames",
167 "TX Broadcast Frames",
168 "TX Multicast Frames",
169 "TX Pause Frames",
170 "TX 64 Byte Frames",
171 "TX 65 - 127 Byte Frames",
172 "TX 128 - 255 Byte Frames",
173 "TX 256 - 511 Bytes Frames",
174 "TX 512 - 1023 Byte Frames",
175 "TX 1024 - 1518 Byte Frames",
176 "TX Greater 1518 Byte Frames",
177 "EEE TX LPI Transitions",
178 "EEE TX LPI Time",
179 };
180
181 struct lan78xx_statstage {
182 u32 rx_fcs_errors;
183 u32 rx_alignment_errors;
184 u32 rx_fragment_errors;
185 u32 rx_jabber_errors;
186 u32 rx_undersize_frame_errors;
187 u32 rx_oversize_frame_errors;
188 u32 rx_dropped_frames;
189 u32 rx_unicast_byte_count;
190 u32 rx_broadcast_byte_count;
191 u32 rx_multicast_byte_count;
192 u32 rx_unicast_frames;
193 u32 rx_broadcast_frames;
194 u32 rx_multicast_frames;
195 u32 rx_pause_frames;
196 u32 rx_64_byte_frames;
197 u32 rx_65_127_byte_frames;
198 u32 rx_128_255_byte_frames;
199 u32 rx_256_511_bytes_frames;
200 u32 rx_512_1023_byte_frames;
201 u32 rx_1024_1518_byte_frames;
202 u32 rx_greater_1518_byte_frames;
203 u32 eee_rx_lpi_transitions;
204 u32 eee_rx_lpi_time;
205 u32 tx_fcs_errors;
206 u32 tx_excess_deferral_errors;
207 u32 tx_carrier_errors;
208 u32 tx_bad_byte_count;
209 u32 tx_single_collisions;
210 u32 tx_multiple_collisions;
211 u32 tx_excessive_collision;
212 u32 tx_late_collisions;
213 u32 tx_unicast_byte_count;
214 u32 tx_broadcast_byte_count;
215 u32 tx_multicast_byte_count;
216 u32 tx_unicast_frames;
217 u32 tx_broadcast_frames;
218 u32 tx_multicast_frames;
219 u32 tx_pause_frames;
220 u32 tx_64_byte_frames;
221 u32 tx_65_127_byte_frames;
222 u32 tx_128_255_byte_frames;
223 u32 tx_256_511_bytes_frames;
224 u32 tx_512_1023_byte_frames;
225 u32 tx_1024_1518_byte_frames;
226 u32 tx_greater_1518_byte_frames;
227 u32 eee_tx_lpi_transitions;
228 u32 eee_tx_lpi_time;
229 };
230
231 struct lan78xx_statstage64 {
232 u64 rx_fcs_errors;
233 u64 rx_alignment_errors;
234 u64 rx_fragment_errors;
235 u64 rx_jabber_errors;
236 u64 rx_undersize_frame_errors;
237 u64 rx_oversize_frame_errors;
238 u64 rx_dropped_frames;
239 u64 rx_unicast_byte_count;
240 u64 rx_broadcast_byte_count;
241 u64 rx_multicast_byte_count;
242 u64 rx_unicast_frames;
243 u64 rx_broadcast_frames;
244 u64 rx_multicast_frames;
245 u64 rx_pause_frames;
246 u64 rx_64_byte_frames;
247 u64 rx_65_127_byte_frames;
248 u64 rx_128_255_byte_frames;
249 u64 rx_256_511_bytes_frames;
250 u64 rx_512_1023_byte_frames;
251 u64 rx_1024_1518_byte_frames;
252 u64 rx_greater_1518_byte_frames;
253 u64 eee_rx_lpi_transitions;
254 u64 eee_rx_lpi_time;
255 u64 tx_fcs_errors;
256 u64 tx_excess_deferral_errors;
257 u64 tx_carrier_errors;
258 u64 tx_bad_byte_count;
259 u64 tx_single_collisions;
260 u64 tx_multiple_collisions;
261 u64 tx_excessive_collision;
262 u64 tx_late_collisions;
263 u64 tx_unicast_byte_count;
264 u64 tx_broadcast_byte_count;
265 u64 tx_multicast_byte_count;
266 u64 tx_unicast_frames;
267 u64 tx_broadcast_frames;
268 u64 tx_multicast_frames;
269 u64 tx_pause_frames;
270 u64 tx_64_byte_frames;
271 u64 tx_65_127_byte_frames;
272 u64 tx_128_255_byte_frames;
273 u64 tx_256_511_bytes_frames;
274 u64 tx_512_1023_byte_frames;
275 u64 tx_1024_1518_byte_frames;
276 u64 tx_greater_1518_byte_frames;
277 u64 eee_tx_lpi_transitions;
278 u64 eee_tx_lpi_time;
279 };
280
281 struct lan78xx_net;
282
283 struct lan78xx_priv {
284 struct lan78xx_net *dev;
285 u32 rfe_ctl;
286 u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicat hash table */
287 u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */
288 u32 vlan_table[DP_SEL_VHF_VLAN_LEN];
289 struct mutex dataport_mutex; /* for dataport access */
290 spinlock_t rfe_ctl_lock; /* for rfe register access */
291 struct work_struct set_multicast;
292 struct work_struct set_vlan;
293 u32 wol;
294 };
295
296 enum skb_state {
297 illegal = 0,
298 tx_start,
299 tx_done,
300 rx_start,
301 rx_done,
302 rx_cleanup,
303 unlink_start
304 };
305
306 struct skb_data { /* skb->cb is one of these */
307 struct urb *urb;
308 struct lan78xx_net *dev;
309 enum skb_state state;
310 size_t length;
311 int num_of_packet;
312 };
313
314 struct usb_context {
315 struct usb_ctrlrequest req;
316 struct lan78xx_net *dev;
317 };
318
319 #define EVENT_TX_HALT 0
320 #define EVENT_RX_HALT 1
321 #define EVENT_RX_MEMORY 2
322 #define EVENT_STS_SPLIT 3
323 #define EVENT_LINK_RESET 4
324 #define EVENT_RX_PAUSED 5
325 #define EVENT_DEV_WAKING 6
326 #define EVENT_DEV_ASLEEP 7
327 #define EVENT_DEV_OPEN 8
328 #define EVENT_STAT_UPDATE 9
329
330 struct statstage {
331 struct mutex access_lock; /* for stats access */
332 struct lan78xx_statstage saved;
333 struct lan78xx_statstage rollover_count;
334 struct lan78xx_statstage rollover_max;
335 struct lan78xx_statstage64 curr_stat;
336 };
337
338 struct irq_domain_data {
339 struct irq_domain *irqdomain;
340 unsigned int phyirq;
341 struct irq_chip *irqchip;
342 irq_flow_handler_t irq_handler;
343 u32 irqenable;
344 struct mutex irq_lock; /* for irq bus access */
345 };
346
347 struct lan78xx_net {
348 struct net_device *net;
349 struct usb_device *udev;
350 struct usb_interface *intf;
351 void *driver_priv;
352
353 int rx_qlen;
354 int tx_qlen;
355 struct sk_buff_head rxq;
356 struct sk_buff_head txq;
357 struct sk_buff_head done;
358 struct sk_buff_head rxq_pause;
359 struct sk_buff_head txq_pend;
360
361 struct tasklet_struct bh;
362 struct delayed_work wq;
363
364 struct usb_host_endpoint *ep_blkin;
365 struct usb_host_endpoint *ep_blkout;
366 struct usb_host_endpoint *ep_intr;
367
368 int msg_enable;
369
370 struct urb *urb_intr;
371 struct usb_anchor deferred;
372
373 struct mutex phy_mutex; /* for phy access */
374 unsigned pipe_in, pipe_out, pipe_intr;
375
376 u32 hard_mtu; /* count any extra framing */
377 size_t rx_urb_size; /* size for rx urbs */
378
379 unsigned long flags;
380
381 wait_queue_head_t *wait;
382 unsigned char suspend_count;
383
384 unsigned maxpacket;
385 struct timer_list delay;
386 struct timer_list stat_monitor;
387
388 unsigned long data[5];
389
390 int link_on;
391 u8 mdix_ctrl;
392
393 u32 chipid;
394 u32 chiprev;
395 struct mii_bus *mdiobus;
396 phy_interface_t interface;
397
398 int fc_autoneg;
399 u8 fc_request_control;
400
401 int delta;
402 struct statstage stats;
403
404 struct irq_domain_data domain_data;
405 };
406
407 /* define external phy id */
408 #define PHY_LAN8835 (0x0007C130)
409 #define PHY_KSZ9031RNX (0x00221620)
410
411 /* use ethtool to change the level for any given device */
412 static int msg_level = -1;
413 module_param(msg_level, int, 0);
414 MODULE_PARM_DESC(msg_level, "Override default message level");
415
416 static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
417 {
418 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
419 int ret;
420
421 if (!buf)
422 return -ENOMEM;
423
424 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
425 USB_VENDOR_REQUEST_READ_REGISTER,
426 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
427 0, index, buf, 4, USB_CTRL_GET_TIMEOUT);
428 if (likely(ret >= 0)) {
429 le32_to_cpus(buf);
430 *data = *buf;
431 } else {
432 netdev_warn(dev->net,
433 "Failed to read register index 0x%08x. ret = %d",
434 index, ret);
435 }
436
437 kfree(buf);
438
439 return ret;
440 }
441
442 static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
443 {
444 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
445 int ret;
446
447 if (!buf)
448 return -ENOMEM;
449
450 *buf = data;
451 cpu_to_le32s(buf);
452
453 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
454 USB_VENDOR_REQUEST_WRITE_REGISTER,
455 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
456 0, index, buf, 4, USB_CTRL_SET_TIMEOUT);
457 if (unlikely(ret < 0)) {
458 netdev_warn(dev->net,
459 "Failed to write register index 0x%08x. ret = %d",
460 index, ret);
461 }
462
463 kfree(buf);
464
465 return ret;
466 }
467
468 static int lan78xx_read_stats(struct lan78xx_net *dev,
469 struct lan78xx_statstage *data)
470 {
471 int ret = 0;
472 int i;
473 struct lan78xx_statstage *stats;
474 u32 *src;
475 u32 *dst;
476
477 stats = kmalloc(sizeof(*stats), GFP_KERNEL);
478 if (!stats)
479 return -ENOMEM;
480
481 ret = usb_control_msg(dev->udev,
482 usb_rcvctrlpipe(dev->udev, 0),
483 USB_VENDOR_REQUEST_GET_STATS,
484 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
485 0,
486 0,
487 (void *)stats,
488 sizeof(*stats),
489 USB_CTRL_SET_TIMEOUT);
490 if (likely(ret >= 0)) {
491 src = (u32 *)stats;
492 dst = (u32 *)data;
493 for (i = 0; i < sizeof(*stats)/sizeof(u32); i++) {
494 le32_to_cpus(&src[i]);
495 dst[i] = src[i];
496 }
497 } else {
498 netdev_warn(dev->net,
499 "Failed to read stat ret = 0x%x", ret);
500 }
501
502 kfree(stats);
503
504 return ret;
505 }
506
507 #define check_counter_rollover(struct1, dev_stats, member) { \
508 if (struct1->member < dev_stats.saved.member) \
509 dev_stats.rollover_count.member++; \
510 }
511
512 static void lan78xx_check_stat_rollover(struct lan78xx_net *dev,
513 struct lan78xx_statstage *stats)
514 {
515 check_counter_rollover(stats, dev->stats, rx_fcs_errors);
516 check_counter_rollover(stats, dev->stats, rx_alignment_errors);
517 check_counter_rollover(stats, dev->stats, rx_fragment_errors);
518 check_counter_rollover(stats, dev->stats, rx_jabber_errors);
519 check_counter_rollover(stats, dev->stats, rx_undersize_frame_errors);
520 check_counter_rollover(stats, dev->stats, rx_oversize_frame_errors);
521 check_counter_rollover(stats, dev->stats, rx_dropped_frames);
522 check_counter_rollover(stats, dev->stats, rx_unicast_byte_count);
523 check_counter_rollover(stats, dev->stats, rx_broadcast_byte_count);
524 check_counter_rollover(stats, dev->stats, rx_multicast_byte_count);
525 check_counter_rollover(stats, dev->stats, rx_unicast_frames);
526 check_counter_rollover(stats, dev->stats, rx_broadcast_frames);
527 check_counter_rollover(stats, dev->stats, rx_multicast_frames);
528 check_counter_rollover(stats, dev->stats, rx_pause_frames);
529 check_counter_rollover(stats, dev->stats, rx_64_byte_frames);
530 check_counter_rollover(stats, dev->stats, rx_65_127_byte_frames);
531 check_counter_rollover(stats, dev->stats, rx_128_255_byte_frames);
532 check_counter_rollover(stats, dev->stats, rx_256_511_bytes_frames);
533 check_counter_rollover(stats, dev->stats, rx_512_1023_byte_frames);
534 check_counter_rollover(stats, dev->stats, rx_1024_1518_byte_frames);
535 check_counter_rollover(stats, dev->stats, rx_greater_1518_byte_frames);
536 check_counter_rollover(stats, dev->stats, eee_rx_lpi_transitions);
537 check_counter_rollover(stats, dev->stats, eee_rx_lpi_time);
538 check_counter_rollover(stats, dev->stats, tx_fcs_errors);
539 check_counter_rollover(stats, dev->stats, tx_excess_deferral_errors);
540 check_counter_rollover(stats, dev->stats, tx_carrier_errors);
541 check_counter_rollover(stats, dev->stats, tx_bad_byte_count);
542 check_counter_rollover(stats, dev->stats, tx_single_collisions);
543 check_counter_rollover(stats, dev->stats, tx_multiple_collisions);
544 check_counter_rollover(stats, dev->stats, tx_excessive_collision);
545 check_counter_rollover(stats, dev->stats, tx_late_collisions);
546 check_counter_rollover(stats, dev->stats, tx_unicast_byte_count);
547 check_counter_rollover(stats, dev->stats, tx_broadcast_byte_count);
548 check_counter_rollover(stats, dev->stats, tx_multicast_byte_count);
549 check_counter_rollover(stats, dev->stats, tx_unicast_frames);
550 check_counter_rollover(stats, dev->stats, tx_broadcast_frames);
551 check_counter_rollover(stats, dev->stats, tx_multicast_frames);
552 check_counter_rollover(stats, dev->stats, tx_pause_frames);
553 check_counter_rollover(stats, dev->stats, tx_64_byte_frames);
554 check_counter_rollover(stats, dev->stats, tx_65_127_byte_frames);
555 check_counter_rollover(stats, dev->stats, tx_128_255_byte_frames);
556 check_counter_rollover(stats, dev->stats, tx_256_511_bytes_frames);
557 check_counter_rollover(stats, dev->stats, tx_512_1023_byte_frames);
558 check_counter_rollover(stats, dev->stats, tx_1024_1518_byte_frames);
559 check_counter_rollover(stats, dev->stats, tx_greater_1518_byte_frames);
560 check_counter_rollover(stats, dev->stats, eee_tx_lpi_transitions);
561 check_counter_rollover(stats, dev->stats, eee_tx_lpi_time);
562
563 memcpy(&dev->stats.saved, stats, sizeof(struct lan78xx_statstage));
564 }
565
566 static void lan78xx_update_stats(struct lan78xx_net *dev)
567 {
568 u32 *p, *count, *max;
569 u64 *data;
570 int i;
571 struct lan78xx_statstage lan78xx_stats;
572
573 if (usb_autopm_get_interface(dev->intf) < 0)
574 return;
575
576 p = (u32 *)&lan78xx_stats;
577 count = (u32 *)&dev->stats.rollover_count;
578 max = (u32 *)&dev->stats.rollover_max;
579 data = (u64 *)&dev->stats.curr_stat;
580
581 mutex_lock(&dev->stats.access_lock);
582
583 if (lan78xx_read_stats(dev, &lan78xx_stats) > 0)
584 lan78xx_check_stat_rollover(dev, &lan78xx_stats);
585
586 for (i = 0; i < (sizeof(lan78xx_stats) / (sizeof(u32))); i++)
587 data[i] = (u64)p[i] + ((u64)count[i] * ((u64)max[i] + 1));
588
589 mutex_unlock(&dev->stats.access_lock);
590
591 usb_autopm_put_interface(dev->intf);
592 }
593
594 /* Loop until the read is completed with timeout called with phy_mutex held */
595 static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)
596 {
597 unsigned long start_time = jiffies;
598 u32 val;
599 int ret;
600
601 do {
602 ret = lan78xx_read_reg(dev, MII_ACC, &val);
603 if (unlikely(ret < 0))
604 return -EIO;
605
606 if (!(val & MII_ACC_MII_BUSY_))
607 return 0;
608 } while (!time_after(jiffies, start_time + HZ));
609
610 return -EIO;
611 }
612
613 static inline u32 mii_access(int id, int index, int read)
614 {
615 u32 ret;
616
617 ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;
618 ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;
619 if (read)
620 ret |= MII_ACC_MII_READ_;
621 else
622 ret |= MII_ACC_MII_WRITE_;
623 ret |= MII_ACC_MII_BUSY_;
624
625 return ret;
626 }
627
628 static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
629 {
630 unsigned long start_time = jiffies;
631 u32 val;
632 int ret;
633
634 do {
635 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
636 if (unlikely(ret < 0))
637 return -EIO;
638
639 if (!(val & E2P_CMD_EPC_BUSY_) ||
640 (val & E2P_CMD_EPC_TIMEOUT_))
641 break;
642 usleep_range(40, 100);
643 } while (!time_after(jiffies, start_time + HZ));
644
645 if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
646 netdev_warn(dev->net, "EEPROM read operation timeout");
647 return -EIO;
648 }
649
650 return 0;
651 }
652
653 static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
654 {
655 unsigned long start_time = jiffies;
656 u32 val;
657 int ret;
658
659 do {
660 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
661 if (unlikely(ret < 0))
662 return -EIO;
663
664 if (!(val & E2P_CMD_EPC_BUSY_))
665 return 0;
666
667 usleep_range(40, 100);
668 } while (!time_after(jiffies, start_time + HZ));
669
670 netdev_warn(dev->net, "EEPROM is busy");
671 return -EIO;
672 }
673
674 static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
675 u32 length, u8 *data)
676 {
677 u32 val;
678 u32 saved;
679 int i, ret;
680 int retval;
681
682 /* depends on chip, some EEPROM pins are muxed with LED function.
683 * disable & restore LED function to access EEPROM.
684 */
685 ret = lan78xx_read_reg(dev, HW_CFG, &val);
686 saved = val;
687 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
688 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
689 ret = lan78xx_write_reg(dev, HW_CFG, val);
690 }
691
692 retval = lan78xx_eeprom_confirm_not_busy(dev);
693 if (retval)
694 return retval;
695
696 for (i = 0; i < length; i++) {
697 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
698 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
699 ret = lan78xx_write_reg(dev, E2P_CMD, val);
700 if (unlikely(ret < 0)) {
701 retval = -EIO;
702 goto exit;
703 }
704
705 retval = lan78xx_wait_eeprom(dev);
706 if (retval < 0)
707 goto exit;
708
709 ret = lan78xx_read_reg(dev, E2P_DATA, &val);
710 if (unlikely(ret < 0)) {
711 retval = -EIO;
712 goto exit;
713 }
714
715 data[i] = val & 0xFF;
716 offset++;
717 }
718
719 retval = 0;
720 exit:
721 if (dev->chipid == ID_REV_CHIP_ID_7800_)
722 ret = lan78xx_write_reg(dev, HW_CFG, saved);
723
724 return retval;
725 }
726
727 static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
728 u32 length, u8 *data)
729 {
730 u8 sig;
731 int ret;
732
733 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
734 if ((ret == 0) && (sig == EEPROM_INDICATOR))
735 ret = lan78xx_read_raw_eeprom(dev, offset, length, data);
736 else
737 ret = -EINVAL;
738
739 return ret;
740 }
741
742 static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
743 u32 length, u8 *data)
744 {
745 u32 val;
746 u32 saved;
747 int i, ret;
748 int retval;
749
750 /* depends on chip, some EEPROM pins are muxed with LED function.
751 * disable & restore LED function to access EEPROM.
752 */
753 ret = lan78xx_read_reg(dev, HW_CFG, &val);
754 saved = val;
755 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
756 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
757 ret = lan78xx_write_reg(dev, HW_CFG, val);
758 }
759
760 retval = lan78xx_eeprom_confirm_not_busy(dev);
761 if (retval)
762 goto exit;
763
764 /* Issue write/erase enable command */
765 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
766 ret = lan78xx_write_reg(dev, E2P_CMD, val);
767 if (unlikely(ret < 0)) {
768 retval = -EIO;
769 goto exit;
770 }
771
772 retval = lan78xx_wait_eeprom(dev);
773 if (retval < 0)
774 goto exit;
775
776 for (i = 0; i < length; i++) {
777 /* Fill data register */
778 val = data[i];
779 ret = lan78xx_write_reg(dev, E2P_DATA, val);
780 if (ret < 0) {
781 retval = -EIO;
782 goto exit;
783 }
784
785 /* Send "write" command */
786 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
787 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
788 ret = lan78xx_write_reg(dev, E2P_CMD, val);
789 if (ret < 0) {
790 retval = -EIO;
791 goto exit;
792 }
793
794 retval = lan78xx_wait_eeprom(dev);
795 if (retval < 0)
796 goto exit;
797
798 offset++;
799 }
800
801 retval = 0;
802 exit:
803 if (dev->chipid == ID_REV_CHIP_ID_7800_)
804 ret = lan78xx_write_reg(dev, HW_CFG, saved);
805
806 return retval;
807 }
808
809 static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
810 u32 length, u8 *data)
811 {
812 int i;
813 int ret;
814 u32 buf;
815 unsigned long timeout;
816
817 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
818
819 if (buf & OTP_PWR_DN_PWRDN_N_) {
820 /* clear it and wait to be cleared */
821 ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
822
823 timeout = jiffies + HZ;
824 do {
825 usleep_range(1, 10);
826 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
827 if (time_after(jiffies, timeout)) {
828 netdev_warn(dev->net,
829 "timeout on OTP_PWR_DN");
830 return -EIO;
831 }
832 } while (buf & OTP_PWR_DN_PWRDN_N_);
833 }
834
835 for (i = 0; i < length; i++) {
836 ret = lan78xx_write_reg(dev, OTP_ADDR1,
837 ((offset + i) >> 8) & OTP_ADDR1_15_11);
838 ret = lan78xx_write_reg(dev, OTP_ADDR2,
839 ((offset + i) & OTP_ADDR2_10_3));
840
841 ret = lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
842 ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
843
844 timeout = jiffies + HZ;
845 do {
846 udelay(1);
847 ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
848 if (time_after(jiffies, timeout)) {
849 netdev_warn(dev->net,
850 "timeout on OTP_STATUS");
851 return -EIO;
852 }
853 } while (buf & OTP_STATUS_BUSY_);
854
855 ret = lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
856
857 data[i] = (u8)(buf & 0xFF);
858 }
859
860 return 0;
861 }
862
863 static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
864 u32 length, u8 *data)
865 {
866 int i;
867 int ret;
868 u32 buf;
869 unsigned long timeout;
870
871 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
872
873 if (buf & OTP_PWR_DN_PWRDN_N_) {
874 /* clear it and wait to be cleared */
875 ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
876
877 timeout = jiffies + HZ;
878 do {
879 udelay(1);
880 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
881 if (time_after(jiffies, timeout)) {
882 netdev_warn(dev->net,
883 "timeout on OTP_PWR_DN completion");
884 return -EIO;
885 }
886 } while (buf & OTP_PWR_DN_PWRDN_N_);
887 }
888
889 /* set to BYTE program mode */
890 ret = lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
891
892 for (i = 0; i < length; i++) {
893 ret = lan78xx_write_reg(dev, OTP_ADDR1,
894 ((offset + i) >> 8) & OTP_ADDR1_15_11);
895 ret = lan78xx_write_reg(dev, OTP_ADDR2,
896 ((offset + i) & OTP_ADDR2_10_3));
897 ret = lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
898 ret = lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
899 ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
900
901 timeout = jiffies + HZ;
902 do {
903 udelay(1);
904 ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
905 if (time_after(jiffies, timeout)) {
906 netdev_warn(dev->net,
907 "Timeout on OTP_STATUS completion");
908 return -EIO;
909 }
910 } while (buf & OTP_STATUS_BUSY_);
911 }
912
913 return 0;
914 }
915
916 static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
917 u32 length, u8 *data)
918 {
919 u8 sig;
920 int ret;
921
922 ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
923
924 if (ret == 0) {
925 if (sig == OTP_INDICATOR_1)
926 offset = offset;
927 else if (sig == OTP_INDICATOR_2)
928 offset += 0x100;
929 else
930 ret = -EINVAL;
931 ret = lan78xx_read_raw_otp(dev, offset, length, data);
932 }
933
934 return ret;
935 }
936
937 static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
938 {
939 int i, ret;
940
941 for (i = 0; i < 100; i++) {
942 u32 dp_sel;
943
944 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
945 if (unlikely(ret < 0))
946 return -EIO;
947
948 if (dp_sel & DP_SEL_DPRDY_)
949 return 0;
950
951 usleep_range(40, 100);
952 }
953
954 netdev_warn(dev->net, "lan78xx_dataport_wait_not_busy timed out");
955
956 return -EIO;
957 }
958
959 static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
960 u32 addr, u32 length, u32 *buf)
961 {
962 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
963 u32 dp_sel;
964 int i, ret;
965
966 if (usb_autopm_get_interface(dev->intf) < 0)
967 return 0;
968
969 mutex_lock(&pdata->dataport_mutex);
970
971 ret = lan78xx_dataport_wait_not_busy(dev);
972 if (ret < 0)
973 goto done;
974
975 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
976
977 dp_sel &= ~DP_SEL_RSEL_MASK_;
978 dp_sel |= ram_select;
979 ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);
980
981 for (i = 0; i < length; i++) {
982 ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
983
984 ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
985
986 ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
987
988 ret = lan78xx_dataport_wait_not_busy(dev);
989 if (ret < 0)
990 goto done;
991 }
992
993 done:
994 mutex_unlock(&pdata->dataport_mutex);
995 usb_autopm_put_interface(dev->intf);
996
997 return ret;
998 }
999
1000 static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,
1001 int index, u8 addr[ETH_ALEN])
1002 {
1003 u32 temp;
1004
1005 if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {
1006 temp = addr[3];
1007 temp = addr[2] | (temp << 8);
1008 temp = addr[1] | (temp << 8);
1009 temp = addr[0] | (temp << 8);
1010 pdata->pfilter_table[index][1] = temp;
1011 temp = addr[5];
1012 temp = addr[4] | (temp << 8);
1013 temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;
1014 pdata->pfilter_table[index][0] = temp;
1015 }
1016 }
1017
1018 /* returns hash bit number for given MAC address */
1019 static inline u32 lan78xx_hash(char addr[ETH_ALEN])
1020 {
1021 return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
1022 }
1023
1024 static void lan78xx_deferred_multicast_write(struct work_struct *param)
1025 {
1026 struct lan78xx_priv *pdata =
1027 container_of(param, struct lan78xx_priv, set_multicast);
1028 struct lan78xx_net *dev = pdata->dev;
1029 int i;
1030 int ret;
1031
1032 netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
1033 pdata->rfe_ctl);
1034
1035 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,
1036 DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
1037
1038 for (i = 1; i < NUM_OF_MAF; i++) {
1039 ret = lan78xx_write_reg(dev, MAF_HI(i), 0);
1040 ret = lan78xx_write_reg(dev, MAF_LO(i),
1041 pdata->pfilter_table[i][1]);
1042 ret = lan78xx_write_reg(dev, MAF_HI(i),
1043 pdata->pfilter_table[i][0]);
1044 }
1045
1046 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1047 }
1048
1049 static void lan78xx_set_multicast(struct net_device *netdev)
1050 {
1051 struct lan78xx_net *dev = netdev_priv(netdev);
1052 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1053 unsigned long flags;
1054 int i;
1055
1056 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1057
1058 pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |
1059 RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
1060
1061 for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
1062 pdata->mchash_table[i] = 0;
1063 /* pfilter_table[0] has own HW address */
1064 for (i = 1; i < NUM_OF_MAF; i++) {
1065 pdata->pfilter_table[i][0] =
1066 pdata->pfilter_table[i][1] = 0;
1067 }
1068
1069 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;
1070
1071 if (dev->net->flags & IFF_PROMISC) {
1072 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
1073 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;
1074 } else {
1075 if (dev->net->flags & IFF_ALLMULTI) {
1076 netif_dbg(dev, drv, dev->net,
1077 "receive all multicast enabled");
1078 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;
1079 }
1080 }
1081
1082 if (netdev_mc_count(dev->net)) {
1083 struct netdev_hw_addr *ha;
1084 int i;
1085
1086 netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
1087
1088 pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;
1089
1090 i = 1;
1091 netdev_for_each_mc_addr(ha, netdev) {
1092 /* set first 32 into Perfect Filter */
1093 if (i < 33) {
1094 lan78xx_set_addr_filter(pdata, i, ha->addr);
1095 } else {
1096 u32 bitnum = lan78xx_hash(ha->addr);
1097
1098 pdata->mchash_table[bitnum / 32] |=
1099 (1 << (bitnum % 32));
1100 pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;
1101 }
1102 i++;
1103 }
1104 }
1105
1106 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1107
1108 /* defer register writes to a sleepable context */
1109 schedule_work(&pdata->set_multicast);
1110 }
1111
1112 static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1113 u16 lcladv, u16 rmtadv)
1114 {
1115 u32 flow = 0, fct_flow = 0;
1116 int ret;
1117 u8 cap;
1118
1119 if (dev->fc_autoneg)
1120 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1121 else
1122 cap = dev->fc_request_control;
1123
1124 if (cap & FLOW_CTRL_TX)
1125 flow |= (FLOW_CR_TX_FCEN_ | 0xFFFF);
1126
1127 if (cap & FLOW_CTRL_RX)
1128 flow |= FLOW_CR_RX_FCEN_;
1129
1130 if (dev->udev->speed == USB_SPEED_SUPER)
1131 fct_flow = 0x817;
1132 else if (dev->udev->speed == USB_SPEED_HIGH)
1133 fct_flow = 0x211;
1134
1135 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1136 (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
1137 (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
1138
1139 ret = lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1140
1141 /* threshold value should be set before enabling flow */
1142 ret = lan78xx_write_reg(dev, FLOW, flow);
1143
1144 return 0;
1145 }
1146
1147 static int lan78xx_link_reset(struct lan78xx_net *dev)
1148 {
1149 struct phy_device *phydev = dev->net->phydev;
1150 struct ethtool_link_ksettings ecmd;
1151 int ladv, radv, ret;
1152 u32 buf;
1153
1154 /* clear LAN78xx interrupt status */
1155 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1156 if (unlikely(ret < 0))
1157 return -EIO;
1158
1159 phy_read_status(phydev);
1160
1161 if (!phydev->link && dev->link_on) {
1162 dev->link_on = false;
1163
1164 /* reset MAC */
1165 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1166 if (unlikely(ret < 0))
1167 return -EIO;
1168 buf |= MAC_CR_RST_;
1169 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1170 if (unlikely(ret < 0))
1171 return -EIO;
1172
1173 del_timer(&dev->stat_monitor);
1174 } else if (phydev->link && !dev->link_on) {
1175 dev->link_on = true;
1176
1177 phy_ethtool_ksettings_get(phydev, &ecmd);
1178
1179 if (dev->udev->speed == USB_SPEED_SUPER) {
1180 if (ecmd.base.speed == 1000) {
1181 /* disable U2 */
1182 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1183 buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1184 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1185 /* enable U1 */
1186 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1187 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1188 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1189 } else {
1190 /* enable U1 & U2 */
1191 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1192 buf |= USB_CFG1_DEV_U2_INIT_EN_;
1193 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1194 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1195 }
1196 }
1197
1198 ladv = phy_read(phydev, MII_ADVERTISE);
1199 if (ladv < 0)
1200 return ladv;
1201
1202 radv = phy_read(phydev, MII_LPA);
1203 if (radv < 0)
1204 return radv;
1205
1206 netif_dbg(dev, link, dev->net,
1207 "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1208 ecmd.base.speed, ecmd.base.duplex, ladv, radv);
1209
1210 ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,
1211 radv);
1212
1213 if (!timer_pending(&dev->stat_monitor)) {
1214 dev->delta = 1;
1215 mod_timer(&dev->stat_monitor,
1216 jiffies + STAT_UPDATE_TIMER);
1217 }
1218 }
1219
1220 return ret;
1221 }
1222
1223 /* some work can't be done in tasklets, so we use keventd
1224 *
1225 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
1226 * but tasklet_schedule() doesn't. hope the failure is rare.
1227 */
1228 static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1229 {
1230 set_bit(work, &dev->flags);
1231 if (!schedule_delayed_work(&dev->wq, 0))
1232 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1233 }
1234
1235 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1236 {
1237 u32 intdata;
1238
1239 if (urb->actual_length != 4) {
1240 netdev_warn(dev->net,
1241 "unexpected urb length %d", urb->actual_length);
1242 return;
1243 }
1244
1245 memcpy(&intdata, urb->transfer_buffer, 4);
1246 le32_to_cpus(&intdata);
1247
1248 if (intdata & INT_ENP_PHY_INT) {
1249 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1250 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1251
1252 if (dev->domain_data.phyirq > 0)
1253 generic_handle_irq(dev->domain_data.phyirq);
1254 } else
1255 netdev_warn(dev->net,
1256 "unexpected interrupt: 0x%08x\n", intdata);
1257 }
1258
1259 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1260 {
1261 return MAX_EEPROM_SIZE;
1262 }
1263
1264 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1265 struct ethtool_eeprom *ee, u8 *data)
1266 {
1267 struct lan78xx_net *dev = netdev_priv(netdev);
1268 int ret;
1269
1270 ret = usb_autopm_get_interface(dev->intf);
1271 if (ret)
1272 return ret;
1273
1274 ee->magic = LAN78XX_EEPROM_MAGIC;
1275
1276 ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1277
1278 usb_autopm_put_interface(dev->intf);
1279
1280 return ret;
1281 }
1282
1283 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1284 struct ethtool_eeprom *ee, u8 *data)
1285 {
1286 struct lan78xx_net *dev = netdev_priv(netdev);
1287 int ret;
1288
1289 ret = usb_autopm_get_interface(dev->intf);
1290 if (ret)
1291 return ret;
1292
1293 /* Invalid EEPROM_INDICATOR at offset zero will result in a failure
1294 * to load data from EEPROM
1295 */
1296 if (ee->magic == LAN78XX_EEPROM_MAGIC)
1297 ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1298 else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1299 (ee->offset == 0) &&
1300 (ee->len == 512) &&
1301 (data[0] == OTP_INDICATOR_1))
1302 ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1303
1304 usb_autopm_put_interface(dev->intf);
1305
1306 return ret;
1307 }
1308
1309 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1310 u8 *data)
1311 {
1312 if (stringset == ETH_SS_STATS)
1313 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1314 }
1315
1316 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1317 {
1318 if (sset == ETH_SS_STATS)
1319 return ARRAY_SIZE(lan78xx_gstrings);
1320 else
1321 return -EOPNOTSUPP;
1322 }
1323
1324 static void lan78xx_get_stats(struct net_device *netdev,
1325 struct ethtool_stats *stats, u64 *data)
1326 {
1327 struct lan78xx_net *dev = netdev_priv(netdev);
1328
1329 lan78xx_update_stats(dev);
1330
1331 mutex_lock(&dev->stats.access_lock);
1332 memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1333 mutex_unlock(&dev->stats.access_lock);
1334 }
1335
1336 static void lan78xx_get_wol(struct net_device *netdev,
1337 struct ethtool_wolinfo *wol)
1338 {
1339 struct lan78xx_net *dev = netdev_priv(netdev);
1340 int ret;
1341 u32 buf;
1342 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1343
1344 if (usb_autopm_get_interface(dev->intf) < 0)
1345 return;
1346
1347 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1348 if (unlikely(ret < 0)) {
1349 wol->supported = 0;
1350 wol->wolopts = 0;
1351 } else {
1352 if (buf & USB_CFG_RMT_WKP_) {
1353 wol->supported = WAKE_ALL;
1354 wol->wolopts = pdata->wol;
1355 } else {
1356 wol->supported = 0;
1357 wol->wolopts = 0;
1358 }
1359 }
1360
1361 usb_autopm_put_interface(dev->intf);
1362 }
1363
1364 static int lan78xx_set_wol(struct net_device *netdev,
1365 struct ethtool_wolinfo *wol)
1366 {
1367 struct lan78xx_net *dev = netdev_priv(netdev);
1368 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1369 int ret;
1370
1371 ret = usb_autopm_get_interface(dev->intf);
1372 if (ret < 0)
1373 return ret;
1374
1375 pdata->wol = 0;
1376 if (wol->wolopts & WAKE_UCAST)
1377 pdata->wol |= WAKE_UCAST;
1378 if (wol->wolopts & WAKE_MCAST)
1379 pdata->wol |= WAKE_MCAST;
1380 if (wol->wolopts & WAKE_BCAST)
1381 pdata->wol |= WAKE_BCAST;
1382 if (wol->wolopts & WAKE_MAGIC)
1383 pdata->wol |= WAKE_MAGIC;
1384 if (wol->wolopts & WAKE_PHY)
1385 pdata->wol |= WAKE_PHY;
1386 if (wol->wolopts & WAKE_ARP)
1387 pdata->wol |= WAKE_ARP;
1388
1389 device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1390
1391 phy_ethtool_set_wol(netdev->phydev, wol);
1392
1393 usb_autopm_put_interface(dev->intf);
1394
1395 return ret;
1396 }
1397
1398 static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1399 {
1400 struct lan78xx_net *dev = netdev_priv(net);
1401 struct phy_device *phydev = net->phydev;
1402 int ret;
1403 u32 buf;
1404
1405 ret = usb_autopm_get_interface(dev->intf);
1406 if (ret < 0)
1407 return ret;
1408
1409 ret = phy_ethtool_get_eee(phydev, edata);
1410 if (ret < 0)
1411 goto exit;
1412
1413 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1414 if (buf & MAC_CR_EEE_EN_) {
1415 edata->eee_enabled = true;
1416 edata->eee_active = !!(edata->advertised &
1417 edata->lp_advertised);
1418 edata->tx_lpi_enabled = true;
1419 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1420 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1421 edata->tx_lpi_timer = buf;
1422 } else {
1423 edata->eee_enabled = false;
1424 edata->eee_active = false;
1425 edata->tx_lpi_enabled = false;
1426 edata->tx_lpi_timer = 0;
1427 }
1428
1429 ret = 0;
1430 exit:
1431 usb_autopm_put_interface(dev->intf);
1432
1433 return ret;
1434 }
1435
1436 static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1437 {
1438 struct lan78xx_net *dev = netdev_priv(net);
1439 int ret;
1440 u32 buf;
1441
1442 ret = usb_autopm_get_interface(dev->intf);
1443 if (ret < 0)
1444 return ret;
1445
1446 if (edata->eee_enabled) {
1447 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1448 buf |= MAC_CR_EEE_EN_;
1449 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1450
1451 phy_ethtool_set_eee(net->phydev, edata);
1452
1453 buf = (u32)edata->tx_lpi_timer;
1454 ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1455 } else {
1456 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1457 buf &= ~MAC_CR_EEE_EN_;
1458 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1459 }
1460
1461 usb_autopm_put_interface(dev->intf);
1462
1463 return 0;
1464 }
1465
1466 static u32 lan78xx_get_link(struct net_device *net)
1467 {
1468 phy_read_status(net->phydev);
1469
1470 return net->phydev->link;
1471 }
1472
1473 static void lan78xx_get_drvinfo(struct net_device *net,
1474 struct ethtool_drvinfo *info)
1475 {
1476 struct lan78xx_net *dev = netdev_priv(net);
1477
1478 strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1479 strncpy(info->version, DRIVER_VERSION, sizeof(info->version));
1480 usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1481 }
1482
1483 static u32 lan78xx_get_msglevel(struct net_device *net)
1484 {
1485 struct lan78xx_net *dev = netdev_priv(net);
1486
1487 return dev->msg_enable;
1488 }
1489
1490 static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1491 {
1492 struct lan78xx_net *dev = netdev_priv(net);
1493
1494 dev->msg_enable = level;
1495 }
1496
1497 static int lan78xx_get_link_ksettings(struct net_device *net,
1498 struct ethtool_link_ksettings *cmd)
1499 {
1500 struct lan78xx_net *dev = netdev_priv(net);
1501 struct phy_device *phydev = net->phydev;
1502 int ret;
1503
1504 ret = usb_autopm_get_interface(dev->intf);
1505 if (ret < 0)
1506 return ret;
1507
1508 phy_ethtool_ksettings_get(phydev, cmd);
1509
1510 usb_autopm_put_interface(dev->intf);
1511
1512 return ret;
1513 }
1514
1515 static int lan78xx_set_link_ksettings(struct net_device *net,
1516 const struct ethtool_link_ksettings *cmd)
1517 {
1518 struct lan78xx_net *dev = netdev_priv(net);
1519 struct phy_device *phydev = net->phydev;
1520 int ret = 0;
1521 int temp;
1522
1523 ret = usb_autopm_get_interface(dev->intf);
1524 if (ret < 0)
1525 return ret;
1526
1527 /* change speed & duplex */
1528 ret = phy_ethtool_ksettings_set(phydev, cmd);
1529
1530 if (!cmd->base.autoneg) {
1531 /* force link down */
1532 temp = phy_read(phydev, MII_BMCR);
1533 phy_write(phydev, MII_BMCR, temp | BMCR_LOOPBACK);
1534 mdelay(1);
1535 phy_write(phydev, MII_BMCR, temp);
1536 }
1537
1538 usb_autopm_put_interface(dev->intf);
1539
1540 return ret;
1541 }
1542
1543 static void lan78xx_get_pause(struct net_device *net,
1544 struct ethtool_pauseparam *pause)
1545 {
1546 struct lan78xx_net *dev = netdev_priv(net);
1547 struct phy_device *phydev = net->phydev;
1548 struct ethtool_link_ksettings ecmd;
1549
1550 phy_ethtool_ksettings_get(phydev, &ecmd);
1551
1552 pause->autoneg = dev->fc_autoneg;
1553
1554 if (dev->fc_request_control & FLOW_CTRL_TX)
1555 pause->tx_pause = 1;
1556
1557 if (dev->fc_request_control & FLOW_CTRL_RX)
1558 pause->rx_pause = 1;
1559 }
1560
1561 static int lan78xx_set_pause(struct net_device *net,
1562 struct ethtool_pauseparam *pause)
1563 {
1564 struct lan78xx_net *dev = netdev_priv(net);
1565 struct phy_device *phydev = net->phydev;
1566 struct ethtool_link_ksettings ecmd;
1567 int ret;
1568
1569 phy_ethtool_ksettings_get(phydev, &ecmd);
1570
1571 if (pause->autoneg && !ecmd.base.autoneg) {
1572 ret = -EINVAL;
1573 goto exit;
1574 }
1575
1576 dev->fc_request_control = 0;
1577 if (pause->rx_pause)
1578 dev->fc_request_control |= FLOW_CTRL_RX;
1579
1580 if (pause->tx_pause)
1581 dev->fc_request_control |= FLOW_CTRL_TX;
1582
1583 if (ecmd.base.autoneg) {
1584 u32 mii_adv;
1585 u32 advertising;
1586
1587 ethtool_convert_link_mode_to_legacy_u32(
1588 &advertising, ecmd.link_modes.advertising);
1589
1590 advertising &= ~(ADVERTISED_Pause | ADVERTISED_Asym_Pause);
1591 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
1592 advertising |= mii_adv_to_ethtool_adv_t(mii_adv);
1593
1594 ethtool_convert_legacy_u32_to_link_mode(
1595 ecmd.link_modes.advertising, advertising);
1596
1597 phy_ethtool_ksettings_set(phydev, &ecmd);
1598 }
1599
1600 dev->fc_autoneg = pause->autoneg;
1601
1602 ret = 0;
1603 exit:
1604 return ret;
1605 }
1606
1607 static const struct ethtool_ops lan78xx_ethtool_ops = {
1608 .get_link = lan78xx_get_link,
1609 .nway_reset = phy_ethtool_nway_reset,
1610 .get_drvinfo = lan78xx_get_drvinfo,
1611 .get_msglevel = lan78xx_get_msglevel,
1612 .set_msglevel = lan78xx_set_msglevel,
1613 .get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1614 .get_eeprom = lan78xx_ethtool_get_eeprom,
1615 .set_eeprom = lan78xx_ethtool_set_eeprom,
1616 .get_ethtool_stats = lan78xx_get_stats,
1617 .get_sset_count = lan78xx_get_sset_count,
1618 .get_strings = lan78xx_get_strings,
1619 .get_wol = lan78xx_get_wol,
1620 .set_wol = lan78xx_set_wol,
1621 .get_eee = lan78xx_get_eee,
1622 .set_eee = lan78xx_set_eee,
1623 .get_pauseparam = lan78xx_get_pause,
1624 .set_pauseparam = lan78xx_set_pause,
1625 .get_link_ksettings = lan78xx_get_link_ksettings,
1626 .set_link_ksettings = lan78xx_set_link_ksettings,
1627 };
1628
1629 static int lan78xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
1630 {
1631 if (!netif_running(netdev))
1632 return -EINVAL;
1633
1634 return phy_mii_ioctl(netdev->phydev, rq, cmd);
1635 }
1636
1637 static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1638 {
1639 u32 addr_lo, addr_hi;
1640 int ret;
1641 u8 addr[6];
1642
1643 ret = lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1644 ret = lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1645
1646 addr[0] = addr_lo & 0xFF;
1647 addr[1] = (addr_lo >> 8) & 0xFF;
1648 addr[2] = (addr_lo >> 16) & 0xFF;
1649 addr[3] = (addr_lo >> 24) & 0xFF;
1650 addr[4] = addr_hi & 0xFF;
1651 addr[5] = (addr_hi >> 8) & 0xFF;
1652
1653 if (!is_valid_ether_addr(addr)) {
1654 /* reading mac address from EEPROM or OTP */
1655 if ((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
1656 addr) == 0) ||
1657 (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
1658 addr) == 0)) {
1659 if (is_valid_ether_addr(addr)) {
1660 /* eeprom values are valid so use them */
1661 netif_dbg(dev, ifup, dev->net,
1662 "MAC address read from EEPROM");
1663 } else {
1664 /* generate random MAC */
1665 random_ether_addr(addr);
1666 netif_dbg(dev, ifup, dev->net,
1667 "MAC address set to random addr");
1668 }
1669
1670 addr_lo = addr[0] | (addr[1] << 8) |
1671 (addr[2] << 16) | (addr[3] << 24);
1672 addr_hi = addr[4] | (addr[5] << 8);
1673
1674 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1675 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1676 } else {
1677 /* generate random MAC */
1678 random_ether_addr(addr);
1679 netif_dbg(dev, ifup, dev->net,
1680 "MAC address set to random addr");
1681 }
1682 }
1683
1684 ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1685 ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1686
1687 ether_addr_copy(dev->net->dev_addr, addr);
1688 }
1689
1690 /* MDIO read and write wrappers for phylib */
1691 static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
1692 {
1693 struct lan78xx_net *dev = bus->priv;
1694 u32 val, addr;
1695 int ret;
1696
1697 ret = usb_autopm_get_interface(dev->intf);
1698 if (ret < 0)
1699 return ret;
1700
1701 mutex_lock(&dev->phy_mutex);
1702
1703 /* confirm MII not busy */
1704 ret = lan78xx_phy_wait_not_busy(dev);
1705 if (ret < 0)
1706 goto done;
1707
1708 /* set the address, index & direction (read from PHY) */
1709 addr = mii_access(phy_id, idx, MII_READ);
1710 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1711
1712 ret = lan78xx_phy_wait_not_busy(dev);
1713 if (ret < 0)
1714 goto done;
1715
1716 ret = lan78xx_read_reg(dev, MII_DATA, &val);
1717
1718 ret = (int)(val & 0xFFFF);
1719
1720 done:
1721 mutex_unlock(&dev->phy_mutex);
1722 usb_autopm_put_interface(dev->intf);
1723
1724 return ret;
1725 }
1726
1727 static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
1728 u16 regval)
1729 {
1730 struct lan78xx_net *dev = bus->priv;
1731 u32 val, addr;
1732 int ret;
1733
1734 ret = usb_autopm_get_interface(dev->intf);
1735 if (ret < 0)
1736 return ret;
1737
1738 mutex_lock(&dev->phy_mutex);
1739
1740 /* confirm MII not busy */
1741 ret = lan78xx_phy_wait_not_busy(dev);
1742 if (ret < 0)
1743 goto done;
1744
1745 val = (u32)regval;
1746 ret = lan78xx_write_reg(dev, MII_DATA, val);
1747
1748 /* set the address, index & direction (write to PHY) */
1749 addr = mii_access(phy_id, idx, MII_WRITE);
1750 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1751
1752 ret = lan78xx_phy_wait_not_busy(dev);
1753 if (ret < 0)
1754 goto done;
1755
1756 done:
1757 mutex_unlock(&dev->phy_mutex);
1758 usb_autopm_put_interface(dev->intf);
1759 return 0;
1760 }
1761
1762 static int lan78xx_mdio_init(struct lan78xx_net *dev)
1763 {
1764 int ret;
1765
1766 dev->mdiobus = mdiobus_alloc();
1767 if (!dev->mdiobus) {
1768 netdev_err(dev->net, "can't allocate MDIO bus\n");
1769 return -ENOMEM;
1770 }
1771
1772 dev->mdiobus->priv = (void *)dev;
1773 dev->mdiobus->read = lan78xx_mdiobus_read;
1774 dev->mdiobus->write = lan78xx_mdiobus_write;
1775 dev->mdiobus->name = "lan78xx-mdiobus";
1776
1777 snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
1778 dev->udev->bus->busnum, dev->udev->devnum);
1779
1780 switch (dev->chipid) {
1781 case ID_REV_CHIP_ID_7800_:
1782 case ID_REV_CHIP_ID_7850_:
1783 /* set to internal PHY id */
1784 dev->mdiobus->phy_mask = ~(1 << 1);
1785 break;
1786 case ID_REV_CHIP_ID_7801_:
1787 /* scan thru PHYAD[2..0] */
1788 dev->mdiobus->phy_mask = ~(0xFF);
1789 break;
1790 }
1791
1792 ret = mdiobus_register(dev->mdiobus);
1793 if (ret) {
1794 netdev_err(dev->net, "can't register MDIO bus\n");
1795 goto exit1;
1796 }
1797
1798 netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
1799 return 0;
1800 exit1:
1801 mdiobus_free(dev->mdiobus);
1802 return ret;
1803 }
1804
1805 static void lan78xx_remove_mdio(struct lan78xx_net *dev)
1806 {
1807 mdiobus_unregister(dev->mdiobus);
1808 mdiobus_free(dev->mdiobus);
1809 }
1810
1811 static void lan78xx_link_status_change(struct net_device *net)
1812 {
1813 struct phy_device *phydev = net->phydev;
1814 int ret, temp;
1815
1816 /* At forced 100 F/H mode, chip may fail to set mode correctly
1817 * when cable is switched between long(~50+m) and short one.
1818 * As workaround, set to 10 before setting to 100
1819 * at forced 100 F/H mode.
1820 */
1821 if (!phydev->autoneg && (phydev->speed == 100)) {
1822 /* disable phy interrupt */
1823 temp = phy_read(phydev, LAN88XX_INT_MASK);
1824 temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_;
1825 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1826
1827 temp = phy_read(phydev, MII_BMCR);
1828 temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000);
1829 phy_write(phydev, MII_BMCR, temp); /* set to 10 first */
1830 temp |= BMCR_SPEED100;
1831 phy_write(phydev, MII_BMCR, temp); /* set to 100 later */
1832
1833 /* clear pending interrupt generated while workaround */
1834 temp = phy_read(phydev, LAN88XX_INT_STS);
1835
1836 /* enable phy interrupt back */
1837 temp = phy_read(phydev, LAN88XX_INT_MASK);
1838 temp |= LAN88XX_INT_MASK_MDINTPIN_EN_;
1839 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1840 }
1841 }
1842
1843 static int irq_map(struct irq_domain *d, unsigned int irq,
1844 irq_hw_number_t hwirq)
1845 {
1846 struct irq_domain_data *data = d->host_data;
1847
1848 irq_set_chip_data(irq, data);
1849 irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);
1850 irq_set_noprobe(irq);
1851
1852 return 0;
1853 }
1854
1855 static void irq_unmap(struct irq_domain *d, unsigned int irq)
1856 {
1857 irq_set_chip_and_handler(irq, NULL, NULL);
1858 irq_set_chip_data(irq, NULL);
1859 }
1860
1861 static const struct irq_domain_ops chip_domain_ops = {
1862 .map = irq_map,
1863 .unmap = irq_unmap,
1864 };
1865
1866 static void lan78xx_irq_mask(struct irq_data *irqd)
1867 {
1868 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1869
1870 data->irqenable &= ~BIT(irqd_to_hwirq(irqd));
1871 }
1872
1873 static void lan78xx_irq_unmask(struct irq_data *irqd)
1874 {
1875 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1876
1877 data->irqenable |= BIT(irqd_to_hwirq(irqd));
1878 }
1879
1880 static void lan78xx_irq_bus_lock(struct irq_data *irqd)
1881 {
1882 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1883
1884 mutex_lock(&data->irq_lock);
1885 }
1886
1887 static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
1888 {
1889 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1890 struct lan78xx_net *dev =
1891 container_of(data, struct lan78xx_net, domain_data);
1892 u32 buf;
1893 int ret;
1894
1895 /* call register access here because irq_bus_lock & irq_bus_sync_unlock
1896 * are only two callbacks executed in non-atomic contex.
1897 */
1898 ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1899 if (buf != data->irqenable)
1900 ret = lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
1901
1902 mutex_unlock(&data->irq_lock);
1903 }
1904
1905 static struct irq_chip lan78xx_irqchip = {
1906 .name = "lan78xx-irqs",
1907 .irq_mask = lan78xx_irq_mask,
1908 .irq_unmask = lan78xx_irq_unmask,
1909 .irq_bus_lock = lan78xx_irq_bus_lock,
1910 .irq_bus_sync_unlock = lan78xx_irq_bus_sync_unlock,
1911 };
1912
1913 static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
1914 {
1915 struct device_node *of_node;
1916 struct irq_domain *irqdomain;
1917 unsigned int irqmap = 0;
1918 u32 buf;
1919 int ret = 0;
1920
1921 of_node = dev->udev->dev.parent->of_node;
1922
1923 mutex_init(&dev->domain_data.irq_lock);
1924
1925 lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1926 dev->domain_data.irqenable = buf;
1927
1928 dev->domain_data.irqchip = &lan78xx_irqchip;
1929 dev->domain_data.irq_handler = handle_simple_irq;
1930
1931 irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,
1932 &chip_domain_ops, &dev->domain_data);
1933 if (irqdomain) {
1934 /* create mapping for PHY interrupt */
1935 irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);
1936 if (!irqmap) {
1937 irq_domain_remove(irqdomain);
1938
1939 irqdomain = NULL;
1940 ret = -EINVAL;
1941 }
1942 } else {
1943 ret = -EINVAL;
1944 }
1945
1946 dev->domain_data.irqdomain = irqdomain;
1947 dev->domain_data.phyirq = irqmap;
1948
1949 return ret;
1950 }
1951
1952 static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
1953 {
1954 if (dev->domain_data.phyirq > 0) {
1955 irq_dispose_mapping(dev->domain_data.phyirq);
1956
1957 if (dev->domain_data.irqdomain)
1958 irq_domain_remove(dev->domain_data.irqdomain);
1959 }
1960 dev->domain_data.phyirq = 0;
1961 dev->domain_data.irqdomain = NULL;
1962 }
1963
1964 static int lan8835_fixup(struct phy_device *phydev)
1965 {
1966 int buf;
1967 int ret;
1968 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
1969
1970 /* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */
1971 buf = phy_read_mmd(phydev, MDIO_MMD_PCS, 0x8010);
1972 buf &= ~0x1800;
1973 buf |= 0x0800;
1974 phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf);
1975
1976 /* RGMII MAC TXC Delay Enable */
1977 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
1978 MAC_RGMII_ID_TXC_DELAY_EN_);
1979
1980 /* RGMII TX DLL Tune Adjust */
1981 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
1982
1983 dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
1984
1985 return 1;
1986 }
1987
1988 static int ksz9031rnx_fixup(struct phy_device *phydev)
1989 {
1990 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
1991
1992 /* Micrel9301RNX PHY configuration */
1993 /* RGMII Control Signal Pad Skew */
1994 phy_write_mmd(phydev, MDIO_MMD_WIS, 4, 0x0077);
1995 /* RGMII RX Data Pad Skew */
1996 phy_write_mmd(phydev, MDIO_MMD_WIS, 5, 0x7777);
1997 /* RGMII RX Clock Pad Skew */
1998 phy_write_mmd(phydev, MDIO_MMD_WIS, 8, 0x1FF);
1999
2000 dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;
2001
2002 return 1;
2003 }
2004
2005 static int lan78xx_phy_init(struct lan78xx_net *dev)
2006 {
2007 int ret;
2008 u32 mii_adv;
2009 struct phy_device *phydev;
2010
2011 phydev = phy_find_first(dev->mdiobus);
2012 if (!phydev) {
2013 netdev_err(dev->net, "no PHY found\n");
2014 return -EIO;
2015 }
2016
2017 if ((dev->chipid == ID_REV_CHIP_ID_7800_) ||
2018 (dev->chipid == ID_REV_CHIP_ID_7850_)) {
2019 phydev->is_internal = true;
2020 dev->interface = PHY_INTERFACE_MODE_GMII;
2021
2022 } else if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2023 if (!phydev->drv) {
2024 netdev_err(dev->net, "no PHY driver found\n");
2025 return -EIO;
2026 }
2027
2028 dev->interface = PHY_INTERFACE_MODE_RGMII;
2029
2030 /* external PHY fixup for KSZ9031RNX */
2031 ret = phy_register_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0,
2032 ksz9031rnx_fixup);
2033 if (ret < 0) {
2034 netdev_err(dev->net, "fail to register fixup\n");
2035 return ret;
2036 }
2037 /* external PHY fixup for LAN8835 */
2038 ret = phy_register_fixup_for_uid(PHY_LAN8835, 0xfffffff0,
2039 lan8835_fixup);
2040 if (ret < 0) {
2041 netdev_err(dev->net, "fail to register fixup\n");
2042 return ret;
2043 }
2044 /* add more external PHY fixup here if needed */
2045
2046 phydev->is_internal = false;
2047 } else {
2048 netdev_err(dev->net, "unknown ID found\n");
2049 ret = -EIO;
2050 goto error;
2051 }
2052
2053 /* if phyirq is not set, use polling mode in phylib */
2054 if (dev->domain_data.phyirq > 0)
2055 phydev->irq = dev->domain_data.phyirq;
2056 else
2057 phydev->irq = 0;
2058 netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2059
2060 /* set to AUTOMDIX */
2061 phydev->mdix = ETH_TP_MDI_AUTO;
2062
2063 ret = phy_connect_direct(dev->net, phydev,
2064 lan78xx_link_status_change,
2065 dev->interface);
2066 if (ret) {
2067 netdev_err(dev->net, "can't attach PHY to %s\n",
2068 dev->mdiobus->id);
2069 return -EIO;
2070 }
2071
2072 /* MAC doesn't support 1000T Half */
2073 phydev->supported &= ~SUPPORTED_1000baseT_Half;
2074
2075 /* support both flow controls */
2076 dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2077 phydev->advertising &= ~(ADVERTISED_Pause | ADVERTISED_Asym_Pause);
2078 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2079 phydev->advertising |= mii_adv_to_ethtool_adv_t(mii_adv);
2080
2081 genphy_config_aneg(phydev);
2082
2083 dev->fc_autoneg = phydev->autoneg;
2084
2085 phy_start(phydev);
2086
2087 netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
2088
2089 return 0;
2090
2091 error:
2092 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
2093 phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
2094
2095 return ret;
2096 }
2097
2098 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2099 {
2100 int ret = 0;
2101 u32 buf;
2102 bool rxenabled;
2103
2104 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2105
2106 rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2107
2108 if (rxenabled) {
2109 buf &= ~MAC_RX_RXEN_;
2110 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2111 }
2112
2113 /* add 4 to size for FCS */
2114 buf &= ~MAC_RX_MAX_SIZE_MASK_;
2115 buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2116
2117 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2118
2119 if (rxenabled) {
2120 buf |= MAC_RX_RXEN_;
2121 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2122 }
2123
2124 return 0;
2125 }
2126
2127 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2128 {
2129 struct sk_buff *skb;
2130 unsigned long flags;
2131 int count = 0;
2132
2133 spin_lock_irqsave(&q->lock, flags);
2134 while (!skb_queue_empty(q)) {
2135 struct skb_data *entry;
2136 struct urb *urb;
2137 int ret;
2138
2139 skb_queue_walk(q, skb) {
2140 entry = (struct skb_data *)skb->cb;
2141 if (entry->state != unlink_start)
2142 goto found;
2143 }
2144 break;
2145 found:
2146 entry->state = unlink_start;
2147 urb = entry->urb;
2148
2149 /* Get reference count of the URB to avoid it to be
2150 * freed during usb_unlink_urb, which may trigger
2151 * use-after-free problem inside usb_unlink_urb since
2152 * usb_unlink_urb is always racing with .complete
2153 * handler(include defer_bh).
2154 */
2155 usb_get_urb(urb);
2156 spin_unlock_irqrestore(&q->lock, flags);
2157 /* during some PM-driven resume scenarios,
2158 * these (async) unlinks complete immediately
2159 */
2160 ret = usb_unlink_urb(urb);
2161 if (ret != -EINPROGRESS && ret != 0)
2162 netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2163 else
2164 count++;
2165 usb_put_urb(urb);
2166 spin_lock_irqsave(&q->lock, flags);
2167 }
2168 spin_unlock_irqrestore(&q->lock, flags);
2169 return count;
2170 }
2171
2172 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2173 {
2174 struct lan78xx_net *dev = netdev_priv(netdev);
2175 int ll_mtu = new_mtu + netdev->hard_header_len;
2176 int old_hard_mtu = dev->hard_mtu;
2177 int old_rx_urb_size = dev->rx_urb_size;
2178 int ret;
2179
2180 /* no second zero-length packet read wanted after mtu-sized packets */
2181 if ((ll_mtu % dev->maxpacket) == 0)
2182 return -EDOM;
2183
2184 ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + ETH_HLEN);
2185
2186 netdev->mtu = new_mtu;
2187
2188 dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
2189 if (dev->rx_urb_size == old_hard_mtu) {
2190 dev->rx_urb_size = dev->hard_mtu;
2191 if (dev->rx_urb_size > old_rx_urb_size) {
2192 if (netif_running(dev->net)) {
2193 unlink_urbs(dev, &dev->rxq);
2194 tasklet_schedule(&dev->bh);
2195 }
2196 }
2197 }
2198
2199 return 0;
2200 }
2201
2202 static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2203 {
2204 struct lan78xx_net *dev = netdev_priv(netdev);
2205 struct sockaddr *addr = p;
2206 u32 addr_lo, addr_hi;
2207 int ret;
2208
2209 if (netif_running(netdev))
2210 return -EBUSY;
2211
2212 if (!is_valid_ether_addr(addr->sa_data))
2213 return -EADDRNOTAVAIL;
2214
2215 ether_addr_copy(netdev->dev_addr, addr->sa_data);
2216
2217 addr_lo = netdev->dev_addr[0] |
2218 netdev->dev_addr[1] << 8 |
2219 netdev->dev_addr[2] << 16 |
2220 netdev->dev_addr[3] << 24;
2221 addr_hi = netdev->dev_addr[4] |
2222 netdev->dev_addr[5] << 8;
2223
2224 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2225 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2226
2227 return 0;
2228 }
2229
2230 /* Enable or disable Rx checksum offload engine */
2231 static int lan78xx_set_features(struct net_device *netdev,
2232 netdev_features_t features)
2233 {
2234 struct lan78xx_net *dev = netdev_priv(netdev);
2235 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2236 unsigned long flags;
2237 int ret;
2238
2239 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2240
2241 if (features & NETIF_F_RXCSUM) {
2242 pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
2243 pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
2244 } else {
2245 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2246 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2247 }
2248
2249 if (features & NETIF_F_HW_VLAN_CTAG_RX)
2250 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2251 else
2252 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2253
2254 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2255
2256 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2257
2258 return 0;
2259 }
2260
2261 static void lan78xx_deferred_vlan_write(struct work_struct *param)
2262 {
2263 struct lan78xx_priv *pdata =
2264 container_of(param, struct lan78xx_priv, set_vlan);
2265 struct lan78xx_net *dev = pdata->dev;
2266
2267 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2268 DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2269 }
2270
2271 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2272 __be16 proto, u16 vid)
2273 {
2274 struct lan78xx_net *dev = netdev_priv(netdev);
2275 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2276 u16 vid_bit_index;
2277 u16 vid_dword_index;
2278
2279 vid_dword_index = (vid >> 5) & 0x7F;
2280 vid_bit_index = vid & 0x1F;
2281
2282 pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2283
2284 /* defer register writes to a sleepable context */
2285 schedule_work(&pdata->set_vlan);
2286
2287 return 0;
2288 }
2289
2290 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2291 __be16 proto, u16 vid)
2292 {
2293 struct lan78xx_net *dev = netdev_priv(netdev);
2294 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2295 u16 vid_bit_index;
2296 u16 vid_dword_index;
2297
2298 vid_dword_index = (vid >> 5) & 0x7F;
2299 vid_bit_index = vid & 0x1F;
2300
2301 pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2302
2303 /* defer register writes to a sleepable context */
2304 schedule_work(&pdata->set_vlan);
2305
2306 return 0;
2307 }
2308
2309 static void lan78xx_init_ltm(struct lan78xx_net *dev)
2310 {
2311 int ret;
2312 u32 buf;
2313 u32 regs[6] = { 0 };
2314
2315 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2316 if (buf & USB_CFG1_LTM_ENABLE_) {
2317 u8 temp[2];
2318 /* Get values from EEPROM first */
2319 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2320 if (temp[0] == 24) {
2321 ret = lan78xx_read_raw_eeprom(dev,
2322 temp[1] * 2,
2323 24,
2324 (u8 *)regs);
2325 if (ret < 0)
2326 return;
2327 }
2328 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2329 if (temp[0] == 24) {
2330 ret = lan78xx_read_raw_otp(dev,
2331 temp[1] * 2,
2332 24,
2333 (u8 *)regs);
2334 if (ret < 0)
2335 return;
2336 }
2337 }
2338 }
2339
2340 lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2341 lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2342 lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2343 lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2344 lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2345 lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2346 }
2347
2348 static int lan78xx_reset(struct lan78xx_net *dev)
2349 {
2350 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2351 u32 buf;
2352 int ret = 0;
2353 unsigned long timeout;
2354
2355 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2356 buf |= HW_CFG_LRST_;
2357 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2358
2359 timeout = jiffies + HZ;
2360 do {
2361 mdelay(1);
2362 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2363 if (time_after(jiffies, timeout)) {
2364 netdev_warn(dev->net,
2365 "timeout on completion of LiteReset");
2366 return -EIO;
2367 }
2368 } while (buf & HW_CFG_LRST_);
2369
2370 lan78xx_init_mac_address(dev);
2371
2372 /* save DEVID for later usage */
2373 ret = lan78xx_read_reg(dev, ID_REV, &buf);
2374 dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2375 dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2376
2377 /* Respond to the IN token with a NAK */
2378 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2379 buf |= USB_CFG_BIR_;
2380 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2381
2382 /* Init LTM */
2383 lan78xx_init_ltm(dev);
2384
2385 if (dev->udev->speed == USB_SPEED_SUPER) {
2386 buf = DEFAULT_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2387 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2388 dev->rx_qlen = 4;
2389 dev->tx_qlen = 4;
2390 } else if (dev->udev->speed == USB_SPEED_HIGH) {
2391 buf = DEFAULT_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2392 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2393 dev->rx_qlen = RX_MAX_QUEUE_MEMORY / dev->rx_urb_size;
2394 dev->tx_qlen = RX_MAX_QUEUE_MEMORY / dev->hard_mtu;
2395 } else {
2396 buf = DEFAULT_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2397 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2398 dev->rx_qlen = 4;
2399 dev->tx_qlen = 4;
2400 }
2401
2402 ret = lan78xx_write_reg(dev, BURST_CAP, buf);
2403 ret = lan78xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
2404
2405 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2406 buf |= HW_CFG_MEF_;
2407 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2408
2409 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2410 buf |= USB_CFG_BCE_;
2411 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2412
2413 /* set FIFO sizes */
2414 buf = (MAX_RX_FIFO_SIZE - 512) / 512;
2415 ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2416
2417 buf = (MAX_TX_FIFO_SIZE - 512) / 512;
2418 ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2419
2420 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2421 ret = lan78xx_write_reg(dev, FLOW, 0);
2422 ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2423
2424 /* Don't need rfe_ctl_lock during initialisation */
2425 ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2426 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
2427 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2428
2429 /* Enable or disable checksum offload engines */
2430 lan78xx_set_features(dev->net, dev->net->features);
2431
2432 lan78xx_set_multicast(dev->net);
2433
2434 /* reset PHY */
2435 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2436 buf |= PMT_CTL_PHY_RST_;
2437 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
2438
2439 timeout = jiffies + HZ;
2440 do {
2441 mdelay(1);
2442 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2443 if (time_after(jiffies, timeout)) {
2444 netdev_warn(dev->net, "timeout waiting for PHY Reset");
2445 return -EIO;
2446 }
2447 } while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
2448
2449 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
2450 /* LAN7801 only has RGMII mode */
2451 if (dev->chipid == ID_REV_CHIP_ID_7801_)
2452 buf &= ~MAC_CR_GMII_EN_;
2453 ret = lan78xx_write_reg(dev, MAC_CR, buf);
2454
2455 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
2456 buf |= MAC_TX_TXEN_;
2457 ret = lan78xx_write_reg(dev, MAC_TX, buf);
2458
2459 ret = lan78xx_read_reg(dev, FCT_TX_CTL, &buf);
2460 buf |= FCT_TX_CTL_EN_;
2461 ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
2462
2463 ret = lan78xx_set_rx_max_frame_length(dev, dev->net->mtu + ETH_HLEN);
2464
2465 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2466 buf |= MAC_RX_RXEN_;
2467 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2468
2469 ret = lan78xx_read_reg(dev, FCT_RX_CTL, &buf);
2470 buf |= FCT_RX_CTL_EN_;
2471 ret = lan78xx_write_reg(dev, FCT_RX_CTL, buf);
2472
2473 return 0;
2474 }
2475
2476 static void lan78xx_init_stats(struct lan78xx_net *dev)
2477 {
2478 u32 *p;
2479 int i;
2480
2481 /* initialize for stats update
2482 * some counters are 20bits and some are 32bits
2483 */
2484 p = (u32 *)&dev->stats.rollover_max;
2485 for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
2486 p[i] = 0xFFFFF;
2487
2488 dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
2489 dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
2490 dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
2491 dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
2492 dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
2493 dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
2494 dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
2495 dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
2496 dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
2497 dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
2498
2499 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
2500 }
2501
2502 static int lan78xx_open(struct net_device *net)
2503 {
2504 struct lan78xx_net *dev = netdev_priv(net);
2505 int ret;
2506
2507 ret = usb_autopm_get_interface(dev->intf);
2508 if (ret < 0)
2509 goto out;
2510
2511 ret = lan78xx_reset(dev);
2512 if (ret < 0)
2513 goto done;
2514
2515 ret = lan78xx_phy_init(dev);
2516 if (ret < 0)
2517 goto done;
2518
2519 /* for Link Check */
2520 if (dev->urb_intr) {
2521 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
2522 if (ret < 0) {
2523 netif_err(dev, ifup, dev->net,
2524 "intr submit %d\n", ret);
2525 goto done;
2526 }
2527 }
2528
2529 lan78xx_init_stats(dev);
2530
2531 set_bit(EVENT_DEV_OPEN, &dev->flags);
2532
2533 netif_start_queue(net);
2534
2535 dev->link_on = false;
2536
2537 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
2538 done:
2539 usb_autopm_put_interface(dev->intf);
2540
2541 out:
2542 return ret;
2543 }
2544
2545 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
2546 {
2547 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
2548 DECLARE_WAITQUEUE(wait, current);
2549 int temp;
2550
2551 /* ensure there are no more active urbs */
2552 add_wait_queue(&unlink_wakeup, &wait);
2553 set_current_state(TASK_UNINTERRUPTIBLE);
2554 dev->wait = &unlink_wakeup;
2555 temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
2556
2557 /* maybe wait for deletions to finish. */
2558 while (!skb_queue_empty(&dev->rxq) &&
2559 !skb_queue_empty(&dev->txq) &&
2560 !skb_queue_empty(&dev->done)) {
2561 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
2562 set_current_state(TASK_UNINTERRUPTIBLE);
2563 netif_dbg(dev, ifdown, dev->net,
2564 "waited for %d urb completions\n", temp);
2565 }
2566 set_current_state(TASK_RUNNING);
2567 dev->wait = NULL;
2568 remove_wait_queue(&unlink_wakeup, &wait);
2569 }
2570
2571 static int lan78xx_stop(struct net_device *net)
2572 {
2573 struct lan78xx_net *dev = netdev_priv(net);
2574
2575 if (timer_pending(&dev->stat_monitor))
2576 del_timer_sync(&dev->stat_monitor);
2577
2578 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
2579 phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
2580
2581 phy_stop(net->phydev);
2582 phy_disconnect(net->phydev);
2583
2584 net->phydev = NULL;
2585
2586 clear_bit(EVENT_DEV_OPEN, &dev->flags);
2587 netif_stop_queue(net);
2588
2589 netif_info(dev, ifdown, dev->net,
2590 "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
2591 net->stats.rx_packets, net->stats.tx_packets,
2592 net->stats.rx_errors, net->stats.tx_errors);
2593
2594 lan78xx_terminate_urbs(dev);
2595
2596 usb_kill_urb(dev->urb_intr);
2597
2598 skb_queue_purge(&dev->rxq_pause);
2599
2600 /* deferred work (task, timer, softirq) must also stop.
2601 * can't flush_scheduled_work() until we drop rtnl (later),
2602 * else workers could deadlock; so make workers a NOP.
2603 */
2604 dev->flags = 0;
2605 cancel_delayed_work_sync(&dev->wq);
2606 tasklet_kill(&dev->bh);
2607
2608 usb_autopm_put_interface(dev->intf);
2609
2610 return 0;
2611 }
2612
2613 static int lan78xx_linearize(struct sk_buff *skb)
2614 {
2615 return skb_linearize(skb);
2616 }
2617
2618 static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
2619 struct sk_buff *skb, gfp_t flags)
2620 {
2621 u32 tx_cmd_a, tx_cmd_b;
2622
2623 if (skb_cow_head(skb, TX_OVERHEAD)) {
2624 dev_kfree_skb_any(skb);
2625 return NULL;
2626 }
2627
2628 if (lan78xx_linearize(skb) < 0)
2629 return NULL;
2630
2631 tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
2632
2633 if (skb->ip_summed == CHECKSUM_PARTIAL)
2634 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
2635
2636 tx_cmd_b = 0;
2637 if (skb_is_gso(skb)) {
2638 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
2639
2640 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
2641
2642 tx_cmd_a |= TX_CMD_A_LSO_;
2643 }
2644
2645 if (skb_vlan_tag_present(skb)) {
2646 tx_cmd_a |= TX_CMD_A_IVTG_;
2647 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
2648 }
2649
2650 skb_push(skb, 4);
2651 cpu_to_le32s(&tx_cmd_b);
2652 memcpy(skb->data, &tx_cmd_b, 4);
2653
2654 skb_push(skb, 4);
2655 cpu_to_le32s(&tx_cmd_a);
2656 memcpy(skb->data, &tx_cmd_a, 4);
2657
2658 return skb;
2659 }
2660
2661 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
2662 struct sk_buff_head *list, enum skb_state state)
2663 {
2664 unsigned long flags;
2665 enum skb_state old_state;
2666 struct skb_data *entry = (struct skb_data *)skb->cb;
2667
2668 spin_lock_irqsave(&list->lock, flags);
2669 old_state = entry->state;
2670 entry->state = state;
2671
2672 __skb_unlink(skb, list);
2673 spin_unlock(&list->lock);
2674 spin_lock(&dev->done.lock);
2675
2676 __skb_queue_tail(&dev->done, skb);
2677 if (skb_queue_len(&dev->done) == 1)
2678 tasklet_schedule(&dev->bh);
2679 spin_unlock_irqrestore(&dev->done.lock, flags);
2680
2681 return old_state;
2682 }
2683
2684 static void tx_complete(struct urb *urb)
2685 {
2686 struct sk_buff *skb = (struct sk_buff *)urb->context;
2687 struct skb_data *entry = (struct skb_data *)skb->cb;
2688 struct lan78xx_net *dev = entry->dev;
2689
2690 if (urb->status == 0) {
2691 dev->net->stats.tx_packets += entry->num_of_packet;
2692 dev->net->stats.tx_bytes += entry->length;
2693 } else {
2694 dev->net->stats.tx_errors++;
2695
2696 switch (urb->status) {
2697 case -EPIPE:
2698 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2699 break;
2700
2701 /* software-driven interface shutdown */
2702 case -ECONNRESET:
2703 case -ESHUTDOWN:
2704 break;
2705
2706 case -EPROTO:
2707 case -ETIME:
2708 case -EILSEQ:
2709 netif_stop_queue(dev->net);
2710 break;
2711 default:
2712 netif_dbg(dev, tx_err, dev->net,
2713 "tx err %d\n", entry->urb->status);
2714 break;
2715 }
2716 }
2717
2718 usb_autopm_put_interface_async(dev->intf);
2719
2720 defer_bh(dev, skb, &dev->txq, tx_done);
2721 }
2722
2723 static void lan78xx_queue_skb(struct sk_buff_head *list,
2724 struct sk_buff *newsk, enum skb_state state)
2725 {
2726 struct skb_data *entry = (struct skb_data *)newsk->cb;
2727
2728 __skb_queue_tail(list, newsk);
2729 entry->state = state;
2730 }
2731
2732 static netdev_tx_t
2733 lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
2734 {
2735 struct lan78xx_net *dev = netdev_priv(net);
2736 struct sk_buff *skb2 = NULL;
2737
2738 if (skb) {
2739 skb_tx_timestamp(skb);
2740 skb2 = lan78xx_tx_prep(dev, skb, GFP_ATOMIC);
2741 }
2742
2743 if (skb2) {
2744 skb_queue_tail(&dev->txq_pend, skb2);
2745
2746 /* throttle TX patch at slower than SUPER SPEED USB */
2747 if ((dev->udev->speed < USB_SPEED_SUPER) &&
2748 (skb_queue_len(&dev->txq_pend) > 10))
2749 netif_stop_queue(net);
2750 } else {
2751 netif_dbg(dev, tx_err, dev->net,
2752 "lan78xx_tx_prep return NULL\n");
2753 dev->net->stats.tx_errors++;
2754 dev->net->stats.tx_dropped++;
2755 }
2756
2757 tasklet_schedule(&dev->bh);
2758
2759 return NETDEV_TX_OK;
2760 }
2761
2762 static int
2763 lan78xx_get_endpoints(struct lan78xx_net *dev, struct usb_interface *intf)
2764 {
2765 int tmp;
2766 struct usb_host_interface *alt = NULL;
2767 struct usb_host_endpoint *in = NULL, *out = NULL;
2768 struct usb_host_endpoint *status = NULL;
2769
2770 for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
2771 unsigned ep;
2772
2773 in = NULL;
2774 out = NULL;
2775 status = NULL;
2776 alt = intf->altsetting + tmp;
2777
2778 for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
2779 struct usb_host_endpoint *e;
2780 int intr = 0;
2781
2782 e = alt->endpoint + ep;
2783 switch (e->desc.bmAttributes) {
2784 case USB_ENDPOINT_XFER_INT:
2785 if (!usb_endpoint_dir_in(&e->desc))
2786 continue;
2787 intr = 1;
2788 /* FALLTHROUGH */
2789 case USB_ENDPOINT_XFER_BULK:
2790 break;
2791 default:
2792 continue;
2793 }
2794 if (usb_endpoint_dir_in(&e->desc)) {
2795 if (!intr && !in)
2796 in = e;
2797 else if (intr && !status)
2798 status = e;
2799 } else {
2800 if (!out)
2801 out = e;
2802 }
2803 }
2804 if (in && out)
2805 break;
2806 }
2807 if (!alt || !in || !out)
2808 return -EINVAL;
2809
2810 dev->pipe_in = usb_rcvbulkpipe(dev->udev,
2811 in->desc.bEndpointAddress &
2812 USB_ENDPOINT_NUMBER_MASK);
2813 dev->pipe_out = usb_sndbulkpipe(dev->udev,
2814 out->desc.bEndpointAddress &
2815 USB_ENDPOINT_NUMBER_MASK);
2816 dev->ep_intr = status;
2817
2818 return 0;
2819 }
2820
2821 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
2822 {
2823 struct lan78xx_priv *pdata = NULL;
2824 int ret;
2825 int i;
2826
2827 ret = lan78xx_get_endpoints(dev, intf);
2828
2829 dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
2830
2831 pdata = (struct lan78xx_priv *)(dev->data[0]);
2832 if (!pdata) {
2833 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
2834 return -ENOMEM;
2835 }
2836
2837 pdata->dev = dev;
2838
2839 spin_lock_init(&pdata->rfe_ctl_lock);
2840 mutex_init(&pdata->dataport_mutex);
2841
2842 INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
2843
2844 for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
2845 pdata->vlan_table[i] = 0;
2846
2847 INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
2848
2849 dev->net->features = 0;
2850
2851 if (DEFAULT_TX_CSUM_ENABLE)
2852 dev->net->features |= NETIF_F_HW_CSUM;
2853
2854 if (DEFAULT_RX_CSUM_ENABLE)
2855 dev->net->features |= NETIF_F_RXCSUM;
2856
2857 if (DEFAULT_TSO_CSUM_ENABLE)
2858 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
2859
2860 dev->net->hw_features = dev->net->features;
2861
2862 ret = lan78xx_setup_irq_domain(dev);
2863 if (ret < 0) {
2864 netdev_warn(dev->net,
2865 "lan78xx_setup_irq_domain() failed : %d", ret);
2866 kfree(pdata);
2867 return ret;
2868 }
2869
2870 dev->net->hard_header_len += TX_OVERHEAD;
2871 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
2872
2873 /* Init all registers */
2874 ret = lan78xx_reset(dev);
2875
2876 ret = lan78xx_mdio_init(dev);
2877
2878 dev->net->flags |= IFF_MULTICAST;
2879
2880 pdata->wol = WAKE_MAGIC;
2881
2882 return ret;
2883 }
2884
2885 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
2886 {
2887 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2888
2889 lan78xx_remove_irq_domain(dev);
2890
2891 lan78xx_remove_mdio(dev);
2892
2893 if (pdata) {
2894 netif_dbg(dev, ifdown, dev->net, "free pdata");
2895 kfree(pdata);
2896 pdata = NULL;
2897 dev->data[0] = 0;
2898 }
2899 }
2900
2901 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
2902 struct sk_buff *skb,
2903 u32 rx_cmd_a, u32 rx_cmd_b)
2904 {
2905 if (!(dev->net->features & NETIF_F_RXCSUM) ||
2906 unlikely(rx_cmd_a & RX_CMD_A_ICSM_)) {
2907 skb->ip_summed = CHECKSUM_NONE;
2908 } else {
2909 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
2910 skb->ip_summed = CHECKSUM_COMPLETE;
2911 }
2912 }
2913
2914 static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
2915 {
2916 int status;
2917
2918 if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
2919 skb_queue_tail(&dev->rxq_pause, skb);
2920 return;
2921 }
2922
2923 dev->net->stats.rx_packets++;
2924 dev->net->stats.rx_bytes += skb->len;
2925
2926 skb->protocol = eth_type_trans(skb, dev->net);
2927
2928 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
2929 skb->len + sizeof(struct ethhdr), skb->protocol);
2930 memset(skb->cb, 0, sizeof(struct skb_data));
2931
2932 if (skb_defer_rx_timestamp(skb))
2933 return;
2934
2935 status = netif_rx(skb);
2936 if (status != NET_RX_SUCCESS)
2937 netif_dbg(dev, rx_err, dev->net,
2938 "netif_rx status %d\n", status);
2939 }
2940
2941 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb)
2942 {
2943 if (skb->len < dev->net->hard_header_len)
2944 return 0;
2945
2946 while (skb->len > 0) {
2947 u32 rx_cmd_a, rx_cmd_b, align_count, size;
2948 u16 rx_cmd_c;
2949 struct sk_buff *skb2;
2950 unsigned char *packet;
2951
2952 memcpy(&rx_cmd_a, skb->data, sizeof(rx_cmd_a));
2953 le32_to_cpus(&rx_cmd_a);
2954 skb_pull(skb, sizeof(rx_cmd_a));
2955
2956 memcpy(&rx_cmd_b, skb->data, sizeof(rx_cmd_b));
2957 le32_to_cpus(&rx_cmd_b);
2958 skb_pull(skb, sizeof(rx_cmd_b));
2959
2960 memcpy(&rx_cmd_c, skb->data, sizeof(rx_cmd_c));
2961 le16_to_cpus(&rx_cmd_c);
2962 skb_pull(skb, sizeof(rx_cmd_c));
2963
2964 packet = skb->data;
2965
2966 /* get the packet length */
2967 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
2968 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
2969
2970 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
2971 netif_dbg(dev, rx_err, dev->net,
2972 "Error rx_cmd_a=0x%08x", rx_cmd_a);
2973 } else {
2974 /* last frame in this batch */
2975 if (skb->len == size) {
2976 lan78xx_rx_csum_offload(dev, skb,
2977 rx_cmd_a, rx_cmd_b);
2978
2979 skb_trim(skb, skb->len - 4); /* remove fcs */
2980 skb->truesize = size + sizeof(struct sk_buff);
2981
2982 return 1;
2983 }
2984
2985 skb2 = skb_clone(skb, GFP_ATOMIC);
2986 if (unlikely(!skb2)) {
2987 netdev_warn(dev->net, "Error allocating skb");
2988 return 0;
2989 }
2990
2991 skb2->len = size;
2992 skb2->data = packet;
2993 skb_set_tail_pointer(skb2, size);
2994
2995 lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
2996
2997 skb_trim(skb2, skb2->len - 4); /* remove fcs */
2998 skb2->truesize = size + sizeof(struct sk_buff);
2999
3000 lan78xx_skb_return(dev, skb2);
3001 }
3002
3003 skb_pull(skb, size);
3004
3005 /* padding bytes before the next frame starts */
3006 if (skb->len)
3007 skb_pull(skb, align_count);
3008 }
3009
3010 return 1;
3011 }
3012
3013 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb)
3014 {
3015 if (!lan78xx_rx(dev, skb)) {
3016 dev->net->stats.rx_errors++;
3017 goto done;
3018 }
3019
3020 if (skb->len) {
3021 lan78xx_skb_return(dev, skb);
3022 return;
3023 }
3024
3025 netif_dbg(dev, rx_err, dev->net, "drop\n");
3026 dev->net->stats.rx_errors++;
3027 done:
3028 skb_queue_tail(&dev->done, skb);
3029 }
3030
3031 static void rx_complete(struct urb *urb);
3032
3033 static int rx_submit(struct lan78xx_net *dev, struct urb *urb, gfp_t flags)
3034 {
3035 struct sk_buff *skb;
3036 struct skb_data *entry;
3037 unsigned long lockflags;
3038 size_t size = dev->rx_urb_size;
3039 int ret = 0;
3040
3041 skb = netdev_alloc_skb_ip_align(dev->net, size);
3042 if (!skb) {
3043 usb_free_urb(urb);
3044 return -ENOMEM;
3045 }
3046
3047 entry = (struct skb_data *)skb->cb;
3048 entry->urb = urb;
3049 entry->dev = dev;
3050 entry->length = 0;
3051
3052 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3053 skb->data, size, rx_complete, skb);
3054
3055 spin_lock_irqsave(&dev->rxq.lock, lockflags);
3056
3057 if (netif_device_present(dev->net) &&
3058 netif_running(dev->net) &&
3059 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3060 !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3061 ret = usb_submit_urb(urb, GFP_ATOMIC);
3062 switch (ret) {
3063 case 0:
3064 lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3065 break;
3066 case -EPIPE:
3067 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3068 break;
3069 case -ENODEV:
3070 netif_dbg(dev, ifdown, dev->net, "device gone\n");
3071 netif_device_detach(dev->net);
3072 break;
3073 case -EHOSTUNREACH:
3074 ret = -ENOLINK;
3075 break;
3076 default:
3077 netif_dbg(dev, rx_err, dev->net,
3078 "rx submit, %d\n", ret);
3079 tasklet_schedule(&dev->bh);
3080 }
3081 } else {
3082 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3083 ret = -ENOLINK;
3084 }
3085 spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3086 if (ret) {
3087 dev_kfree_skb_any(skb);
3088 usb_free_urb(urb);
3089 }
3090 return ret;
3091 }
3092
3093 static void rx_complete(struct urb *urb)
3094 {
3095 struct sk_buff *skb = (struct sk_buff *)urb->context;
3096 struct skb_data *entry = (struct skb_data *)skb->cb;
3097 struct lan78xx_net *dev = entry->dev;
3098 int urb_status = urb->status;
3099 enum skb_state state;
3100
3101 skb_put(skb, urb->actual_length);
3102 state = rx_done;
3103 entry->urb = NULL;
3104
3105 switch (urb_status) {
3106 case 0:
3107 if (skb->len < dev->net->hard_header_len) {
3108 state = rx_cleanup;
3109 dev->net->stats.rx_errors++;
3110 dev->net->stats.rx_length_errors++;
3111 netif_dbg(dev, rx_err, dev->net,
3112 "rx length %d\n", skb->len);
3113 }
3114 usb_mark_last_busy(dev->udev);
3115 break;
3116 case -EPIPE:
3117 dev->net->stats.rx_errors++;
3118 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3119 /* FALLTHROUGH */
3120 case -ECONNRESET: /* async unlink */
3121 case -ESHUTDOWN: /* hardware gone */
3122 netif_dbg(dev, ifdown, dev->net,
3123 "rx shutdown, code %d\n", urb_status);
3124 state = rx_cleanup;
3125 entry->urb = urb;
3126 urb = NULL;
3127 break;
3128 case -EPROTO:
3129 case -ETIME:
3130 case -EILSEQ:
3131 dev->net->stats.rx_errors++;
3132 state = rx_cleanup;
3133 entry->urb = urb;
3134 urb = NULL;
3135 break;
3136
3137 /* data overrun ... flush fifo? */
3138 case -EOVERFLOW:
3139 dev->net->stats.rx_over_errors++;
3140 /* FALLTHROUGH */
3141
3142 default:
3143 state = rx_cleanup;
3144 dev->net->stats.rx_errors++;
3145 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3146 break;
3147 }
3148
3149 state = defer_bh(dev, skb, &dev->rxq, state);
3150
3151 if (urb) {
3152 if (netif_running(dev->net) &&
3153 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3154 state != unlink_start) {
3155 rx_submit(dev, urb, GFP_ATOMIC);
3156 return;
3157 }
3158 usb_free_urb(urb);
3159 }
3160 netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
3161 }
3162
3163 static void lan78xx_tx_bh(struct lan78xx_net *dev)
3164 {
3165 int length;
3166 struct urb *urb = NULL;
3167 struct skb_data *entry;
3168 unsigned long flags;
3169 struct sk_buff_head *tqp = &dev->txq_pend;
3170 struct sk_buff *skb, *skb2;
3171 int ret;
3172 int count, pos;
3173 int skb_totallen, pkt_cnt;
3174
3175 skb_totallen = 0;
3176 pkt_cnt = 0;
3177 count = 0;
3178 length = 0;
3179 for (skb = tqp->next; pkt_cnt < tqp->qlen; skb = skb->next) {
3180 if (skb_is_gso(skb)) {
3181 if (pkt_cnt) {
3182 /* handle previous packets first */
3183 break;
3184 }
3185 count = 1;
3186 length = skb->len - TX_OVERHEAD;
3187 skb2 = skb_dequeue(tqp);
3188 goto gso_skb;
3189 }
3190
3191 if ((skb_totallen + skb->len) > MAX_SINGLE_PACKET_SIZE)
3192 break;
3193 skb_totallen = skb->len + roundup(skb_totallen, sizeof(u32));
3194 pkt_cnt++;
3195 }
3196
3197 /* copy to a single skb */
3198 skb = alloc_skb(skb_totallen, GFP_ATOMIC);
3199 if (!skb)
3200 goto drop;
3201
3202 skb_put(skb, skb_totallen);
3203
3204 for (count = pos = 0; count < pkt_cnt; count++) {
3205 skb2 = skb_dequeue(tqp);
3206 if (skb2) {
3207 length += (skb2->len - TX_OVERHEAD);
3208 memcpy(skb->data + pos, skb2->data, skb2->len);
3209 pos += roundup(skb2->len, sizeof(u32));
3210 dev_kfree_skb(skb2);
3211 }
3212 }
3213
3214 gso_skb:
3215 urb = usb_alloc_urb(0, GFP_ATOMIC);
3216 if (!urb)
3217 goto drop;
3218
3219 entry = (struct skb_data *)skb->cb;
3220 entry->urb = urb;
3221 entry->dev = dev;
3222 entry->length = length;
3223 entry->num_of_packet = count;
3224
3225 spin_lock_irqsave(&dev->txq.lock, flags);
3226 ret = usb_autopm_get_interface_async(dev->intf);
3227 if (ret < 0) {
3228 spin_unlock_irqrestore(&dev->txq.lock, flags);
3229 goto drop;
3230 }
3231
3232 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_out,
3233 skb->data, skb->len, tx_complete, skb);
3234
3235 if (length % dev->maxpacket == 0) {
3236 /* send USB_ZERO_PACKET */
3237 urb->transfer_flags |= URB_ZERO_PACKET;
3238 }
3239
3240 #ifdef CONFIG_PM
3241 /* if this triggers the device is still a sleep */
3242 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3243 /* transmission will be done in resume */
3244 usb_anchor_urb(urb, &dev->deferred);
3245 /* no use to process more packets */
3246 netif_stop_queue(dev->net);
3247 usb_put_urb(urb);
3248 spin_unlock_irqrestore(&dev->txq.lock, flags);
3249 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
3250 return;
3251 }
3252 #endif
3253
3254 ret = usb_submit_urb(urb, GFP_ATOMIC);
3255 switch (ret) {
3256 case 0:
3257 netif_trans_update(dev->net);
3258 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3259 if (skb_queue_len(&dev->txq) >= dev->tx_qlen)
3260 netif_stop_queue(dev->net);
3261 break;
3262 case -EPIPE:
3263 netif_stop_queue(dev->net);
3264 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3265 usb_autopm_put_interface_async(dev->intf);
3266 break;
3267 default:
3268 usb_autopm_put_interface_async(dev->intf);
3269 netif_dbg(dev, tx_err, dev->net,
3270 "tx: submit urb err %d\n", ret);
3271 break;
3272 }
3273
3274 spin_unlock_irqrestore(&dev->txq.lock, flags);
3275
3276 if (ret) {
3277 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", ret);
3278 drop:
3279 dev->net->stats.tx_dropped++;
3280 if (skb)
3281 dev_kfree_skb_any(skb);
3282 usb_free_urb(urb);
3283 } else
3284 netif_dbg(dev, tx_queued, dev->net,
3285 "> tx, len %d, type 0x%x\n", length, skb->protocol);
3286 }
3287
3288 static void lan78xx_rx_bh(struct lan78xx_net *dev)
3289 {
3290 struct urb *urb;
3291 int i;
3292
3293 if (skb_queue_len(&dev->rxq) < dev->rx_qlen) {
3294 for (i = 0; i < 10; i++) {
3295 if (skb_queue_len(&dev->rxq) >= dev->rx_qlen)
3296 break;
3297 urb = usb_alloc_urb(0, GFP_ATOMIC);
3298 if (urb)
3299 if (rx_submit(dev, urb, GFP_ATOMIC) == -ENOLINK)
3300 return;
3301 }
3302
3303 if (skb_queue_len(&dev->rxq) < dev->rx_qlen)
3304 tasklet_schedule(&dev->bh);
3305 }
3306 if (skb_queue_len(&dev->txq) < dev->tx_qlen)
3307 netif_wake_queue(dev->net);
3308 }
3309
3310 static void lan78xx_bh(unsigned long param)
3311 {
3312 struct lan78xx_net *dev = (struct lan78xx_net *)param;
3313 struct sk_buff *skb;
3314 struct skb_data *entry;
3315
3316 while ((skb = skb_dequeue(&dev->done))) {
3317 entry = (struct skb_data *)(skb->cb);
3318 switch (entry->state) {
3319 case rx_done:
3320 entry->state = rx_cleanup;
3321 rx_process(dev, skb);
3322 continue;
3323 case tx_done:
3324 usb_free_urb(entry->urb);
3325 dev_kfree_skb(skb);
3326 continue;
3327 case rx_cleanup:
3328 usb_free_urb(entry->urb);
3329 dev_kfree_skb(skb);
3330 continue;
3331 default:
3332 netdev_dbg(dev->net, "skb state %d\n", entry->state);
3333 return;
3334 }
3335 }
3336
3337 if (netif_device_present(dev->net) && netif_running(dev->net)) {
3338 /* reset update timer delta */
3339 if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
3340 dev->delta = 1;
3341 mod_timer(&dev->stat_monitor,
3342 jiffies + STAT_UPDATE_TIMER);
3343 }
3344
3345 if (!skb_queue_empty(&dev->txq_pend))
3346 lan78xx_tx_bh(dev);
3347
3348 if (!timer_pending(&dev->delay) &&
3349 !test_bit(EVENT_RX_HALT, &dev->flags))
3350 lan78xx_rx_bh(dev);
3351 }
3352 }
3353
3354 static void lan78xx_delayedwork(struct work_struct *work)
3355 {
3356 int status;
3357 struct lan78xx_net *dev;
3358
3359 dev = container_of(work, struct lan78xx_net, wq.work);
3360
3361 if (test_bit(EVENT_TX_HALT, &dev->flags)) {
3362 unlink_urbs(dev, &dev->txq);
3363 status = usb_autopm_get_interface(dev->intf);
3364 if (status < 0)
3365 goto fail_pipe;
3366 status = usb_clear_halt(dev->udev, dev->pipe_out);
3367 usb_autopm_put_interface(dev->intf);
3368 if (status < 0 &&
3369 status != -EPIPE &&
3370 status != -ESHUTDOWN) {
3371 if (netif_msg_tx_err(dev))
3372 fail_pipe:
3373 netdev_err(dev->net,
3374 "can't clear tx halt, status %d\n",
3375 status);
3376 } else {
3377 clear_bit(EVENT_TX_HALT, &dev->flags);
3378 if (status != -ESHUTDOWN)
3379 netif_wake_queue(dev->net);
3380 }
3381 }
3382 if (test_bit(EVENT_RX_HALT, &dev->flags)) {
3383 unlink_urbs(dev, &dev->rxq);
3384 status = usb_autopm_get_interface(dev->intf);
3385 if (status < 0)
3386 goto fail_halt;
3387 status = usb_clear_halt(dev->udev, dev->pipe_in);
3388 usb_autopm_put_interface(dev->intf);
3389 if (status < 0 &&
3390 status != -EPIPE &&
3391 status != -ESHUTDOWN) {
3392 if (netif_msg_rx_err(dev))
3393 fail_halt:
3394 netdev_err(dev->net,
3395 "can't clear rx halt, status %d\n",
3396 status);
3397 } else {
3398 clear_bit(EVENT_RX_HALT, &dev->flags);
3399 tasklet_schedule(&dev->bh);
3400 }
3401 }
3402
3403 if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
3404 int ret = 0;
3405
3406 clear_bit(EVENT_LINK_RESET, &dev->flags);
3407 status = usb_autopm_get_interface(dev->intf);
3408 if (status < 0)
3409 goto skip_reset;
3410 if (lan78xx_link_reset(dev) < 0) {
3411 usb_autopm_put_interface(dev->intf);
3412 skip_reset:
3413 netdev_info(dev->net, "link reset failed (%d)\n",
3414 ret);
3415 } else {
3416 usb_autopm_put_interface(dev->intf);
3417 }
3418 }
3419
3420 if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
3421 lan78xx_update_stats(dev);
3422
3423 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3424
3425 mod_timer(&dev->stat_monitor,
3426 jiffies + (STAT_UPDATE_TIMER * dev->delta));
3427
3428 dev->delta = min((dev->delta * 2), 50);
3429 }
3430 }
3431
3432 static void intr_complete(struct urb *urb)
3433 {
3434 struct lan78xx_net *dev = urb->context;
3435 int status = urb->status;
3436
3437 switch (status) {
3438 /* success */
3439 case 0:
3440 lan78xx_status(dev, urb);
3441 break;
3442
3443 /* software-driven interface shutdown */
3444 case -ENOENT: /* urb killed */
3445 case -ESHUTDOWN: /* hardware gone */
3446 netif_dbg(dev, ifdown, dev->net,
3447 "intr shutdown, code %d\n", status);
3448 return;
3449
3450 /* NOTE: not throttling like RX/TX, since this endpoint
3451 * already polls infrequently
3452 */
3453 default:
3454 netdev_dbg(dev->net, "intr status %d\n", status);
3455 break;
3456 }
3457
3458 if (!netif_running(dev->net))
3459 return;
3460
3461 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
3462 status = usb_submit_urb(urb, GFP_ATOMIC);
3463 if (status != 0)
3464 netif_err(dev, timer, dev->net,
3465 "intr resubmit --> %d\n", status);
3466 }
3467
3468 static void lan78xx_disconnect(struct usb_interface *intf)
3469 {
3470 struct lan78xx_net *dev;
3471 struct usb_device *udev;
3472 struct net_device *net;
3473
3474 dev = usb_get_intfdata(intf);
3475 usb_set_intfdata(intf, NULL);
3476 if (!dev)
3477 return;
3478
3479 udev = interface_to_usbdev(intf);
3480
3481 net = dev->net;
3482 unregister_netdev(net);
3483
3484 cancel_delayed_work_sync(&dev->wq);
3485
3486 usb_scuttle_anchored_urbs(&dev->deferred);
3487
3488 lan78xx_unbind(dev, intf);
3489
3490 usb_kill_urb(dev->urb_intr);
3491 usb_free_urb(dev->urb_intr);
3492
3493 free_netdev(net);
3494 usb_put_dev(udev);
3495 }
3496
3497 static void lan78xx_tx_timeout(struct net_device *net)
3498 {
3499 struct lan78xx_net *dev = netdev_priv(net);
3500
3501 unlink_urbs(dev, &dev->txq);
3502 tasklet_schedule(&dev->bh);
3503 }
3504
3505 static const struct net_device_ops lan78xx_netdev_ops = {
3506 .ndo_open = lan78xx_open,
3507 .ndo_stop = lan78xx_stop,
3508 .ndo_start_xmit = lan78xx_start_xmit,
3509 .ndo_tx_timeout = lan78xx_tx_timeout,
3510 .ndo_change_mtu = lan78xx_change_mtu,
3511 .ndo_set_mac_address = lan78xx_set_mac_addr,
3512 .ndo_validate_addr = eth_validate_addr,
3513 .ndo_do_ioctl = lan78xx_ioctl,
3514 .ndo_set_rx_mode = lan78xx_set_multicast,
3515 .ndo_set_features = lan78xx_set_features,
3516 .ndo_vlan_rx_add_vid = lan78xx_vlan_rx_add_vid,
3517 .ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid,
3518 };
3519
3520 static void lan78xx_stat_monitor(struct timer_list *t)
3521 {
3522 struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
3523
3524 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
3525 }
3526
3527 static int lan78xx_probe(struct usb_interface *intf,
3528 const struct usb_device_id *id)
3529 {
3530 struct lan78xx_net *dev;
3531 struct net_device *netdev;
3532 struct usb_device *udev;
3533 int ret;
3534 unsigned maxp;
3535 unsigned period;
3536 u8 *buf = NULL;
3537
3538 udev = interface_to_usbdev(intf);
3539 udev = usb_get_dev(udev);
3540
3541 netdev = alloc_etherdev(sizeof(struct lan78xx_net));
3542 if (!netdev) {
3543 dev_err(&intf->dev, "Error: OOM\n");
3544 ret = -ENOMEM;
3545 goto out1;
3546 }
3547
3548 /* netdev_printk() needs this */
3549 SET_NETDEV_DEV(netdev, &intf->dev);
3550
3551 dev = netdev_priv(netdev);
3552 dev->udev = udev;
3553 dev->intf = intf;
3554 dev->net = netdev;
3555 dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
3556 | NETIF_MSG_PROBE | NETIF_MSG_LINK);
3557
3558 skb_queue_head_init(&dev->rxq);
3559 skb_queue_head_init(&dev->txq);
3560 skb_queue_head_init(&dev->done);
3561 skb_queue_head_init(&dev->rxq_pause);
3562 skb_queue_head_init(&dev->txq_pend);
3563 mutex_init(&dev->phy_mutex);
3564
3565 tasklet_init(&dev->bh, lan78xx_bh, (unsigned long)dev);
3566 INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
3567 init_usb_anchor(&dev->deferred);
3568
3569 netdev->netdev_ops = &lan78xx_netdev_ops;
3570 netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
3571 netdev->ethtool_ops = &lan78xx_ethtool_ops;
3572
3573 dev->delta = 1;
3574 timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
3575
3576 mutex_init(&dev->stats.access_lock);
3577
3578 ret = lan78xx_bind(dev, intf);
3579 if (ret < 0)
3580 goto out2;
3581 strcpy(netdev->name, "eth%d");
3582
3583 if (netdev->mtu > (dev->hard_mtu - netdev->hard_header_len))
3584 netdev->mtu = dev->hard_mtu - netdev->hard_header_len;
3585
3586 /* MTU range: 68 - 9000 */
3587 netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
3588
3589 dev->ep_blkin = (intf->cur_altsetting)->endpoint + 0;
3590 dev->ep_blkout = (intf->cur_altsetting)->endpoint + 1;
3591 dev->ep_intr = (intf->cur_altsetting)->endpoint + 2;
3592
3593 dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
3594 dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
3595
3596 dev->pipe_intr = usb_rcvintpipe(dev->udev,
3597 dev->ep_intr->desc.bEndpointAddress &
3598 USB_ENDPOINT_NUMBER_MASK);
3599 period = dev->ep_intr->desc.bInterval;
3600
3601 maxp = usb_maxpacket(dev->udev, dev->pipe_intr, 0);
3602 buf = kmalloc(maxp, GFP_KERNEL);
3603 if (buf) {
3604 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
3605 if (!dev->urb_intr) {
3606 ret = -ENOMEM;
3607 kfree(buf);
3608 goto out3;
3609 } else {
3610 usb_fill_int_urb(dev->urb_intr, dev->udev,
3611 dev->pipe_intr, buf, maxp,
3612 intr_complete, dev, period);
3613 }
3614 }
3615
3616 dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out, 1);
3617
3618 /* driver requires remote-wakeup capability during autosuspend. */
3619 intf->needs_remote_wakeup = 1;
3620
3621 ret = register_netdev(netdev);
3622 if (ret != 0) {
3623 netif_err(dev, probe, netdev, "couldn't register the device\n");
3624 goto out3;
3625 }
3626
3627 usb_set_intfdata(intf, dev);
3628
3629 ret = device_set_wakeup_enable(&udev->dev, true);
3630
3631 /* Default delay of 2sec has more overhead than advantage.
3632 * Set to 10sec as default.
3633 */
3634 pm_runtime_set_autosuspend_delay(&udev->dev,
3635 DEFAULT_AUTOSUSPEND_DELAY);
3636
3637 return 0;
3638
3639 out3:
3640 lan78xx_unbind(dev, intf);
3641 out2:
3642 free_netdev(netdev);
3643 out1:
3644 usb_put_dev(udev);
3645
3646 return ret;
3647 }
3648
3649 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
3650 {
3651 const u16 crc16poly = 0x8005;
3652 int i;
3653 u16 bit, crc, msb;
3654 u8 data;
3655
3656 crc = 0xFFFF;
3657 for (i = 0; i < len; i++) {
3658 data = *buf++;
3659 for (bit = 0; bit < 8; bit++) {
3660 msb = crc >> 15;
3661 crc <<= 1;
3662
3663 if (msb ^ (u16)(data & 1)) {
3664 crc ^= crc16poly;
3665 crc |= (u16)0x0001U;
3666 }
3667 data >>= 1;
3668 }
3669 }
3670
3671 return crc;
3672 }
3673
3674 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
3675 {
3676 u32 buf;
3677 int ret;
3678 int mask_index;
3679 u16 crc;
3680 u32 temp_wucsr;
3681 u32 temp_pmt_ctl;
3682 const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
3683 const u8 ipv6_multicast[3] = { 0x33, 0x33 };
3684 const u8 arp_type[2] = { 0x08, 0x06 };
3685
3686 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3687 buf &= ~MAC_TX_TXEN_;
3688 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3689 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3690 buf &= ~MAC_RX_RXEN_;
3691 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3692
3693 ret = lan78xx_write_reg(dev, WUCSR, 0);
3694 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3695 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3696
3697 temp_wucsr = 0;
3698
3699 temp_pmt_ctl = 0;
3700 ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
3701 temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
3702 temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
3703
3704 for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
3705 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
3706
3707 mask_index = 0;
3708 if (wol & WAKE_PHY) {
3709 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
3710
3711 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3712 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3713 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3714 }
3715 if (wol & WAKE_MAGIC) {
3716 temp_wucsr |= WUCSR_MPEN_;
3717
3718 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3719 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3720 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
3721 }
3722 if (wol & WAKE_BCAST) {
3723 temp_wucsr |= WUCSR_BCST_EN_;
3724
3725 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3726 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3727 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3728 }
3729 if (wol & WAKE_MCAST) {
3730 temp_wucsr |= WUCSR_WAKE_EN_;
3731
3732 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
3733 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
3734 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3735 WUF_CFGX_EN_ |
3736 WUF_CFGX_TYPE_MCAST_ |
3737 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3738 (crc & WUF_CFGX_CRC16_MASK_));
3739
3740 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
3741 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3742 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3743 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3744 mask_index++;
3745
3746 /* for IPv6 Multicast */
3747 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
3748 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3749 WUF_CFGX_EN_ |
3750 WUF_CFGX_TYPE_MCAST_ |
3751 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3752 (crc & WUF_CFGX_CRC16_MASK_));
3753
3754 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
3755 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3756 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3757 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3758 mask_index++;
3759
3760 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3761 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3762 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3763 }
3764 if (wol & WAKE_UCAST) {
3765 temp_wucsr |= WUCSR_PFDA_EN_;
3766
3767 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3768 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3769 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3770 }
3771 if (wol & WAKE_ARP) {
3772 temp_wucsr |= WUCSR_WAKE_EN_;
3773
3774 /* set WUF_CFG & WUF_MASK
3775 * for packettype (offset 12,13) = ARP (0x0806)
3776 */
3777 crc = lan78xx_wakeframe_crc16(arp_type, 2);
3778 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3779 WUF_CFGX_EN_ |
3780 WUF_CFGX_TYPE_ALL_ |
3781 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3782 (crc & WUF_CFGX_CRC16_MASK_));
3783
3784 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
3785 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3786 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3787 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3788 mask_index++;
3789
3790 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3791 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3792 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3793 }
3794
3795 ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
3796
3797 /* when multiple WOL bits are set */
3798 if (hweight_long((unsigned long)wol) > 1) {
3799 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3800 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3801 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3802 }
3803 ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
3804
3805 /* clear WUPS */
3806 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3807 buf |= PMT_CTL_WUPS_MASK_;
3808 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3809
3810 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3811 buf |= MAC_RX_RXEN_;
3812 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3813
3814 return 0;
3815 }
3816
3817 static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
3818 {
3819 struct lan78xx_net *dev = usb_get_intfdata(intf);
3820 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3821 u32 buf;
3822 int ret;
3823 int event;
3824
3825 event = message.event;
3826
3827 if (!dev->suspend_count++) {
3828 spin_lock_irq(&dev->txq.lock);
3829 /* don't autosuspend while transmitting */
3830 if ((skb_queue_len(&dev->txq) ||
3831 skb_queue_len(&dev->txq_pend)) &&
3832 PMSG_IS_AUTO(message)) {
3833 spin_unlock_irq(&dev->txq.lock);
3834 ret = -EBUSY;
3835 goto out;
3836 } else {
3837 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
3838 spin_unlock_irq(&dev->txq.lock);
3839 }
3840
3841 /* stop TX & RX */
3842 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3843 buf &= ~MAC_TX_TXEN_;
3844 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3845 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3846 buf &= ~MAC_RX_RXEN_;
3847 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3848
3849 /* empty out the rx and queues */
3850 netif_device_detach(dev->net);
3851 lan78xx_terminate_urbs(dev);
3852 usb_kill_urb(dev->urb_intr);
3853
3854 /* reattach */
3855 netif_device_attach(dev->net);
3856 }
3857
3858 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3859 del_timer(&dev->stat_monitor);
3860
3861 if (PMSG_IS_AUTO(message)) {
3862 /* auto suspend (selective suspend) */
3863 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3864 buf &= ~MAC_TX_TXEN_;
3865 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3866 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3867 buf &= ~MAC_RX_RXEN_;
3868 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3869
3870 ret = lan78xx_write_reg(dev, WUCSR, 0);
3871 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3872 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3873
3874 /* set goodframe wakeup */
3875 ret = lan78xx_read_reg(dev, WUCSR, &buf);
3876
3877 buf |= WUCSR_RFE_WAKE_EN_;
3878 buf |= WUCSR_STORE_WAKE_;
3879
3880 ret = lan78xx_write_reg(dev, WUCSR, buf);
3881
3882 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3883
3884 buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
3885 buf |= PMT_CTL_RES_CLR_WKP_STS_;
3886
3887 buf |= PMT_CTL_PHY_WAKE_EN_;
3888 buf |= PMT_CTL_WOL_EN_;
3889 buf &= ~PMT_CTL_SUS_MODE_MASK_;
3890 buf |= PMT_CTL_SUS_MODE_3_;
3891
3892 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3893
3894 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3895
3896 buf |= PMT_CTL_WUPS_MASK_;
3897
3898 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3899
3900 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3901 buf |= MAC_RX_RXEN_;
3902 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3903 } else {
3904 lan78xx_set_suspend(dev, pdata->wol);
3905 }
3906 }
3907
3908 ret = 0;
3909 out:
3910 return ret;
3911 }
3912
3913 static int lan78xx_resume(struct usb_interface *intf)
3914 {
3915 struct lan78xx_net *dev = usb_get_intfdata(intf);
3916 struct sk_buff *skb;
3917 struct urb *res;
3918 int ret;
3919 u32 buf;
3920
3921 if (!timer_pending(&dev->stat_monitor)) {
3922 dev->delta = 1;
3923 mod_timer(&dev->stat_monitor,
3924 jiffies + STAT_UPDATE_TIMER);
3925 }
3926
3927 if (!--dev->suspend_count) {
3928 /* resume interrupt URBs */
3929 if (dev->urb_intr && test_bit(EVENT_DEV_OPEN, &dev->flags))
3930 usb_submit_urb(dev->urb_intr, GFP_NOIO);
3931
3932 spin_lock_irq(&dev->txq.lock);
3933 while ((res = usb_get_from_anchor(&dev->deferred))) {
3934 skb = (struct sk_buff *)res->context;
3935 ret = usb_submit_urb(res, GFP_ATOMIC);
3936 if (ret < 0) {
3937 dev_kfree_skb_any(skb);
3938 usb_free_urb(res);
3939 usb_autopm_put_interface_async(dev->intf);
3940 } else {
3941 netif_trans_update(dev->net);
3942 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3943 }
3944 }
3945
3946 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
3947 spin_unlock_irq(&dev->txq.lock);
3948
3949 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
3950 if (!(skb_queue_len(&dev->txq) >= dev->tx_qlen))
3951 netif_start_queue(dev->net);
3952 tasklet_schedule(&dev->bh);
3953 }
3954 }
3955
3956 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3957 ret = lan78xx_write_reg(dev, WUCSR, 0);
3958 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3959
3960 ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
3961 WUCSR2_ARP_RCD_ |
3962 WUCSR2_IPV6_TCPSYN_RCD_ |
3963 WUCSR2_IPV4_TCPSYN_RCD_);
3964
3965 ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
3966 WUCSR_EEE_RX_WAKE_ |
3967 WUCSR_PFDA_FR_ |
3968 WUCSR_RFE_WAKE_FR_ |
3969 WUCSR_WUFR_ |
3970 WUCSR_MPR_ |
3971 WUCSR_BCST_FR_);
3972
3973 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3974 buf |= MAC_TX_TXEN_;
3975 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3976
3977 return 0;
3978 }
3979
3980 static int lan78xx_reset_resume(struct usb_interface *intf)
3981 {
3982 struct lan78xx_net *dev = usb_get_intfdata(intf);
3983
3984 lan78xx_reset(dev);
3985
3986 lan78xx_phy_init(dev);
3987
3988 return lan78xx_resume(intf);
3989 }
3990
3991 static const struct usb_device_id products[] = {
3992 {
3993 /* LAN7800 USB Gigabit Ethernet Device */
3994 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
3995 },
3996 {
3997 /* LAN7850 USB Gigabit Ethernet Device */
3998 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
3999 },
4000 {
4001 /* LAN7801 USB Gigabit Ethernet Device */
4002 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
4003 },
4004 {},
4005 };
4006 MODULE_DEVICE_TABLE(usb, products);
4007
4008 static struct usb_driver lan78xx_driver = {
4009 .name = DRIVER_NAME,
4010 .id_table = products,
4011 .probe = lan78xx_probe,
4012 .disconnect = lan78xx_disconnect,
4013 .suspend = lan78xx_suspend,
4014 .resume = lan78xx_resume,
4015 .reset_resume = lan78xx_reset_resume,
4016 .supports_autosuspend = 1,
4017 .disable_hub_initiated_lpm = 1,
4018 };
4019
4020 module_usb_driver(lan78xx_driver);
4021
4022 MODULE_AUTHOR(DRIVER_AUTHOR);
4023 MODULE_DESCRIPTION(DRIVER_DESC);
4024 MODULE_LICENSE("GPL");
Linux with added FPC-III support