]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - drivers/net/usb/lan78xx.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:


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