1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2015 Microchip Technology
5 #include <linux/module.h>
6 #include <linux/netdevice.h>
7 #include <linux/etherdevice.h>
8 #include <linux/ethtool.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>
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>
34 #define DRIVER_DESC "LAN78XX USB 3.0 Gigabit Ethernet Devices"
35 #define DRIVER_NAME "lan78xx"
37 #define TX_TIMEOUT_JIFFIES (5 * HZ)
38 #define THROTTLE_JIFFIES (HZ / 8)
39 #define UNLINK_TIMEOUT_MS 3
41 #define RX_MAX_QUEUE_MEMORY (60 * 1518)
43 #define SS_USB_PKT_SIZE (1024)
44 #define HS_USB_PKT_SIZE (512)
45 #define FS_USB_PKT_SIZE (64)
47 #define MAX_RX_FIFO_SIZE (12 * 1024)
48 #define MAX_TX_FIFO_SIZE (12 * 1024)
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))
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
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
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_ALIGNMENT (4)
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)
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)
91 #define WAKE_ALL (WAKE_PHY | WAKE_UCAST | \
92 WAKE_MCAST | WAKE_BCAST | \
93 WAKE_ARP | WAKE_MAGIC)
96 #define TX_SS_URB_NUM TX_URB_NUM
97 #define TX_HS_URB_NUM TX_URB_NUM
98 #define TX_FS_URB_NUM TX_URB_NUM
100 /* A single URB buffer must be large enough to hold a complete jumbo packet
102 #define TX_SS_URB_SIZE (32 * 1024)
103 #define TX_HS_URB_SIZE (16 * 1024)
104 #define TX_FS_URB_SIZE (10 * 1024)
106 #define RX_SS_URB_NUM 30
107 #define RX_HS_URB_NUM 10
108 #define RX_FS_URB_NUM 10
109 #define RX_SS_URB_SIZE TX_SS_URB_SIZE
110 #define RX_HS_URB_SIZE TX_HS_URB_SIZE
111 #define RX_FS_URB_SIZE TX_FS_URB_SIZE
113 #define SS_BURST_CAP_SIZE RX_SS_URB_SIZE
114 #define SS_BULK_IN_DELAY 0x2000
115 #define HS_BURST_CAP_SIZE RX_HS_URB_SIZE
116 #define HS_BULK_IN_DELAY 0x2000
117 #define FS_BURST_CAP_SIZE RX_FS_URB_SIZE
118 #define FS_BULK_IN_DELAY 0x2000
121 #define TX_SKB_MIN_LEN (TX_CMD_LEN + ETH_HLEN)
122 #define LAN78XX_TSO_SIZE(dev) ((dev)->tx_urb_size - TX_SKB_MIN_LEN)
124 #define RX_CMD_LEN 10
125 #define RX_SKB_MIN_LEN (RX_CMD_LEN + ETH_HLEN)
126 #define RX_MAX_FRAME_LEN(mtu) ((mtu) + ETH_HLEN + VLAN_HLEN)
128 /* USB related defines */
129 #define BULK_IN_PIPE 1
130 #define BULK_OUT_PIPE 2
132 /* default autosuspend delay (mSec)*/
133 #define DEFAULT_AUTOSUSPEND_DELAY (10 * 1000)
135 /* statistic update interval (mSec) */
136 #define STAT_UPDATE_TIMER (1 * 1000)
138 /* time to wait for MAC or FCT to stop (jiffies) */
139 #define HW_DISABLE_TIMEOUT (HZ / 10)
141 /* time to wait between polling MAC or FCT state (ms) */
142 #define HW_DISABLE_DELAY_MS 1
144 /* defines interrupts from interrupt EP */
145 #define MAX_INT_EP (32)
146 #define INT_EP_INTEP (31)
147 #define INT_EP_OTP_WR_DONE (28)
148 #define INT_EP_EEE_TX_LPI_START (26)
149 #define INT_EP_EEE_TX_LPI_STOP (25)
150 #define INT_EP_EEE_RX_LPI (24)
151 #define INT_EP_MAC_RESET_TIMEOUT (23)
152 #define INT_EP_RDFO (22)
153 #define INT_EP_TXE (21)
154 #define INT_EP_USB_STATUS (20)
155 #define INT_EP_TX_DIS (19)
156 #define INT_EP_RX_DIS (18)
157 #define INT_EP_PHY (17)
158 #define INT_EP_DP (16)
159 #define INT_EP_MAC_ERR (15)
160 #define INT_EP_TDFU (14)
161 #define INT_EP_TDFO (13)
162 #define INT_EP_UTX (12)
163 #define INT_EP_GPIO_11 (11)
164 #define INT_EP_GPIO_10 (10)
165 #define INT_EP_GPIO_9 (9)
166 #define INT_EP_GPIO_8 (8)
167 #define INT_EP_GPIO_7 (7)
168 #define INT_EP_GPIO_6 (6)
169 #define INT_EP_GPIO_5 (5)
170 #define INT_EP_GPIO_4 (4)
171 #define INT_EP_GPIO_3 (3)
172 #define INT_EP_GPIO_2 (2)
173 #define INT_EP_GPIO_1 (1)
174 #define INT_EP_GPIO_0 (0)
176 static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {
178 "RX Alignment Errors",
179 "Rx Fragment Errors",
181 "RX Undersize Frame Errors",
182 "RX Oversize Frame Errors",
184 "RX Unicast Byte Count",
185 "RX Broadcast Byte Count",
186 "RX Multicast Byte Count",
188 "RX Broadcast Frames",
189 "RX Multicast Frames",
192 "RX 65 - 127 Byte Frames",
193 "RX 128 - 255 Byte Frames",
194 "RX 256 - 511 Bytes Frames",
195 "RX 512 - 1023 Byte Frames",
196 "RX 1024 - 1518 Byte Frames",
197 "RX Greater 1518 Byte Frames",
198 "EEE RX LPI Transitions",
201 "TX Excess Deferral Errors",
204 "TX Single Collisions",
205 "TX Multiple Collisions",
206 "TX Excessive Collision",
207 "TX Late Collisions",
208 "TX Unicast Byte Count",
209 "TX Broadcast Byte Count",
210 "TX Multicast Byte Count",
212 "TX Broadcast Frames",
213 "TX Multicast Frames",
216 "TX 65 - 127 Byte Frames",
217 "TX 128 - 255 Byte Frames",
218 "TX 256 - 511 Bytes Frames",
219 "TX 512 - 1023 Byte Frames",
220 "TX 1024 - 1518 Byte Frames",
221 "TX Greater 1518 Byte Frames",
222 "EEE TX LPI Transitions",
226 struct lan78xx_statstage {
228 u32 rx_alignment_errors;
229 u32 rx_fragment_errors;
230 u32 rx_jabber_errors;
231 u32 rx_undersize_frame_errors;
232 u32 rx_oversize_frame_errors;
233 u32 rx_dropped_frames;
234 u32 rx_unicast_byte_count;
235 u32 rx_broadcast_byte_count;
236 u32 rx_multicast_byte_count;
237 u32 rx_unicast_frames;
238 u32 rx_broadcast_frames;
239 u32 rx_multicast_frames;
241 u32 rx_64_byte_frames;
242 u32 rx_65_127_byte_frames;
243 u32 rx_128_255_byte_frames;
244 u32 rx_256_511_bytes_frames;
245 u32 rx_512_1023_byte_frames;
246 u32 rx_1024_1518_byte_frames;
247 u32 rx_greater_1518_byte_frames;
248 u32 eee_rx_lpi_transitions;
251 u32 tx_excess_deferral_errors;
252 u32 tx_carrier_errors;
253 u32 tx_bad_byte_count;
254 u32 tx_single_collisions;
255 u32 tx_multiple_collisions;
256 u32 tx_excessive_collision;
257 u32 tx_late_collisions;
258 u32 tx_unicast_byte_count;
259 u32 tx_broadcast_byte_count;
260 u32 tx_multicast_byte_count;
261 u32 tx_unicast_frames;
262 u32 tx_broadcast_frames;
263 u32 tx_multicast_frames;
265 u32 tx_64_byte_frames;
266 u32 tx_65_127_byte_frames;
267 u32 tx_128_255_byte_frames;
268 u32 tx_256_511_bytes_frames;
269 u32 tx_512_1023_byte_frames;
270 u32 tx_1024_1518_byte_frames;
271 u32 tx_greater_1518_byte_frames;
272 u32 eee_tx_lpi_transitions;
276 struct lan78xx_statstage64 {
278 u64 rx_alignment_errors;
279 u64 rx_fragment_errors;
280 u64 rx_jabber_errors;
281 u64 rx_undersize_frame_errors;
282 u64 rx_oversize_frame_errors;
283 u64 rx_dropped_frames;
284 u64 rx_unicast_byte_count;
285 u64 rx_broadcast_byte_count;
286 u64 rx_multicast_byte_count;
287 u64 rx_unicast_frames;
288 u64 rx_broadcast_frames;
289 u64 rx_multicast_frames;
291 u64 rx_64_byte_frames;
292 u64 rx_65_127_byte_frames;
293 u64 rx_128_255_byte_frames;
294 u64 rx_256_511_bytes_frames;
295 u64 rx_512_1023_byte_frames;
296 u64 rx_1024_1518_byte_frames;
297 u64 rx_greater_1518_byte_frames;
298 u64 eee_rx_lpi_transitions;
301 u64 tx_excess_deferral_errors;
302 u64 tx_carrier_errors;
303 u64 tx_bad_byte_count;
304 u64 tx_single_collisions;
305 u64 tx_multiple_collisions;
306 u64 tx_excessive_collision;
307 u64 tx_late_collisions;
308 u64 tx_unicast_byte_count;
309 u64 tx_broadcast_byte_count;
310 u64 tx_multicast_byte_count;
311 u64 tx_unicast_frames;
312 u64 tx_broadcast_frames;
313 u64 tx_multicast_frames;
315 u64 tx_64_byte_frames;
316 u64 tx_65_127_byte_frames;
317 u64 tx_128_255_byte_frames;
318 u64 tx_256_511_bytes_frames;
319 u64 tx_512_1023_byte_frames;
320 u64 tx_1024_1518_byte_frames;
321 u64 tx_greater_1518_byte_frames;
322 u64 eee_tx_lpi_transitions;
326 static u32 lan78xx_regs[] = {
348 #define PHY_REG_SIZE (32 * sizeof(u32))
352 struct lan78xx_priv {
353 struct lan78xx_net *dev;
355 u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicast hash table */
356 u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */
357 u32 vlan_table[DP_SEL_VHF_VLAN_LEN];
358 struct mutex dataport_mutex; /* for dataport access */
359 spinlock_t rfe_ctl_lock; /* for rfe register access */
360 struct work_struct set_multicast;
361 struct work_struct set_vlan;
375 struct skb_data { /* skb->cb is one of these */
377 struct lan78xx_net *dev;
378 enum skb_state state;
383 #define EVENT_TX_HALT 0
384 #define EVENT_RX_HALT 1
385 #define EVENT_RX_MEMORY 2
386 #define EVENT_STS_SPLIT 3
387 #define EVENT_LINK_RESET 4
388 #define EVENT_RX_PAUSED 5
389 #define EVENT_DEV_WAKING 6
390 #define EVENT_DEV_ASLEEP 7
391 #define EVENT_DEV_OPEN 8
392 #define EVENT_STAT_UPDATE 9
393 #define EVENT_DEV_DISCONNECT 10
396 struct mutex access_lock; /* for stats access */
397 struct lan78xx_statstage saved;
398 struct lan78xx_statstage rollover_count;
399 struct lan78xx_statstage rollover_max;
400 struct lan78xx_statstage64 curr_stat;
403 struct irq_domain_data {
404 struct irq_domain *irqdomain;
406 struct irq_chip *irqchip;
407 irq_flow_handler_t irq_handler;
409 struct mutex irq_lock; /* for irq bus access */
413 struct net_device *net;
414 struct usb_device *udev;
415 struct usb_interface *intf;
418 unsigned int tx_pend_data_len;
424 struct sk_buff_head rxq_free;
425 struct sk_buff_head rxq;
426 struct sk_buff_head rxq_done;
427 struct sk_buff_head rxq_overflow;
428 struct sk_buff_head txq_free;
429 struct sk_buff_head txq;
430 struct sk_buff_head txq_pend;
432 struct napi_struct napi;
434 struct delayed_work wq;
438 struct urb *urb_intr;
439 struct usb_anchor deferred;
441 struct mutex dev_mutex; /* serialise open/stop wrt suspend/resume */
442 struct mutex phy_mutex; /* for phy access */
443 unsigned int pipe_in, pipe_out, pipe_intr;
445 unsigned int bulk_in_delay;
446 unsigned int burst_cap;
450 wait_queue_head_t *wait;
451 unsigned char suspend_count;
453 unsigned int maxpacket;
454 struct timer_list stat_monitor;
456 unsigned long data[5];
463 struct mii_bus *mdiobus;
464 phy_interface_t interface;
467 u8 fc_request_control;
470 struct statstage stats;
472 struct irq_domain_data domain_data;
475 /* define external phy id */
476 #define PHY_LAN8835 (0x0007C130)
477 #define PHY_KSZ9031RNX (0x00221620)
479 /* use ethtool to change the level for any given device */
480 static int msg_level = -1;
481 module_param(msg_level, int, 0);
482 MODULE_PARM_DESC(msg_level, "Override default message level");
484 static struct sk_buff *lan78xx_get_buf(struct sk_buff_head *buf_pool)
486 if (skb_queue_empty(buf_pool))
489 return skb_dequeue(buf_pool);
492 static void lan78xx_release_buf(struct sk_buff_head *buf_pool,
495 buf->data = buf->head;
496 skb_reset_tail_pointer(buf);
501 skb_queue_tail(buf_pool, buf);
504 static void lan78xx_free_buf_pool(struct sk_buff_head *buf_pool)
506 struct skb_data *entry;
509 while (!skb_queue_empty(buf_pool)) {
510 buf = skb_dequeue(buf_pool);
512 entry = (struct skb_data *)buf->cb;
513 usb_free_urb(entry->urb);
514 dev_kfree_skb_any(buf);
519 static int lan78xx_alloc_buf_pool(struct sk_buff_head *buf_pool,
520 size_t n_urbs, size_t urb_size,
521 struct lan78xx_net *dev)
523 struct skb_data *entry;
528 skb_queue_head_init(buf_pool);
530 for (i = 0; i < n_urbs; i++) {
531 buf = alloc_skb(urb_size, GFP_ATOMIC);
535 if (skb_linearize(buf) != 0) {
536 dev_kfree_skb_any(buf);
540 urb = usb_alloc_urb(0, GFP_ATOMIC);
542 dev_kfree_skb_any(buf);
546 entry = (struct skb_data *)buf->cb;
550 entry->num_of_packet = 0;
552 skb_queue_tail(buf_pool, buf);
558 lan78xx_free_buf_pool(buf_pool);
563 static struct sk_buff *lan78xx_get_rx_buf(struct lan78xx_net *dev)
565 return lan78xx_get_buf(&dev->rxq_free);
568 static void lan78xx_release_rx_buf(struct lan78xx_net *dev,
569 struct sk_buff *rx_buf)
571 lan78xx_release_buf(&dev->rxq_free, rx_buf);
574 static void lan78xx_free_rx_resources(struct lan78xx_net *dev)
576 lan78xx_free_buf_pool(&dev->rxq_free);
579 static int lan78xx_alloc_rx_resources(struct lan78xx_net *dev)
581 return lan78xx_alloc_buf_pool(&dev->rxq_free,
582 dev->n_rx_urbs, dev->rx_urb_size, dev);
585 static struct sk_buff *lan78xx_get_tx_buf(struct lan78xx_net *dev)
587 return lan78xx_get_buf(&dev->txq_free);
590 static void lan78xx_release_tx_buf(struct lan78xx_net *dev,
591 struct sk_buff *tx_buf)
593 lan78xx_release_buf(&dev->txq_free, tx_buf);
596 static void lan78xx_free_tx_resources(struct lan78xx_net *dev)
598 lan78xx_free_buf_pool(&dev->txq_free);
601 static int lan78xx_alloc_tx_resources(struct lan78xx_net *dev)
603 return lan78xx_alloc_buf_pool(&dev->txq_free,
604 dev->n_tx_urbs, dev->tx_urb_size, dev);
607 static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
612 if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
615 buf = kmalloc(sizeof(u32), GFP_KERNEL);
619 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
620 USB_VENDOR_REQUEST_READ_REGISTER,
621 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
622 0, index, buf, 4, USB_CTRL_GET_TIMEOUT);
623 if (likely(ret >= 0)) {
626 } else if (net_ratelimit()) {
627 netdev_warn(dev->net,
628 "Failed to read register index 0x%08x. ret = %d",
637 static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
642 if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
645 buf = kmalloc(sizeof(u32), GFP_KERNEL);
652 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
653 USB_VENDOR_REQUEST_WRITE_REGISTER,
654 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
655 0, index, buf, 4, USB_CTRL_SET_TIMEOUT);
656 if (unlikely(ret < 0) &&
658 netdev_warn(dev->net,
659 "Failed to write register index 0x%08x. ret = %d",
668 static int lan78xx_update_reg(struct lan78xx_net *dev, u32 reg, u32 mask,
674 ret = lan78xx_read_reg(dev, reg, &buf);
679 buf |= (mask & data);
681 ret = lan78xx_write_reg(dev, reg, buf);
688 static int lan78xx_read_stats(struct lan78xx_net *dev,
689 struct lan78xx_statstage *data)
693 struct lan78xx_statstage *stats;
697 stats = kmalloc(sizeof(*stats), GFP_KERNEL);
701 ret = usb_control_msg(dev->udev,
702 usb_rcvctrlpipe(dev->udev, 0),
703 USB_VENDOR_REQUEST_GET_STATS,
704 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
709 USB_CTRL_SET_TIMEOUT);
710 if (likely(ret >= 0)) {
713 for (i = 0; i < sizeof(*stats) / sizeof(u32); i++) {
714 le32_to_cpus(&src[i]);
718 netdev_warn(dev->net,
719 "Failed to read stat ret = %d", ret);
727 #define check_counter_rollover(struct1, dev_stats, member) \
729 if ((struct1)->member < (dev_stats).saved.member) \
730 (dev_stats).rollover_count.member++; \
733 static void lan78xx_check_stat_rollover(struct lan78xx_net *dev,
734 struct lan78xx_statstage *stats)
736 check_counter_rollover(stats, dev->stats, rx_fcs_errors);
737 check_counter_rollover(stats, dev->stats, rx_alignment_errors);
738 check_counter_rollover(stats, dev->stats, rx_fragment_errors);
739 check_counter_rollover(stats, dev->stats, rx_jabber_errors);
740 check_counter_rollover(stats, dev->stats, rx_undersize_frame_errors);
741 check_counter_rollover(stats, dev->stats, rx_oversize_frame_errors);
742 check_counter_rollover(stats, dev->stats, rx_dropped_frames);
743 check_counter_rollover(stats, dev->stats, rx_unicast_byte_count);
744 check_counter_rollover(stats, dev->stats, rx_broadcast_byte_count);
745 check_counter_rollover(stats, dev->stats, rx_multicast_byte_count);
746 check_counter_rollover(stats, dev->stats, rx_unicast_frames);
747 check_counter_rollover(stats, dev->stats, rx_broadcast_frames);
748 check_counter_rollover(stats, dev->stats, rx_multicast_frames);
749 check_counter_rollover(stats, dev->stats, rx_pause_frames);
750 check_counter_rollover(stats, dev->stats, rx_64_byte_frames);
751 check_counter_rollover(stats, dev->stats, rx_65_127_byte_frames);
752 check_counter_rollover(stats, dev->stats, rx_128_255_byte_frames);
753 check_counter_rollover(stats, dev->stats, rx_256_511_bytes_frames);
754 check_counter_rollover(stats, dev->stats, rx_512_1023_byte_frames);
755 check_counter_rollover(stats, dev->stats, rx_1024_1518_byte_frames);
756 check_counter_rollover(stats, dev->stats, rx_greater_1518_byte_frames);
757 check_counter_rollover(stats, dev->stats, eee_rx_lpi_transitions);
758 check_counter_rollover(stats, dev->stats, eee_rx_lpi_time);
759 check_counter_rollover(stats, dev->stats, tx_fcs_errors);
760 check_counter_rollover(stats, dev->stats, tx_excess_deferral_errors);
761 check_counter_rollover(stats, dev->stats, tx_carrier_errors);
762 check_counter_rollover(stats, dev->stats, tx_bad_byte_count);
763 check_counter_rollover(stats, dev->stats, tx_single_collisions);
764 check_counter_rollover(stats, dev->stats, tx_multiple_collisions);
765 check_counter_rollover(stats, dev->stats, tx_excessive_collision);
766 check_counter_rollover(stats, dev->stats, tx_late_collisions);
767 check_counter_rollover(stats, dev->stats, tx_unicast_byte_count);
768 check_counter_rollover(stats, dev->stats, tx_broadcast_byte_count);
769 check_counter_rollover(stats, dev->stats, tx_multicast_byte_count);
770 check_counter_rollover(stats, dev->stats, tx_unicast_frames);
771 check_counter_rollover(stats, dev->stats, tx_broadcast_frames);
772 check_counter_rollover(stats, dev->stats, tx_multicast_frames);
773 check_counter_rollover(stats, dev->stats, tx_pause_frames);
774 check_counter_rollover(stats, dev->stats, tx_64_byte_frames);
775 check_counter_rollover(stats, dev->stats, tx_65_127_byte_frames);
776 check_counter_rollover(stats, dev->stats, tx_128_255_byte_frames);
777 check_counter_rollover(stats, dev->stats, tx_256_511_bytes_frames);
778 check_counter_rollover(stats, dev->stats, tx_512_1023_byte_frames);
779 check_counter_rollover(stats, dev->stats, tx_1024_1518_byte_frames);
780 check_counter_rollover(stats, dev->stats, tx_greater_1518_byte_frames);
781 check_counter_rollover(stats, dev->stats, eee_tx_lpi_transitions);
782 check_counter_rollover(stats, dev->stats, eee_tx_lpi_time);
784 memcpy(&dev->stats.saved, stats, sizeof(struct lan78xx_statstage));
787 static void lan78xx_update_stats(struct lan78xx_net *dev)
789 u32 *p, *count, *max;
792 struct lan78xx_statstage lan78xx_stats;
794 if (usb_autopm_get_interface(dev->intf) < 0)
797 p = (u32 *)&lan78xx_stats;
798 count = (u32 *)&dev->stats.rollover_count;
799 max = (u32 *)&dev->stats.rollover_max;
800 data = (u64 *)&dev->stats.curr_stat;
802 mutex_lock(&dev->stats.access_lock);
804 if (lan78xx_read_stats(dev, &lan78xx_stats) > 0)
805 lan78xx_check_stat_rollover(dev, &lan78xx_stats);
807 for (i = 0; i < (sizeof(lan78xx_stats) / (sizeof(u32))); i++)
808 data[i] = (u64)p[i] + ((u64)count[i] * ((u64)max[i] + 1));
810 mutex_unlock(&dev->stats.access_lock);
812 usb_autopm_put_interface(dev->intf);
815 /* Loop until the read is completed with timeout called with phy_mutex held */
816 static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)
818 unsigned long start_time = jiffies;
823 ret = lan78xx_read_reg(dev, MII_ACC, &val);
824 if (unlikely(ret < 0))
827 if (!(val & MII_ACC_MII_BUSY_))
829 } while (!time_after(jiffies, start_time + HZ));
834 static inline u32 mii_access(int id, int index, int read)
838 ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;
839 ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;
841 ret |= MII_ACC_MII_READ_;
843 ret |= MII_ACC_MII_WRITE_;
844 ret |= MII_ACC_MII_BUSY_;
849 static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
851 unsigned long start_time = jiffies;
856 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
857 if (unlikely(ret < 0))
860 if (!(val & E2P_CMD_EPC_BUSY_) ||
861 (val & E2P_CMD_EPC_TIMEOUT_))
863 usleep_range(40, 100);
864 } while (!time_after(jiffies, start_time + HZ));
866 if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
867 netdev_warn(dev->net, "EEPROM read operation timeout");
874 static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
876 unsigned long start_time = jiffies;
881 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
882 if (unlikely(ret < 0))
885 if (!(val & E2P_CMD_EPC_BUSY_))
888 usleep_range(40, 100);
889 } while (!time_after(jiffies, start_time + HZ));
891 netdev_warn(dev->net, "EEPROM is busy");
895 static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
896 u32 length, u8 *data)
903 /* depends on chip, some EEPROM pins are muxed with LED function.
904 * disable & restore LED function to access EEPROM.
906 ret = lan78xx_read_reg(dev, HW_CFG, &val);
908 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
909 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
910 ret = lan78xx_write_reg(dev, HW_CFG, val);
913 retval = lan78xx_eeprom_confirm_not_busy(dev);
917 for (i = 0; i < length; i++) {
918 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
919 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
920 ret = lan78xx_write_reg(dev, E2P_CMD, val);
921 if (unlikely(ret < 0)) {
926 retval = lan78xx_wait_eeprom(dev);
930 ret = lan78xx_read_reg(dev, E2P_DATA, &val);
931 if (unlikely(ret < 0)) {
936 data[i] = val & 0xFF;
942 if (dev->chipid == ID_REV_CHIP_ID_7800_)
943 ret = lan78xx_write_reg(dev, HW_CFG, saved);
948 static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
949 u32 length, u8 *data)
954 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
955 if ((ret == 0) && (sig == EEPROM_INDICATOR))
956 ret = lan78xx_read_raw_eeprom(dev, offset, length, data);
963 static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
964 u32 length, u8 *data)
971 /* depends on chip, some EEPROM pins are muxed with LED function.
972 * disable & restore LED function to access EEPROM.
974 ret = lan78xx_read_reg(dev, HW_CFG, &val);
976 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
977 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
978 ret = lan78xx_write_reg(dev, HW_CFG, val);
981 retval = lan78xx_eeprom_confirm_not_busy(dev);
985 /* Issue write/erase enable command */
986 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
987 ret = lan78xx_write_reg(dev, E2P_CMD, val);
988 if (unlikely(ret < 0)) {
993 retval = lan78xx_wait_eeprom(dev);
997 for (i = 0; i < length; i++) {
998 /* Fill data register */
1000 ret = lan78xx_write_reg(dev, E2P_DATA, val);
1006 /* Send "write" command */
1007 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
1008 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
1009 ret = lan78xx_write_reg(dev, E2P_CMD, val);
1015 retval = lan78xx_wait_eeprom(dev);
1024 if (dev->chipid == ID_REV_CHIP_ID_7800_)
1025 ret = lan78xx_write_reg(dev, HW_CFG, saved);
1030 static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
1031 u32 length, u8 *data)
1035 unsigned long timeout;
1037 lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1039 if (buf & OTP_PWR_DN_PWRDN_N_) {
1040 /* clear it and wait to be cleared */
1041 lan78xx_write_reg(dev, OTP_PWR_DN, 0);
1043 timeout = jiffies + HZ;
1045 usleep_range(1, 10);
1046 lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1047 if (time_after(jiffies, timeout)) {
1048 netdev_warn(dev->net,
1049 "timeout on OTP_PWR_DN");
1052 } while (buf & OTP_PWR_DN_PWRDN_N_);
1055 for (i = 0; i < length; i++) {
1056 lan78xx_write_reg(dev, OTP_ADDR1,
1057 ((offset + i) >> 8) & OTP_ADDR1_15_11);
1058 lan78xx_write_reg(dev, OTP_ADDR2,
1059 ((offset + i) & OTP_ADDR2_10_3));
1061 lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
1062 lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
1064 timeout = jiffies + HZ;
1067 lan78xx_read_reg(dev, OTP_STATUS, &buf);
1068 if (time_after(jiffies, timeout)) {
1069 netdev_warn(dev->net,
1070 "timeout on OTP_STATUS");
1073 } while (buf & OTP_STATUS_BUSY_);
1075 lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
1077 data[i] = (u8)(buf & 0xFF);
1083 static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
1084 u32 length, u8 *data)
1088 unsigned long timeout;
1090 lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1092 if (buf & OTP_PWR_DN_PWRDN_N_) {
1093 /* clear it and wait to be cleared */
1094 lan78xx_write_reg(dev, OTP_PWR_DN, 0);
1096 timeout = jiffies + HZ;
1099 lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1100 if (time_after(jiffies, timeout)) {
1101 netdev_warn(dev->net,
1102 "timeout on OTP_PWR_DN completion");
1105 } while (buf & OTP_PWR_DN_PWRDN_N_);
1108 /* set to BYTE program mode */
1109 lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
1111 for (i = 0; i < length; i++) {
1112 lan78xx_write_reg(dev, OTP_ADDR1,
1113 ((offset + i) >> 8) & OTP_ADDR1_15_11);
1114 lan78xx_write_reg(dev, OTP_ADDR2,
1115 ((offset + i) & OTP_ADDR2_10_3));
1116 lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
1117 lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
1118 lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
1120 timeout = jiffies + HZ;
1123 lan78xx_read_reg(dev, OTP_STATUS, &buf);
1124 if (time_after(jiffies, timeout)) {
1125 netdev_warn(dev->net,
1126 "Timeout on OTP_STATUS completion");
1129 } while (buf & OTP_STATUS_BUSY_);
1135 static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
1136 u32 length, u8 *data)
1141 ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
1144 if (sig == OTP_INDICATOR_2)
1146 else if (sig != OTP_INDICATOR_1)
1149 ret = lan78xx_read_raw_otp(dev, offset, length, data);
1155 static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
1159 for (i = 0; i < 100; i++) {
1162 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
1163 if (unlikely(ret < 0))
1166 if (dp_sel & DP_SEL_DPRDY_)
1169 usleep_range(40, 100);
1172 netdev_warn(dev->net, "%s timed out", __func__);
1177 static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
1178 u32 addr, u32 length, u32 *buf)
1180 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1184 if (usb_autopm_get_interface(dev->intf) < 0)
1187 mutex_lock(&pdata->dataport_mutex);
1189 ret = lan78xx_dataport_wait_not_busy(dev);
1193 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
1195 dp_sel &= ~DP_SEL_RSEL_MASK_;
1196 dp_sel |= ram_select;
1197 ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);
1199 for (i = 0; i < length; i++) {
1200 ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
1202 ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
1204 ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
1206 ret = lan78xx_dataport_wait_not_busy(dev);
1212 mutex_unlock(&pdata->dataport_mutex);
1213 usb_autopm_put_interface(dev->intf);
1218 static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,
1219 int index, u8 addr[ETH_ALEN])
1223 if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {
1225 temp = addr[2] | (temp << 8);
1226 temp = addr[1] | (temp << 8);
1227 temp = addr[0] | (temp << 8);
1228 pdata->pfilter_table[index][1] = temp;
1230 temp = addr[4] | (temp << 8);
1231 temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;
1232 pdata->pfilter_table[index][0] = temp;
1236 /* returns hash bit number for given MAC address */
1237 static inline u32 lan78xx_hash(char addr[ETH_ALEN])
1239 return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
1242 static void lan78xx_deferred_multicast_write(struct work_struct *param)
1244 struct lan78xx_priv *pdata =
1245 container_of(param, struct lan78xx_priv, set_multicast);
1246 struct lan78xx_net *dev = pdata->dev;
1249 netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
1252 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,
1253 DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
1255 for (i = 1; i < NUM_OF_MAF; i++) {
1256 lan78xx_write_reg(dev, MAF_HI(i), 0);
1257 lan78xx_write_reg(dev, MAF_LO(i),
1258 pdata->pfilter_table[i][1]);
1259 lan78xx_write_reg(dev, MAF_HI(i),
1260 pdata->pfilter_table[i][0]);
1263 lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1266 static void lan78xx_set_multicast(struct net_device *netdev)
1268 struct lan78xx_net *dev = netdev_priv(netdev);
1269 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1270 unsigned long flags;
1273 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1275 pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |
1276 RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
1278 for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
1279 pdata->mchash_table[i] = 0;
1281 /* pfilter_table[0] has own HW address */
1282 for (i = 1; i < NUM_OF_MAF; i++) {
1283 pdata->pfilter_table[i][0] = 0;
1284 pdata->pfilter_table[i][1] = 0;
1287 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;
1289 if (dev->net->flags & IFF_PROMISC) {
1290 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
1291 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;
1293 if (dev->net->flags & IFF_ALLMULTI) {
1294 netif_dbg(dev, drv, dev->net,
1295 "receive all multicast enabled");
1296 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;
1300 if (netdev_mc_count(dev->net)) {
1301 struct netdev_hw_addr *ha;
1304 netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
1306 pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;
1309 netdev_for_each_mc_addr(ha, netdev) {
1310 /* set first 32 into Perfect Filter */
1312 lan78xx_set_addr_filter(pdata, i, ha->addr);
1314 u32 bitnum = lan78xx_hash(ha->addr);
1316 pdata->mchash_table[bitnum / 32] |=
1317 (1 << (bitnum % 32));
1318 pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;
1324 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1326 /* defer register writes to a sleepable context */
1327 schedule_work(&pdata->set_multicast);
1330 static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1331 u16 lcladv, u16 rmtadv)
1333 u32 flow = 0, fct_flow = 0;
1336 if (dev->fc_autoneg)
1337 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1339 cap = dev->fc_request_control;
1341 if (cap & FLOW_CTRL_TX)
1342 flow |= (FLOW_CR_TX_FCEN_ | 0xFFFF);
1344 if (cap & FLOW_CTRL_RX)
1345 flow |= FLOW_CR_RX_FCEN_;
1347 if (dev->udev->speed == USB_SPEED_SUPER)
1348 fct_flow = FLOW_CTRL_THRESHOLD(FLOW_ON_SS, FLOW_OFF_SS);
1349 else if (dev->udev->speed == USB_SPEED_HIGH)
1350 fct_flow = FLOW_CTRL_THRESHOLD(FLOW_ON_HS, FLOW_OFF_HS);
1352 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1353 (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
1354 (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
1356 lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1358 /* threshold value should be set before enabling flow */
1359 lan78xx_write_reg(dev, FLOW, flow);
1364 static void lan78xx_rx_urb_submit_all(struct lan78xx_net *dev);
1366 static int lan78xx_mac_reset(struct lan78xx_net *dev)
1368 unsigned long start_time = jiffies;
1372 mutex_lock(&dev->phy_mutex);
1374 /* Resetting the device while there is activity on the MDIO
1375 * bus can result in the MAC interface locking up and not
1376 * completing register access transactions.
1378 ret = lan78xx_phy_wait_not_busy(dev);
1382 ret = lan78xx_read_reg(dev, MAC_CR, &val);
1387 ret = lan78xx_write_reg(dev, MAC_CR, val);
1391 /* Wait for the reset to complete before allowing any further
1392 * MAC register accesses otherwise the MAC may lock up.
1395 ret = lan78xx_read_reg(dev, MAC_CR, &val);
1399 if (!(val & MAC_CR_RST_)) {
1403 } while (!time_after(jiffies, start_time + HZ));
1407 mutex_unlock(&dev->phy_mutex);
1412 static int lan78xx_link_reset(struct lan78xx_net *dev)
1414 struct phy_device *phydev = dev->net->phydev;
1415 struct ethtool_link_ksettings ecmd;
1416 int ladv, radv, ret, link;
1419 /* clear LAN78xx interrupt status */
1420 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1421 if (unlikely(ret < 0))
1424 mutex_lock(&phydev->lock);
1425 phy_read_status(phydev);
1426 link = phydev->link;
1427 mutex_unlock(&phydev->lock);
1429 if (!link && dev->link_on) {
1430 dev->link_on = false;
1433 ret = lan78xx_mac_reset(dev);
1437 del_timer(&dev->stat_monitor);
1438 } else if (link && !dev->link_on) {
1439 dev->link_on = true;
1441 phy_ethtool_ksettings_get(phydev, &ecmd);
1443 if (dev->udev->speed == USB_SPEED_SUPER) {
1444 if (ecmd.base.speed == 1000) {
1446 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1449 buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1450 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1454 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1457 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1458 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1462 /* enable U1 & U2 */
1463 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1466 buf |= USB_CFG1_DEV_U2_INIT_EN_;
1467 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1468 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1474 ladv = phy_read(phydev, MII_ADVERTISE);
1478 radv = phy_read(phydev, MII_LPA);
1482 netif_dbg(dev, link, dev->net,
1483 "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1484 ecmd.base.speed, ecmd.base.duplex, ladv, radv);
1486 ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,
1491 if (!timer_pending(&dev->stat_monitor)) {
1493 mod_timer(&dev->stat_monitor,
1494 jiffies + STAT_UPDATE_TIMER);
1497 lan78xx_rx_urb_submit_all(dev);
1500 napi_schedule(&dev->napi);
1507 /* some work can't be done in tasklets, so we use keventd
1509 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
1510 * but tasklet_schedule() doesn't. hope the failure is rare.
1512 static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1514 set_bit(work, &dev->flags);
1515 if (!schedule_delayed_work(&dev->wq, 0))
1516 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1519 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1523 if (urb->actual_length != 4) {
1524 netdev_warn(dev->net,
1525 "unexpected urb length %d", urb->actual_length);
1529 intdata = get_unaligned_le32(urb->transfer_buffer);
1531 if (intdata & INT_ENP_PHY_INT) {
1532 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1533 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1535 if (dev->domain_data.phyirq > 0)
1536 generic_handle_irq_safe(dev->domain_data.phyirq);
1538 netdev_warn(dev->net,
1539 "unexpected interrupt: 0x%08x\n", intdata);
1543 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1545 return MAX_EEPROM_SIZE;
1548 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1549 struct ethtool_eeprom *ee, u8 *data)
1551 struct lan78xx_net *dev = netdev_priv(netdev);
1554 ret = usb_autopm_get_interface(dev->intf);
1558 ee->magic = LAN78XX_EEPROM_MAGIC;
1560 ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1562 usb_autopm_put_interface(dev->intf);
1567 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1568 struct ethtool_eeprom *ee, u8 *data)
1570 struct lan78xx_net *dev = netdev_priv(netdev);
1573 ret = usb_autopm_get_interface(dev->intf);
1577 /* Invalid EEPROM_INDICATOR at offset zero will result in a failure
1578 * to load data from EEPROM
1580 if (ee->magic == LAN78XX_EEPROM_MAGIC)
1581 ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1582 else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1583 (ee->offset == 0) &&
1585 (data[0] == OTP_INDICATOR_1))
1586 ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1588 usb_autopm_put_interface(dev->intf);
1593 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1596 if (stringset == ETH_SS_STATS)
1597 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1600 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1602 if (sset == ETH_SS_STATS)
1603 return ARRAY_SIZE(lan78xx_gstrings);
1608 static void lan78xx_get_stats(struct net_device *netdev,
1609 struct ethtool_stats *stats, u64 *data)
1611 struct lan78xx_net *dev = netdev_priv(netdev);
1613 lan78xx_update_stats(dev);
1615 mutex_lock(&dev->stats.access_lock);
1616 memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1617 mutex_unlock(&dev->stats.access_lock);
1620 static void lan78xx_get_wol(struct net_device *netdev,
1621 struct ethtool_wolinfo *wol)
1623 struct lan78xx_net *dev = netdev_priv(netdev);
1626 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1628 if (usb_autopm_get_interface(dev->intf) < 0)
1631 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1632 if (unlikely(ret < 0)) {
1636 if (buf & USB_CFG_RMT_WKP_) {
1637 wol->supported = WAKE_ALL;
1638 wol->wolopts = pdata->wol;
1645 usb_autopm_put_interface(dev->intf);
1648 static int lan78xx_set_wol(struct net_device *netdev,
1649 struct ethtool_wolinfo *wol)
1651 struct lan78xx_net *dev = netdev_priv(netdev);
1652 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1655 ret = usb_autopm_get_interface(dev->intf);
1659 if (wol->wolopts & ~WAKE_ALL)
1662 pdata->wol = wol->wolopts;
1664 device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1666 phy_ethtool_set_wol(netdev->phydev, wol);
1668 usb_autopm_put_interface(dev->intf);
1673 static int lan78xx_get_eee(struct net_device *net, struct ethtool_keee *edata)
1675 struct lan78xx_net *dev = netdev_priv(net);
1676 struct phy_device *phydev = net->phydev;
1680 ret = usb_autopm_get_interface(dev->intf);
1684 ret = phy_ethtool_get_eee(phydev, edata);
1688 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1689 if (buf & MAC_CR_EEE_EN_) {
1690 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1691 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1692 edata->tx_lpi_timer = buf;
1694 edata->tx_lpi_timer = 0;
1699 usb_autopm_put_interface(dev->intf);
1704 static int lan78xx_set_eee(struct net_device *net, struct ethtool_keee *edata)
1706 struct lan78xx_net *dev = netdev_priv(net);
1710 ret = usb_autopm_get_interface(dev->intf);
1714 ret = phy_ethtool_set_eee(net->phydev, edata);
1718 buf = (u32)edata->tx_lpi_timer;
1719 ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1721 usb_autopm_put_interface(dev->intf);
1726 static u32 lan78xx_get_link(struct net_device *net)
1730 mutex_lock(&net->phydev->lock);
1731 phy_read_status(net->phydev);
1732 link = net->phydev->link;
1733 mutex_unlock(&net->phydev->lock);
1738 static void lan78xx_get_drvinfo(struct net_device *net,
1739 struct ethtool_drvinfo *info)
1741 struct lan78xx_net *dev = netdev_priv(net);
1743 strscpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1744 usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1747 static u32 lan78xx_get_msglevel(struct net_device *net)
1749 struct lan78xx_net *dev = netdev_priv(net);
1751 return dev->msg_enable;
1754 static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1756 struct lan78xx_net *dev = netdev_priv(net);
1758 dev->msg_enable = level;
1761 static int lan78xx_get_link_ksettings(struct net_device *net,
1762 struct ethtool_link_ksettings *cmd)
1764 struct lan78xx_net *dev = netdev_priv(net);
1765 struct phy_device *phydev = net->phydev;
1768 ret = usb_autopm_get_interface(dev->intf);
1772 phy_ethtool_ksettings_get(phydev, cmd);
1774 usb_autopm_put_interface(dev->intf);
1779 static int lan78xx_set_link_ksettings(struct net_device *net,
1780 const struct ethtool_link_ksettings *cmd)
1782 struct lan78xx_net *dev = netdev_priv(net);
1783 struct phy_device *phydev = net->phydev;
1787 ret = usb_autopm_get_interface(dev->intf);
1791 /* change speed & duplex */
1792 ret = phy_ethtool_ksettings_set(phydev, cmd);
1794 if (!cmd->base.autoneg) {
1795 /* force link down */
1796 temp = phy_read(phydev, MII_BMCR);
1797 phy_write(phydev, MII_BMCR, temp | BMCR_LOOPBACK);
1799 phy_write(phydev, MII_BMCR, temp);
1802 usb_autopm_put_interface(dev->intf);
1807 static void lan78xx_get_pause(struct net_device *net,
1808 struct ethtool_pauseparam *pause)
1810 struct lan78xx_net *dev = netdev_priv(net);
1811 struct phy_device *phydev = net->phydev;
1812 struct ethtool_link_ksettings ecmd;
1814 phy_ethtool_ksettings_get(phydev, &ecmd);
1816 pause->autoneg = dev->fc_autoneg;
1818 if (dev->fc_request_control & FLOW_CTRL_TX)
1819 pause->tx_pause = 1;
1821 if (dev->fc_request_control & FLOW_CTRL_RX)
1822 pause->rx_pause = 1;
1825 static int lan78xx_set_pause(struct net_device *net,
1826 struct ethtool_pauseparam *pause)
1828 struct lan78xx_net *dev = netdev_priv(net);
1829 struct phy_device *phydev = net->phydev;
1830 struct ethtool_link_ksettings ecmd;
1833 phy_ethtool_ksettings_get(phydev, &ecmd);
1835 if (pause->autoneg && !ecmd.base.autoneg) {
1840 dev->fc_request_control = 0;
1841 if (pause->rx_pause)
1842 dev->fc_request_control |= FLOW_CTRL_RX;
1844 if (pause->tx_pause)
1845 dev->fc_request_control |= FLOW_CTRL_TX;
1847 if (ecmd.base.autoneg) {
1848 __ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
1851 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
1852 ecmd.link_modes.advertising);
1853 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
1854 ecmd.link_modes.advertising);
1855 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
1856 mii_adv_to_linkmode_adv_t(fc, mii_adv);
1857 linkmode_or(ecmd.link_modes.advertising, fc,
1858 ecmd.link_modes.advertising);
1860 phy_ethtool_ksettings_set(phydev, &ecmd);
1863 dev->fc_autoneg = pause->autoneg;
1870 static int lan78xx_get_regs_len(struct net_device *netdev)
1872 if (!netdev->phydev)
1873 return (sizeof(lan78xx_regs));
1875 return (sizeof(lan78xx_regs) + PHY_REG_SIZE);
1879 lan78xx_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
1884 struct lan78xx_net *dev = netdev_priv(netdev);
1886 /* Read Device/MAC registers */
1887 for (i = 0; i < ARRAY_SIZE(lan78xx_regs); i++)
1888 lan78xx_read_reg(dev, lan78xx_regs[i], &data[i]);
1890 if (!netdev->phydev)
1893 /* Read PHY registers */
1894 for (j = 0; j < 32; i++, j++)
1895 data[i] = phy_read(netdev->phydev, j);
1898 static const struct ethtool_ops lan78xx_ethtool_ops = {
1899 .get_link = lan78xx_get_link,
1900 .nway_reset = phy_ethtool_nway_reset,
1901 .get_drvinfo = lan78xx_get_drvinfo,
1902 .get_msglevel = lan78xx_get_msglevel,
1903 .set_msglevel = lan78xx_set_msglevel,
1904 .get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1905 .get_eeprom = lan78xx_ethtool_get_eeprom,
1906 .set_eeprom = lan78xx_ethtool_set_eeprom,
1907 .get_ethtool_stats = lan78xx_get_stats,
1908 .get_sset_count = lan78xx_get_sset_count,
1909 .get_strings = lan78xx_get_strings,
1910 .get_wol = lan78xx_get_wol,
1911 .set_wol = lan78xx_set_wol,
1912 .get_ts_info = ethtool_op_get_ts_info,
1913 .get_eee = lan78xx_get_eee,
1914 .set_eee = lan78xx_set_eee,
1915 .get_pauseparam = lan78xx_get_pause,
1916 .set_pauseparam = lan78xx_set_pause,
1917 .get_link_ksettings = lan78xx_get_link_ksettings,
1918 .set_link_ksettings = lan78xx_set_link_ksettings,
1919 .get_regs_len = lan78xx_get_regs_len,
1920 .get_regs = lan78xx_get_regs,
1923 static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1925 u32 addr_lo, addr_hi;
1928 lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1929 lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1931 addr[0] = addr_lo & 0xFF;
1932 addr[1] = (addr_lo >> 8) & 0xFF;
1933 addr[2] = (addr_lo >> 16) & 0xFF;
1934 addr[3] = (addr_lo >> 24) & 0xFF;
1935 addr[4] = addr_hi & 0xFF;
1936 addr[5] = (addr_hi >> 8) & 0xFF;
1938 if (!is_valid_ether_addr(addr)) {
1939 if (!eth_platform_get_mac_address(&dev->udev->dev, addr)) {
1940 /* valid address present in Device Tree */
1941 netif_dbg(dev, ifup, dev->net,
1942 "MAC address read from Device Tree");
1943 } else if (((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET,
1944 ETH_ALEN, addr) == 0) ||
1945 (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET,
1946 ETH_ALEN, addr) == 0)) &&
1947 is_valid_ether_addr(addr)) {
1948 /* eeprom values are valid so use them */
1949 netif_dbg(dev, ifup, dev->net,
1950 "MAC address read from EEPROM");
1952 /* generate random MAC */
1953 eth_random_addr(addr);
1954 netif_dbg(dev, ifup, dev->net,
1955 "MAC address set to random addr");
1958 addr_lo = addr[0] | (addr[1] << 8) |
1959 (addr[2] << 16) | (addr[3] << 24);
1960 addr_hi = addr[4] | (addr[5] << 8);
1962 lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1963 lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1966 lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1967 lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1969 eth_hw_addr_set(dev->net, addr);
1972 /* MDIO read and write wrappers for phylib */
1973 static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
1975 struct lan78xx_net *dev = bus->priv;
1979 ret = usb_autopm_get_interface(dev->intf);
1983 mutex_lock(&dev->phy_mutex);
1985 /* confirm MII not busy */
1986 ret = lan78xx_phy_wait_not_busy(dev);
1990 /* set the address, index & direction (read from PHY) */
1991 addr = mii_access(phy_id, idx, MII_READ);
1992 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1994 ret = lan78xx_phy_wait_not_busy(dev);
1998 ret = lan78xx_read_reg(dev, MII_DATA, &val);
2000 ret = (int)(val & 0xFFFF);
2003 mutex_unlock(&dev->phy_mutex);
2004 usb_autopm_put_interface(dev->intf);
2009 static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
2012 struct lan78xx_net *dev = bus->priv;
2016 ret = usb_autopm_get_interface(dev->intf);
2020 mutex_lock(&dev->phy_mutex);
2022 /* confirm MII not busy */
2023 ret = lan78xx_phy_wait_not_busy(dev);
2028 ret = lan78xx_write_reg(dev, MII_DATA, val);
2030 /* set the address, index & direction (write to PHY) */
2031 addr = mii_access(phy_id, idx, MII_WRITE);
2032 ret = lan78xx_write_reg(dev, MII_ACC, addr);
2034 ret = lan78xx_phy_wait_not_busy(dev);
2039 mutex_unlock(&dev->phy_mutex);
2040 usb_autopm_put_interface(dev->intf);
2044 static int lan78xx_mdio_init(struct lan78xx_net *dev)
2046 struct device_node *node;
2049 dev->mdiobus = mdiobus_alloc();
2050 if (!dev->mdiobus) {
2051 netdev_err(dev->net, "can't allocate MDIO bus\n");
2055 dev->mdiobus->priv = (void *)dev;
2056 dev->mdiobus->read = lan78xx_mdiobus_read;
2057 dev->mdiobus->write = lan78xx_mdiobus_write;
2058 dev->mdiobus->name = "lan78xx-mdiobus";
2059 dev->mdiobus->parent = &dev->udev->dev;
2061 snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
2062 dev->udev->bus->busnum, dev->udev->devnum);
2064 switch (dev->chipid) {
2065 case ID_REV_CHIP_ID_7800_:
2066 case ID_REV_CHIP_ID_7850_:
2067 /* set to internal PHY id */
2068 dev->mdiobus->phy_mask = ~(1 << 1);
2070 case ID_REV_CHIP_ID_7801_:
2071 /* scan thru PHYAD[2..0] */
2072 dev->mdiobus->phy_mask = ~(0xFF);
2076 node = of_get_child_by_name(dev->udev->dev.of_node, "mdio");
2077 ret = of_mdiobus_register(dev->mdiobus, node);
2080 netdev_err(dev->net, "can't register MDIO bus\n");
2084 netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
2087 mdiobus_free(dev->mdiobus);
2091 static void lan78xx_remove_mdio(struct lan78xx_net *dev)
2093 mdiobus_unregister(dev->mdiobus);
2094 mdiobus_free(dev->mdiobus);
2097 static void lan78xx_link_status_change(struct net_device *net)
2099 struct lan78xx_net *dev = netdev_priv(net);
2100 struct phy_device *phydev = net->phydev;
2104 ret = lan78xx_read_reg(dev, MAC_CR, &data);
2108 if (phydev->enable_tx_lpi)
2109 data |= MAC_CR_EEE_EN_;
2111 data &= ~MAC_CR_EEE_EN_;
2112 lan78xx_write_reg(dev, MAC_CR, data);
2114 phy_print_status(phydev);
2117 static int irq_map(struct irq_domain *d, unsigned int irq,
2118 irq_hw_number_t hwirq)
2120 struct irq_domain_data *data = d->host_data;
2122 irq_set_chip_data(irq, data);
2123 irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);
2124 irq_set_noprobe(irq);
2129 static void irq_unmap(struct irq_domain *d, unsigned int irq)
2131 irq_set_chip_and_handler(irq, NULL, NULL);
2132 irq_set_chip_data(irq, NULL);
2135 static const struct irq_domain_ops chip_domain_ops = {
2140 static void lan78xx_irq_mask(struct irq_data *irqd)
2142 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
2144 data->irqenable &= ~BIT(irqd_to_hwirq(irqd));
2147 static void lan78xx_irq_unmask(struct irq_data *irqd)
2149 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
2151 data->irqenable |= BIT(irqd_to_hwirq(irqd));
2154 static void lan78xx_irq_bus_lock(struct irq_data *irqd)
2156 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
2158 mutex_lock(&data->irq_lock);
2161 static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
2163 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
2164 struct lan78xx_net *dev =
2165 container_of(data, struct lan78xx_net, domain_data);
2168 /* call register access here because irq_bus_lock & irq_bus_sync_unlock
2169 * are only two callbacks executed in non-atomic contex.
2171 lan78xx_read_reg(dev, INT_EP_CTL, &buf);
2172 if (buf != data->irqenable)
2173 lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
2175 mutex_unlock(&data->irq_lock);
2178 static struct irq_chip lan78xx_irqchip = {
2179 .name = "lan78xx-irqs",
2180 .irq_mask = lan78xx_irq_mask,
2181 .irq_unmask = lan78xx_irq_unmask,
2182 .irq_bus_lock = lan78xx_irq_bus_lock,
2183 .irq_bus_sync_unlock = lan78xx_irq_bus_sync_unlock,
2186 static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
2188 struct device_node *of_node;
2189 struct irq_domain *irqdomain;
2190 unsigned int irqmap = 0;
2194 of_node = dev->udev->dev.parent->of_node;
2196 mutex_init(&dev->domain_data.irq_lock);
2198 lan78xx_read_reg(dev, INT_EP_CTL, &buf);
2199 dev->domain_data.irqenable = buf;
2201 dev->domain_data.irqchip = &lan78xx_irqchip;
2202 dev->domain_data.irq_handler = handle_simple_irq;
2204 irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,
2205 &chip_domain_ops, &dev->domain_data);
2207 /* create mapping for PHY interrupt */
2208 irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);
2210 irq_domain_remove(irqdomain);
2219 dev->domain_data.irqdomain = irqdomain;
2220 dev->domain_data.phyirq = irqmap;
2225 static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
2227 if (dev->domain_data.phyirq > 0) {
2228 irq_dispose_mapping(dev->domain_data.phyirq);
2230 if (dev->domain_data.irqdomain)
2231 irq_domain_remove(dev->domain_data.irqdomain);
2233 dev->domain_data.phyirq = 0;
2234 dev->domain_data.irqdomain = NULL;
2237 static int lan8835_fixup(struct phy_device *phydev)
2240 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2242 /* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */
2243 buf = phy_read_mmd(phydev, MDIO_MMD_PCS, 0x8010);
2246 phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf);
2248 /* RGMII MAC TXC Delay Enable */
2249 lan78xx_write_reg(dev, MAC_RGMII_ID,
2250 MAC_RGMII_ID_TXC_DELAY_EN_);
2252 /* RGMII TX DLL Tune Adjust */
2253 lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2255 dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
2260 static int ksz9031rnx_fixup(struct phy_device *phydev)
2262 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2264 /* Micrel9301RNX PHY configuration */
2265 /* RGMII Control Signal Pad Skew */
2266 phy_write_mmd(phydev, MDIO_MMD_WIS, 4, 0x0077);
2267 /* RGMII RX Data Pad Skew */
2268 phy_write_mmd(phydev, MDIO_MMD_WIS, 5, 0x7777);
2269 /* RGMII RX Clock Pad Skew */
2270 phy_write_mmd(phydev, MDIO_MMD_WIS, 8, 0x1FF);
2272 dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;
2277 static struct phy_device *lan7801_phy_init(struct lan78xx_net *dev)
2281 struct fixed_phy_status fphy_status = {
2283 .speed = SPEED_1000,
2284 .duplex = DUPLEX_FULL,
2286 struct phy_device *phydev;
2288 phydev = phy_find_first(dev->mdiobus);
2290 netdev_dbg(dev->net, "PHY Not Found!! Registering Fixed PHY\n");
2291 phydev = fixed_phy_register(PHY_POLL, &fphy_status, NULL);
2292 if (IS_ERR(phydev)) {
2293 netdev_err(dev->net, "No PHY/fixed_PHY found\n");
2296 netdev_dbg(dev->net, "Registered FIXED PHY\n");
2297 dev->interface = PHY_INTERFACE_MODE_RGMII;
2298 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
2299 MAC_RGMII_ID_TXC_DELAY_EN_);
2300 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2301 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2302 buf |= HW_CFG_CLK125_EN_;
2303 buf |= HW_CFG_REFCLK25_EN_;
2304 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2307 netdev_err(dev->net, "no PHY driver found\n");
2310 dev->interface = PHY_INTERFACE_MODE_RGMII;
2311 /* external PHY fixup for KSZ9031RNX */
2312 ret = phy_register_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0,
2315 netdev_err(dev->net, "Failed to register fixup for PHY_KSZ9031RNX\n");
2318 /* external PHY fixup for LAN8835 */
2319 ret = phy_register_fixup_for_uid(PHY_LAN8835, 0xfffffff0,
2322 netdev_err(dev->net, "Failed to register fixup for PHY_LAN8835\n");
2325 /* add more external PHY fixup here if needed */
2327 phydev->is_internal = false;
2332 static int lan78xx_phy_init(struct lan78xx_net *dev)
2334 __ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
2337 struct phy_device *phydev;
2339 switch (dev->chipid) {
2340 case ID_REV_CHIP_ID_7801_:
2341 phydev = lan7801_phy_init(dev);
2343 netdev_err(dev->net, "lan7801: PHY Init Failed");
2348 case ID_REV_CHIP_ID_7800_:
2349 case ID_REV_CHIP_ID_7850_:
2350 phydev = phy_find_first(dev->mdiobus);
2352 netdev_err(dev->net, "no PHY found\n");
2355 phydev->is_internal = true;
2356 dev->interface = PHY_INTERFACE_MODE_GMII;
2360 netdev_err(dev->net, "Unknown CHIP ID found\n");
2364 /* if phyirq is not set, use polling mode in phylib */
2365 if (dev->domain_data.phyirq > 0)
2366 phydev->irq = dev->domain_data.phyirq;
2368 phydev->irq = PHY_POLL;
2369 netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2371 /* set to AUTOMDIX */
2372 phydev->mdix = ETH_TP_MDI_AUTO;
2374 ret = phy_connect_direct(dev->net, phydev,
2375 lan78xx_link_status_change,
2378 netdev_err(dev->net, "can't attach PHY to %s\n",
2380 if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2381 if (phy_is_pseudo_fixed_link(phydev)) {
2382 fixed_phy_unregister(phydev);
2384 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX,
2386 phy_unregister_fixup_for_uid(PHY_LAN8835,
2393 /* MAC doesn't support 1000T Half */
2394 phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
2396 /* support both flow controls */
2397 dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2398 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2399 phydev->advertising);
2400 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2401 phydev->advertising);
2402 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2403 mii_adv_to_linkmode_adv_t(fc, mii_adv);
2404 linkmode_or(phydev->advertising, fc, phydev->advertising);
2406 phy_support_eee(phydev);
2408 if (phydev->mdio.dev.of_node) {
2412 len = of_property_count_elems_of_size(phydev->mdio.dev.of_node,
2413 "microchip,led-modes",
2416 /* Ensure the appropriate LEDs are enabled */
2417 lan78xx_read_reg(dev, HW_CFG, ®);
2418 reg &= ~(HW_CFG_LED0_EN_ |
2422 reg |= (len > 0) * HW_CFG_LED0_EN_ |
2423 (len > 1) * HW_CFG_LED1_EN_ |
2424 (len > 2) * HW_CFG_LED2_EN_ |
2425 (len > 3) * HW_CFG_LED3_EN_;
2426 lan78xx_write_reg(dev, HW_CFG, reg);
2430 genphy_config_aneg(phydev);
2432 dev->fc_autoneg = phydev->autoneg;
2437 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2442 lan78xx_read_reg(dev, MAC_RX, &buf);
2444 rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2447 buf &= ~MAC_RX_RXEN_;
2448 lan78xx_write_reg(dev, MAC_RX, buf);
2451 /* add 4 to size for FCS */
2452 buf &= ~MAC_RX_MAX_SIZE_MASK_;
2453 buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2455 lan78xx_write_reg(dev, MAC_RX, buf);
2458 buf |= MAC_RX_RXEN_;
2459 lan78xx_write_reg(dev, MAC_RX, buf);
2465 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2467 struct sk_buff *skb;
2468 unsigned long flags;
2471 spin_lock_irqsave(&q->lock, flags);
2472 while (!skb_queue_empty(q)) {
2473 struct skb_data *entry;
2477 skb_queue_walk(q, skb) {
2478 entry = (struct skb_data *)skb->cb;
2479 if (entry->state != unlink_start)
2484 entry->state = unlink_start;
2487 /* Get reference count of the URB to avoid it to be
2488 * freed during usb_unlink_urb, which may trigger
2489 * use-after-free problem inside usb_unlink_urb since
2490 * usb_unlink_urb is always racing with .complete
2491 * handler(include defer_bh).
2494 spin_unlock_irqrestore(&q->lock, flags);
2495 /* during some PM-driven resume scenarios,
2496 * these (async) unlinks complete immediately
2498 ret = usb_unlink_urb(urb);
2499 if (ret != -EINPROGRESS && ret != 0)
2500 netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2504 spin_lock_irqsave(&q->lock, flags);
2506 spin_unlock_irqrestore(&q->lock, flags);
2510 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2512 struct lan78xx_net *dev = netdev_priv(netdev);
2513 int max_frame_len = RX_MAX_FRAME_LEN(new_mtu);
2516 /* no second zero-length packet read wanted after mtu-sized packets */
2517 if ((max_frame_len % dev->maxpacket) == 0)
2520 ret = usb_autopm_get_interface(dev->intf);
2524 ret = lan78xx_set_rx_max_frame_length(dev, max_frame_len);
2526 WRITE_ONCE(netdev->mtu, new_mtu);
2528 usb_autopm_put_interface(dev->intf);
2533 static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2535 struct lan78xx_net *dev = netdev_priv(netdev);
2536 struct sockaddr *addr = p;
2537 u32 addr_lo, addr_hi;
2539 if (netif_running(netdev))
2542 if (!is_valid_ether_addr(addr->sa_data))
2543 return -EADDRNOTAVAIL;
2545 eth_hw_addr_set(netdev, addr->sa_data);
2547 addr_lo = netdev->dev_addr[0] |
2548 netdev->dev_addr[1] << 8 |
2549 netdev->dev_addr[2] << 16 |
2550 netdev->dev_addr[3] << 24;
2551 addr_hi = netdev->dev_addr[4] |
2552 netdev->dev_addr[5] << 8;
2554 lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2555 lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2557 /* Added to support MAC address changes */
2558 lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2559 lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2564 /* Enable or disable Rx checksum offload engine */
2565 static int lan78xx_set_features(struct net_device *netdev,
2566 netdev_features_t features)
2568 struct lan78xx_net *dev = netdev_priv(netdev);
2569 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2570 unsigned long flags;
2572 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2574 if (features & NETIF_F_RXCSUM) {
2575 pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
2576 pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
2578 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2579 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2582 if (features & NETIF_F_HW_VLAN_CTAG_RX)
2583 pdata->rfe_ctl |= RFE_CTL_VLAN_STRIP_;
2585 pdata->rfe_ctl &= ~RFE_CTL_VLAN_STRIP_;
2587 if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
2588 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2590 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2592 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2594 lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2599 static void lan78xx_deferred_vlan_write(struct work_struct *param)
2601 struct lan78xx_priv *pdata =
2602 container_of(param, struct lan78xx_priv, set_vlan);
2603 struct lan78xx_net *dev = pdata->dev;
2605 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2606 DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2609 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2610 __be16 proto, u16 vid)
2612 struct lan78xx_net *dev = netdev_priv(netdev);
2613 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2615 u16 vid_dword_index;
2617 vid_dword_index = (vid >> 5) & 0x7F;
2618 vid_bit_index = vid & 0x1F;
2620 pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2622 /* defer register writes to a sleepable context */
2623 schedule_work(&pdata->set_vlan);
2628 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2629 __be16 proto, u16 vid)
2631 struct lan78xx_net *dev = netdev_priv(netdev);
2632 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2634 u16 vid_dword_index;
2636 vid_dword_index = (vid >> 5) & 0x7F;
2637 vid_bit_index = vid & 0x1F;
2639 pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2641 /* defer register writes to a sleepable context */
2642 schedule_work(&pdata->set_vlan);
2647 static void lan78xx_init_ltm(struct lan78xx_net *dev)
2651 u32 regs[6] = { 0 };
2653 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2654 if (buf & USB_CFG1_LTM_ENABLE_) {
2656 /* Get values from EEPROM first */
2657 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2658 if (temp[0] == 24) {
2659 ret = lan78xx_read_raw_eeprom(dev,
2666 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2667 if (temp[0] == 24) {
2668 ret = lan78xx_read_raw_otp(dev,
2678 lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2679 lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2680 lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2681 lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2682 lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2683 lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2686 static int lan78xx_urb_config_init(struct lan78xx_net *dev)
2690 switch (dev->udev->speed) {
2691 case USB_SPEED_SUPER:
2692 dev->rx_urb_size = RX_SS_URB_SIZE;
2693 dev->tx_urb_size = TX_SS_URB_SIZE;
2694 dev->n_rx_urbs = RX_SS_URB_NUM;
2695 dev->n_tx_urbs = TX_SS_URB_NUM;
2696 dev->bulk_in_delay = SS_BULK_IN_DELAY;
2697 dev->burst_cap = SS_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2699 case USB_SPEED_HIGH:
2700 dev->rx_urb_size = RX_HS_URB_SIZE;
2701 dev->tx_urb_size = TX_HS_URB_SIZE;
2702 dev->n_rx_urbs = RX_HS_URB_NUM;
2703 dev->n_tx_urbs = TX_HS_URB_NUM;
2704 dev->bulk_in_delay = HS_BULK_IN_DELAY;
2705 dev->burst_cap = HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2707 case USB_SPEED_FULL:
2708 dev->rx_urb_size = RX_FS_URB_SIZE;
2709 dev->tx_urb_size = TX_FS_URB_SIZE;
2710 dev->n_rx_urbs = RX_FS_URB_NUM;
2711 dev->n_tx_urbs = TX_FS_URB_NUM;
2712 dev->bulk_in_delay = FS_BULK_IN_DELAY;
2713 dev->burst_cap = FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2716 netdev_warn(dev->net, "USB bus speed not supported\n");
2724 static int lan78xx_start_hw(struct lan78xx_net *dev, u32 reg, u32 hw_enable)
2726 return lan78xx_update_reg(dev, reg, hw_enable, hw_enable);
2729 static int lan78xx_stop_hw(struct lan78xx_net *dev, u32 reg, u32 hw_enabled,
2732 unsigned long timeout;
2733 bool stopped = true;
2737 /* Stop the h/w block (if not already stopped) */
2739 ret = lan78xx_read_reg(dev, reg, &buf);
2743 if (buf & hw_enabled) {
2746 ret = lan78xx_write_reg(dev, reg, buf);
2751 timeout = jiffies + HW_DISABLE_TIMEOUT;
2753 ret = lan78xx_read_reg(dev, reg, &buf);
2757 if (buf & hw_disabled)
2760 msleep(HW_DISABLE_DELAY_MS);
2761 } while (!stopped && !time_after(jiffies, timeout));
2764 ret = stopped ? 0 : -ETIME;
2769 static int lan78xx_flush_fifo(struct lan78xx_net *dev, u32 reg, u32 fifo_flush)
2771 return lan78xx_update_reg(dev, reg, fifo_flush, fifo_flush);
2774 static int lan78xx_start_tx_path(struct lan78xx_net *dev)
2778 netif_dbg(dev, drv, dev->net, "start tx path");
2780 /* Start the MAC transmitter */
2782 ret = lan78xx_start_hw(dev, MAC_TX, MAC_TX_TXEN_);
2786 /* Start the Tx FIFO */
2788 ret = lan78xx_start_hw(dev, FCT_TX_CTL, FCT_TX_CTL_EN_);
2795 static int lan78xx_stop_tx_path(struct lan78xx_net *dev)
2799 netif_dbg(dev, drv, dev->net, "stop tx path");
2801 /* Stop the Tx FIFO */
2803 ret = lan78xx_stop_hw(dev, FCT_TX_CTL, FCT_TX_CTL_EN_, FCT_TX_CTL_DIS_);
2807 /* Stop the MAC transmitter */
2809 ret = lan78xx_stop_hw(dev, MAC_TX, MAC_TX_TXEN_, MAC_TX_TXD_);
2816 /* The caller must ensure the Tx path is stopped before calling
2817 * lan78xx_flush_tx_fifo().
2819 static int lan78xx_flush_tx_fifo(struct lan78xx_net *dev)
2821 return lan78xx_flush_fifo(dev, FCT_TX_CTL, FCT_TX_CTL_RST_);
2824 static int lan78xx_start_rx_path(struct lan78xx_net *dev)
2828 netif_dbg(dev, drv, dev->net, "start rx path");
2830 /* Start the Rx FIFO */
2832 ret = lan78xx_start_hw(dev, FCT_RX_CTL, FCT_RX_CTL_EN_);
2836 /* Start the MAC receiver*/
2838 ret = lan78xx_start_hw(dev, MAC_RX, MAC_RX_RXEN_);
2845 static int lan78xx_stop_rx_path(struct lan78xx_net *dev)
2849 netif_dbg(dev, drv, dev->net, "stop rx path");
2851 /* Stop the MAC receiver */
2853 ret = lan78xx_stop_hw(dev, MAC_RX, MAC_RX_RXEN_, MAC_RX_RXD_);
2857 /* Stop the Rx FIFO */
2859 ret = lan78xx_stop_hw(dev, FCT_RX_CTL, FCT_RX_CTL_EN_, FCT_RX_CTL_DIS_);
2866 /* The caller must ensure the Rx path is stopped before calling
2867 * lan78xx_flush_rx_fifo().
2869 static int lan78xx_flush_rx_fifo(struct lan78xx_net *dev)
2871 return lan78xx_flush_fifo(dev, FCT_RX_CTL, FCT_RX_CTL_RST_);
2874 static int lan78xx_reset(struct lan78xx_net *dev)
2876 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2877 unsigned long timeout;
2882 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2886 buf |= HW_CFG_LRST_;
2888 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2892 timeout = jiffies + HZ;
2895 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2899 if (time_after(jiffies, timeout)) {
2900 netdev_warn(dev->net,
2901 "timeout on completion of LiteReset");
2905 } while (buf & HW_CFG_LRST_);
2907 lan78xx_init_mac_address(dev);
2909 /* save DEVID for later usage */
2910 ret = lan78xx_read_reg(dev, ID_REV, &buf);
2914 dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2915 dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2917 /* Respond to the IN token with a NAK */
2918 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2922 buf |= USB_CFG_BIR_;
2924 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2929 lan78xx_init_ltm(dev);
2931 ret = lan78xx_write_reg(dev, BURST_CAP, dev->burst_cap);
2935 ret = lan78xx_write_reg(dev, BULK_IN_DLY, dev->bulk_in_delay);
2939 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2944 buf |= HW_CFG_CLK125_EN_;
2945 buf |= HW_CFG_REFCLK25_EN_;
2947 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2951 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2955 buf |= USB_CFG_BCE_;
2957 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2961 /* set FIFO sizes */
2962 buf = (MAX_RX_FIFO_SIZE - 512) / 512;
2964 ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2968 buf = (MAX_TX_FIFO_SIZE - 512) / 512;
2970 ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2974 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2978 ret = lan78xx_write_reg(dev, FLOW, 0);
2982 ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2986 /* Don't need rfe_ctl_lock during initialisation */
2987 ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2991 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
2993 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2997 /* Enable or disable checksum offload engines */
2998 ret = lan78xx_set_features(dev->net, dev->net->features);
3002 lan78xx_set_multicast(dev->net);
3005 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3009 buf |= PMT_CTL_PHY_RST_;
3011 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3015 timeout = jiffies + HZ;
3018 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3022 if (time_after(jiffies, timeout)) {
3023 netdev_warn(dev->net, "timeout waiting for PHY Reset");
3027 } while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
3029 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
3033 /* LAN7801 only has RGMII mode */
3034 if (dev->chipid == ID_REV_CHIP_ID_7801_) {
3035 buf &= ~MAC_CR_GMII_EN_;
3036 /* Enable Auto Duplex and Auto speed */
3037 buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
3040 if (dev->chipid == ID_REV_CHIP_ID_7800_ ||
3041 dev->chipid == ID_REV_CHIP_ID_7850_) {
3042 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
3043 if (!ret && sig != EEPROM_INDICATOR) {
3044 /* Implies there is no external eeprom. Set mac speed */
3045 netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");
3046 buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
3049 ret = lan78xx_write_reg(dev, MAC_CR, buf);
3053 ret = lan78xx_set_rx_max_frame_length(dev,
3054 RX_MAX_FRAME_LEN(dev->net->mtu));
3059 static void lan78xx_init_stats(struct lan78xx_net *dev)
3064 /* initialize for stats update
3065 * some counters are 20bits and some are 32bits
3067 p = (u32 *)&dev->stats.rollover_max;
3068 for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
3071 dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
3072 dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
3073 dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
3074 dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
3075 dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
3076 dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
3077 dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
3078 dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
3079 dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
3080 dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
3082 set_bit(EVENT_STAT_UPDATE, &dev->flags);
3085 static int lan78xx_open(struct net_device *net)
3087 struct lan78xx_net *dev = netdev_priv(net);
3090 netif_dbg(dev, ifup, dev->net, "open device");
3092 ret = usb_autopm_get_interface(dev->intf);
3096 mutex_lock(&dev->dev_mutex);
3098 phy_start(net->phydev);
3100 netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
3102 /* for Link Check */
3103 if (dev->urb_intr) {
3104 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
3106 netif_err(dev, ifup, dev->net,
3107 "intr submit %d\n", ret);
3112 ret = lan78xx_flush_rx_fifo(dev);
3115 ret = lan78xx_flush_tx_fifo(dev);
3119 ret = lan78xx_start_tx_path(dev);
3122 ret = lan78xx_start_rx_path(dev);
3126 lan78xx_init_stats(dev);
3128 set_bit(EVENT_DEV_OPEN, &dev->flags);
3130 netif_start_queue(net);
3132 dev->link_on = false;
3134 napi_enable(&dev->napi);
3136 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
3138 mutex_unlock(&dev->dev_mutex);
3141 usb_autopm_put_interface(dev->intf);
3146 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
3148 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
3149 DECLARE_WAITQUEUE(wait, current);
3152 /* ensure there are no more active urbs */
3153 add_wait_queue(&unlink_wakeup, &wait);
3154 set_current_state(TASK_UNINTERRUPTIBLE);
3155 dev->wait = &unlink_wakeup;
3156 temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
3158 /* maybe wait for deletions to finish. */
3159 while (!skb_queue_empty(&dev->rxq) ||
3160 !skb_queue_empty(&dev->txq)) {
3161 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
3162 set_current_state(TASK_UNINTERRUPTIBLE);
3163 netif_dbg(dev, ifdown, dev->net,
3164 "waited for %d urb completions", temp);
3166 set_current_state(TASK_RUNNING);
3168 remove_wait_queue(&unlink_wakeup, &wait);
3170 /* empty Rx done, Rx overflow and Tx pend queues
3172 while (!skb_queue_empty(&dev->rxq_done)) {
3173 struct sk_buff *skb = skb_dequeue(&dev->rxq_done);
3175 lan78xx_release_rx_buf(dev, skb);
3178 skb_queue_purge(&dev->rxq_overflow);
3179 skb_queue_purge(&dev->txq_pend);
3182 static int lan78xx_stop(struct net_device *net)
3184 struct lan78xx_net *dev = netdev_priv(net);
3186 netif_dbg(dev, ifup, dev->net, "stop device");
3188 mutex_lock(&dev->dev_mutex);
3190 if (timer_pending(&dev->stat_monitor))
3191 del_timer_sync(&dev->stat_monitor);
3193 clear_bit(EVENT_DEV_OPEN, &dev->flags);
3194 netif_stop_queue(net);
3195 napi_disable(&dev->napi);
3197 lan78xx_terminate_urbs(dev);
3199 netif_info(dev, ifdown, dev->net,
3200 "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
3201 net->stats.rx_packets, net->stats.tx_packets,
3202 net->stats.rx_errors, net->stats.tx_errors);
3204 /* ignore errors that occur stopping the Tx and Rx data paths */
3205 lan78xx_stop_tx_path(dev);
3206 lan78xx_stop_rx_path(dev);
3209 phy_stop(net->phydev);
3211 usb_kill_urb(dev->urb_intr);
3213 /* deferred work (task, timer, softirq) must also stop.
3214 * can't flush_scheduled_work() until we drop rtnl (later),
3215 * else workers could deadlock; so make workers a NOP.
3217 clear_bit(EVENT_TX_HALT, &dev->flags);
3218 clear_bit(EVENT_RX_HALT, &dev->flags);
3219 clear_bit(EVENT_LINK_RESET, &dev->flags);
3220 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3222 cancel_delayed_work_sync(&dev->wq);
3224 usb_autopm_put_interface(dev->intf);
3226 mutex_unlock(&dev->dev_mutex);
3231 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
3232 struct sk_buff_head *list, enum skb_state state)
3234 unsigned long flags;
3235 enum skb_state old_state;
3236 struct skb_data *entry = (struct skb_data *)skb->cb;
3238 spin_lock_irqsave(&list->lock, flags);
3239 old_state = entry->state;
3240 entry->state = state;
3242 __skb_unlink(skb, list);
3243 spin_unlock(&list->lock);
3244 spin_lock(&dev->rxq_done.lock);
3246 __skb_queue_tail(&dev->rxq_done, skb);
3247 if (skb_queue_len(&dev->rxq_done) == 1)
3248 napi_schedule(&dev->napi);
3250 spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
3255 static void tx_complete(struct urb *urb)
3257 struct sk_buff *skb = (struct sk_buff *)urb->context;
3258 struct skb_data *entry = (struct skb_data *)skb->cb;
3259 struct lan78xx_net *dev = entry->dev;
3261 if (urb->status == 0) {
3262 dev->net->stats.tx_packets += entry->num_of_packet;
3263 dev->net->stats.tx_bytes += entry->length;
3265 dev->net->stats.tx_errors += entry->num_of_packet;
3267 switch (urb->status) {
3269 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3272 /* software-driven interface shutdown */
3275 netif_dbg(dev, tx_err, dev->net,
3276 "tx err interface gone %d\n",
3277 entry->urb->status);
3283 netif_stop_queue(dev->net);
3284 netif_dbg(dev, tx_err, dev->net,
3285 "tx err queue stopped %d\n",
3286 entry->urb->status);
3289 netif_dbg(dev, tx_err, dev->net,
3290 "unknown tx err %d\n",
3291 entry->urb->status);
3296 usb_autopm_put_interface_async(dev->intf);
3298 skb_unlink(skb, &dev->txq);
3300 lan78xx_release_tx_buf(dev, skb);
3302 /* Re-schedule NAPI if Tx data pending but no URBs in progress.
3304 if (skb_queue_empty(&dev->txq) &&
3305 !skb_queue_empty(&dev->txq_pend))
3306 napi_schedule(&dev->napi);
3309 static void lan78xx_queue_skb(struct sk_buff_head *list,
3310 struct sk_buff *newsk, enum skb_state state)
3312 struct skb_data *entry = (struct skb_data *)newsk->cb;
3314 __skb_queue_tail(list, newsk);
3315 entry->state = state;
3318 static unsigned int lan78xx_tx_urb_space(struct lan78xx_net *dev)
3320 return skb_queue_len(&dev->txq_free) * dev->tx_urb_size;
3323 static unsigned int lan78xx_tx_pend_data_len(struct lan78xx_net *dev)
3325 return dev->tx_pend_data_len;
3328 static void lan78xx_tx_pend_skb_add(struct lan78xx_net *dev,
3329 struct sk_buff *skb,
3330 unsigned int *tx_pend_data_len)
3332 unsigned long flags;
3334 spin_lock_irqsave(&dev->txq_pend.lock, flags);
3336 __skb_queue_tail(&dev->txq_pend, skb);
3338 dev->tx_pend_data_len += skb->len;
3339 *tx_pend_data_len = dev->tx_pend_data_len;
3341 spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3344 static void lan78xx_tx_pend_skb_head_add(struct lan78xx_net *dev,
3345 struct sk_buff *skb,
3346 unsigned int *tx_pend_data_len)
3348 unsigned long flags;
3350 spin_lock_irqsave(&dev->txq_pend.lock, flags);
3352 __skb_queue_head(&dev->txq_pend, skb);
3354 dev->tx_pend_data_len += skb->len;
3355 *tx_pend_data_len = dev->tx_pend_data_len;
3357 spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3360 static void lan78xx_tx_pend_skb_get(struct lan78xx_net *dev,
3361 struct sk_buff **skb,
3362 unsigned int *tx_pend_data_len)
3364 unsigned long flags;
3366 spin_lock_irqsave(&dev->txq_pend.lock, flags);
3368 *skb = __skb_dequeue(&dev->txq_pend);
3370 dev->tx_pend_data_len -= (*skb)->len;
3371 *tx_pend_data_len = dev->tx_pend_data_len;
3373 spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3377 lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
3379 struct lan78xx_net *dev = netdev_priv(net);
3380 unsigned int tx_pend_data_len;
3382 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags))
3383 schedule_delayed_work(&dev->wq, 0);
3385 skb_tx_timestamp(skb);
3387 lan78xx_tx_pend_skb_add(dev, skb, &tx_pend_data_len);
3389 /* Set up a Tx URB if none is in progress */
3391 if (skb_queue_empty(&dev->txq))
3392 napi_schedule(&dev->napi);
3394 /* Stop stack Tx queue if we have enough data to fill
3395 * all the free Tx URBs.
3397 if (tx_pend_data_len > lan78xx_tx_urb_space(dev)) {
3398 netif_stop_queue(net);
3400 netif_dbg(dev, hw, dev->net, "tx data len: %u, urb space %u",
3401 tx_pend_data_len, lan78xx_tx_urb_space(dev));
3403 /* Kick off transmission of pending data */
3405 if (!skb_queue_empty(&dev->txq_free))
3406 napi_schedule(&dev->napi);
3409 return NETDEV_TX_OK;
3412 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
3414 struct lan78xx_priv *pdata = NULL;
3418 dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
3420 pdata = (struct lan78xx_priv *)(dev->data[0]);
3422 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
3428 spin_lock_init(&pdata->rfe_ctl_lock);
3429 mutex_init(&pdata->dataport_mutex);
3431 INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
3433 for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
3434 pdata->vlan_table[i] = 0;
3436 INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
3438 dev->net->features = 0;
3440 if (DEFAULT_TX_CSUM_ENABLE)
3441 dev->net->features |= NETIF_F_HW_CSUM;
3443 if (DEFAULT_RX_CSUM_ENABLE)
3444 dev->net->features |= NETIF_F_RXCSUM;
3446 if (DEFAULT_TSO_CSUM_ENABLE)
3447 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
3449 if (DEFAULT_VLAN_RX_OFFLOAD)
3450 dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX;
3452 if (DEFAULT_VLAN_FILTER_ENABLE)
3453 dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
3455 dev->net->hw_features = dev->net->features;
3457 ret = lan78xx_setup_irq_domain(dev);
3459 netdev_warn(dev->net,
3460 "lan78xx_setup_irq_domain() failed : %d", ret);
3464 /* Init all registers */
3465 ret = lan78xx_reset(dev);
3467 netdev_warn(dev->net, "Registers INIT FAILED....");
3471 ret = lan78xx_mdio_init(dev);
3473 netdev_warn(dev->net, "MDIO INIT FAILED.....");
3477 dev->net->flags |= IFF_MULTICAST;
3479 pdata->wol = WAKE_MAGIC;
3484 lan78xx_remove_irq_domain(dev);
3487 netdev_warn(dev->net, "Bind routine FAILED");
3488 cancel_work_sync(&pdata->set_multicast);
3489 cancel_work_sync(&pdata->set_vlan);
3494 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
3496 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3498 lan78xx_remove_irq_domain(dev);
3500 lan78xx_remove_mdio(dev);
3503 cancel_work_sync(&pdata->set_multicast);
3504 cancel_work_sync(&pdata->set_vlan);
3505 netif_dbg(dev, ifdown, dev->net, "free pdata");
3512 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
3513 struct sk_buff *skb,
3514 u32 rx_cmd_a, u32 rx_cmd_b)
3516 /* HW Checksum offload appears to be flawed if used when not stripping
3517 * VLAN headers. Drop back to S/W checksums under these conditions.
3519 if (!(dev->net->features & NETIF_F_RXCSUM) ||
3520 unlikely(rx_cmd_a & RX_CMD_A_ICSM_) ||
3521 ((rx_cmd_a & RX_CMD_A_FVTG_) &&
3522 !(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) {
3523 skb->ip_summed = CHECKSUM_NONE;
3525 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
3526 skb->ip_summed = CHECKSUM_COMPLETE;
3530 static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev,
3531 struct sk_buff *skb,
3532 u32 rx_cmd_a, u32 rx_cmd_b)
3534 if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) &&
3535 (rx_cmd_a & RX_CMD_A_FVTG_))
3536 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
3537 (rx_cmd_b & 0xffff));
3540 static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
3542 dev->net->stats.rx_packets++;
3543 dev->net->stats.rx_bytes += skb->len;
3545 skb->protocol = eth_type_trans(skb, dev->net);
3547 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
3548 skb->len + sizeof(struct ethhdr), skb->protocol);
3549 memset(skb->cb, 0, sizeof(struct skb_data));
3551 if (skb_defer_rx_timestamp(skb))
3554 napi_gro_receive(&dev->napi, skb);
3557 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb,
3558 int budget, int *work_done)
3560 if (skb->len < RX_SKB_MIN_LEN)
3563 /* Extract frames from the URB buffer and pass each one to
3564 * the stack in a new NAPI SKB.
3566 while (skb->len > 0) {
3567 u32 rx_cmd_a, rx_cmd_b, align_count, size;
3569 unsigned char *packet;
3571 rx_cmd_a = get_unaligned_le32(skb->data);
3572 skb_pull(skb, sizeof(rx_cmd_a));
3574 rx_cmd_b = get_unaligned_le32(skb->data);
3575 skb_pull(skb, sizeof(rx_cmd_b));
3577 rx_cmd_c = get_unaligned_le16(skb->data);
3578 skb_pull(skb, sizeof(rx_cmd_c));
3582 /* get the packet length */
3583 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
3584 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
3586 if (unlikely(size > skb->len)) {
3587 netif_dbg(dev, rx_err, dev->net,
3588 "size err rx_cmd_a=0x%08x\n",
3593 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
3594 netif_dbg(dev, rx_err, dev->net,
3595 "Error rx_cmd_a=0x%08x", rx_cmd_a);
3598 struct sk_buff *skb2;
3600 if (unlikely(size < ETH_FCS_LEN)) {
3601 netif_dbg(dev, rx_err, dev->net,
3602 "size err rx_cmd_a=0x%08x\n",
3607 frame_len = size - ETH_FCS_LEN;
3609 skb2 = napi_alloc_skb(&dev->napi, frame_len);
3613 memcpy(skb2->data, packet, frame_len);
3615 skb_put(skb2, frame_len);
3617 lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3618 lan78xx_rx_vlan_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3620 /* Processing of the URB buffer must complete once
3621 * it has started. If the NAPI work budget is exhausted
3622 * while frames remain they are added to the overflow
3623 * queue for delivery in the next NAPI polling cycle.
3625 if (*work_done < budget) {
3626 lan78xx_skb_return(dev, skb2);
3629 skb_queue_tail(&dev->rxq_overflow, skb2);
3633 skb_pull(skb, size);
3635 /* skip padding bytes before the next frame starts */
3637 skb_pull(skb, align_count);
3643 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb,
3644 int budget, int *work_done)
3646 if (!lan78xx_rx(dev, skb, budget, work_done)) {
3647 netif_dbg(dev, rx_err, dev->net, "drop\n");
3648 dev->net->stats.rx_errors++;
3652 static void rx_complete(struct urb *urb)
3654 struct sk_buff *skb = (struct sk_buff *)urb->context;
3655 struct skb_data *entry = (struct skb_data *)skb->cb;
3656 struct lan78xx_net *dev = entry->dev;
3657 int urb_status = urb->status;
3658 enum skb_state state;
3660 netif_dbg(dev, rx_status, dev->net,
3661 "rx done: status %d", urb->status);
3663 skb_put(skb, urb->actual_length);
3666 if (urb != entry->urb)
3667 netif_warn(dev, rx_err, dev->net, "URB pointer mismatch");
3669 switch (urb_status) {
3671 if (skb->len < RX_SKB_MIN_LEN) {
3673 dev->net->stats.rx_errors++;
3674 dev->net->stats.rx_length_errors++;
3675 netif_dbg(dev, rx_err, dev->net,
3676 "rx length %d\n", skb->len);
3678 usb_mark_last_busy(dev->udev);
3681 dev->net->stats.rx_errors++;
3682 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3684 case -ECONNRESET: /* async unlink */
3685 case -ESHUTDOWN: /* hardware gone */
3686 netif_dbg(dev, ifdown, dev->net,
3687 "rx shutdown, code %d\n", urb_status);
3693 dev->net->stats.rx_errors++;
3697 /* data overrun ... flush fifo? */
3699 dev->net->stats.rx_over_errors++;
3704 dev->net->stats.rx_errors++;
3705 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3709 state = defer_bh(dev, skb, &dev->rxq, state);
3712 static int rx_submit(struct lan78xx_net *dev, struct sk_buff *skb, gfp_t flags)
3714 struct skb_data *entry = (struct skb_data *)skb->cb;
3715 size_t size = dev->rx_urb_size;
3716 struct urb *urb = entry->urb;
3717 unsigned long lockflags;
3720 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3721 skb->data, size, rx_complete, skb);
3723 spin_lock_irqsave(&dev->rxq.lock, lockflags);
3725 if (netif_device_present(dev->net) &&
3726 netif_running(dev->net) &&
3727 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3728 !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3729 ret = usb_submit_urb(urb, flags);
3732 lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3735 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3739 netif_dbg(dev, ifdown, dev->net, "device gone\n");
3740 netif_device_detach(dev->net);
3744 napi_schedule(&dev->napi);
3747 netif_dbg(dev, rx_err, dev->net,
3748 "rx submit, %d\n", ret);
3749 napi_schedule(&dev->napi);
3753 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3756 spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3759 lan78xx_release_rx_buf(dev, skb);
3764 static void lan78xx_rx_urb_submit_all(struct lan78xx_net *dev)
3766 struct sk_buff *rx_buf;
3768 /* Ensure the maximum number of Rx URBs is submitted
3770 while ((rx_buf = lan78xx_get_rx_buf(dev)) != NULL) {
3771 if (rx_submit(dev, rx_buf, GFP_ATOMIC) != 0)
3776 static void lan78xx_rx_urb_resubmit(struct lan78xx_net *dev,
3777 struct sk_buff *rx_buf)
3779 /* reset SKB data pointers */
3781 rx_buf->data = rx_buf->head;
3782 skb_reset_tail_pointer(rx_buf);
3784 rx_buf->data_len = 0;
3786 rx_submit(dev, rx_buf, GFP_ATOMIC);
3789 static void lan78xx_fill_tx_cmd_words(struct sk_buff *skb, u8 *buffer)
3794 tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
3796 if (skb->ip_summed == CHECKSUM_PARTIAL)
3797 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
3800 if (skb_is_gso(skb)) {
3801 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
3803 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
3805 tx_cmd_a |= TX_CMD_A_LSO_;
3808 if (skb_vlan_tag_present(skb)) {
3809 tx_cmd_a |= TX_CMD_A_IVTG_;
3810 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
3813 put_unaligned_le32(tx_cmd_a, buffer);
3814 put_unaligned_le32(tx_cmd_b, buffer + 4);
3817 static struct skb_data *lan78xx_tx_buf_fill(struct lan78xx_net *dev,
3818 struct sk_buff *tx_buf)
3820 struct skb_data *entry = (struct skb_data *)tx_buf->cb;
3821 int remain = dev->tx_urb_size;
3822 u8 *tx_data = tx_buf->data;
3825 entry->num_of_packet = 0;
3828 /* Work through the pending SKBs and copy the data of each SKB into
3829 * the URB buffer if there room for all the SKB data.
3831 * There must be at least DST+SRC+TYPE in the SKB (with padding enabled)
3833 while (remain >= TX_SKB_MIN_LEN) {
3834 unsigned int pending_bytes;
3835 unsigned int align_bytes;
3836 struct sk_buff *skb;
3839 lan78xx_tx_pend_skb_get(dev, &skb, &pending_bytes);
3844 align_bytes = (TX_ALIGNMENT - (urb_len % TX_ALIGNMENT)) %
3846 len = align_bytes + TX_CMD_LEN + skb->len;
3848 lan78xx_tx_pend_skb_head_add(dev, skb, &pending_bytes);
3852 tx_data += align_bytes;
3854 lan78xx_fill_tx_cmd_words(skb, tx_data);
3855 tx_data += TX_CMD_LEN;
3858 if (skb_copy_bits(skb, 0, tx_data, len) < 0) {
3859 struct net_device_stats *stats = &dev->net->stats;
3861 stats->tx_dropped++;
3862 dev_kfree_skb_any(skb);
3863 tx_data -= TX_CMD_LEN;
3868 entry->length += len;
3869 entry->num_of_packet += skb_shinfo(skb)->gso_segs ?: 1;
3871 dev_kfree_skb_any(skb);
3873 urb_len = (u32)(tx_data - (u8 *)tx_buf->data);
3875 remain = dev->tx_urb_size - urb_len;
3878 skb_put(tx_buf, urb_len);
3883 static void lan78xx_tx_bh(struct lan78xx_net *dev)
3887 /* Start the stack Tx queue if it was stopped
3889 netif_tx_lock(dev->net);
3890 if (netif_queue_stopped(dev->net)) {
3891 if (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev))
3892 netif_wake_queue(dev->net);
3894 netif_tx_unlock(dev->net);
3896 /* Go through the Tx pending queue and set up URBs to transfer
3897 * the data to the device. Stop if no more pending data or URBs,
3898 * or if an error occurs when a URB is submitted.
3901 struct skb_data *entry;
3902 struct sk_buff *tx_buf;
3903 unsigned long flags;
3905 if (skb_queue_empty(&dev->txq_pend))
3908 tx_buf = lan78xx_get_tx_buf(dev);
3912 entry = lan78xx_tx_buf_fill(dev, tx_buf);
3914 spin_lock_irqsave(&dev->txq.lock, flags);
3915 ret = usb_autopm_get_interface_async(dev->intf);
3917 spin_unlock_irqrestore(&dev->txq.lock, flags);
3921 usb_fill_bulk_urb(entry->urb, dev->udev, dev->pipe_out,
3922 tx_buf->data, tx_buf->len, tx_complete,
3925 if (tx_buf->len % dev->maxpacket == 0) {
3926 /* send USB_ZERO_PACKET */
3927 entry->urb->transfer_flags |= URB_ZERO_PACKET;
3931 /* if device is asleep stop outgoing packet processing */
3932 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3933 usb_anchor_urb(entry->urb, &dev->deferred);
3934 netif_stop_queue(dev->net);
3935 spin_unlock_irqrestore(&dev->txq.lock, flags);
3936 netdev_dbg(dev->net,
3937 "Delaying transmission for resumption\n");
3941 ret = usb_submit_urb(entry->urb, GFP_ATOMIC);
3944 netif_trans_update(dev->net);
3945 lan78xx_queue_skb(&dev->txq, tx_buf, tx_start);
3948 netif_stop_queue(dev->net);
3949 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3950 usb_autopm_put_interface_async(dev->intf);
3954 netif_dbg(dev, tx_err, dev->net,
3955 "tx submit urb err %d (disconnected?)", ret);
3956 netif_device_detach(dev->net);
3959 usb_autopm_put_interface_async(dev->intf);
3960 netif_dbg(dev, tx_err, dev->net,
3961 "tx submit urb err %d\n", ret);
3965 spin_unlock_irqrestore(&dev->txq.lock, flags);
3968 netdev_warn(dev->net, "failed to tx urb %d\n", ret);
3970 dev->net->stats.tx_dropped += entry->num_of_packet;
3971 lan78xx_release_tx_buf(dev, tx_buf);
3976 static int lan78xx_bh(struct lan78xx_net *dev, int budget)
3978 struct sk_buff_head done;
3979 struct sk_buff *rx_buf;
3980 struct skb_data *entry;
3981 unsigned long flags;
3984 /* Pass frames received in the last NAPI cycle before
3985 * working on newly completed URBs.
3987 while (!skb_queue_empty(&dev->rxq_overflow)) {
3988 lan78xx_skb_return(dev, skb_dequeue(&dev->rxq_overflow));
3992 /* Take a snapshot of the done queue and move items to a
3993 * temporary queue. Rx URB completions will continue to add
3994 * to the done queue.
3996 __skb_queue_head_init(&done);
3998 spin_lock_irqsave(&dev->rxq_done.lock, flags);
3999 skb_queue_splice_init(&dev->rxq_done, &done);
4000 spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
4002 /* Extract receive frames from completed URBs and
4003 * pass them to the stack. Re-submit each completed URB.
4005 while ((work_done < budget) &&
4006 (rx_buf = __skb_dequeue(&done))) {
4007 entry = (struct skb_data *)(rx_buf->cb);
4008 switch (entry->state) {
4010 rx_process(dev, rx_buf, budget, &work_done);
4015 netdev_dbg(dev->net, "rx buf state %d\n",
4020 lan78xx_rx_urb_resubmit(dev, rx_buf);
4023 /* If budget was consumed before processing all the URBs put them
4024 * back on the front of the done queue. They will be first to be
4025 * processed in the next NAPI cycle.
4027 spin_lock_irqsave(&dev->rxq_done.lock, flags);
4028 skb_queue_splice(&done, &dev->rxq_done);
4029 spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
4031 if (netif_device_present(dev->net) && netif_running(dev->net)) {
4032 /* reset update timer delta */
4033 if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
4035 mod_timer(&dev->stat_monitor,
4036 jiffies + STAT_UPDATE_TIMER);
4039 /* Submit all free Rx URBs */
4041 if (!test_bit(EVENT_RX_HALT, &dev->flags))
4042 lan78xx_rx_urb_submit_all(dev);
4044 /* Submit new Tx URBs */
4052 static int lan78xx_poll(struct napi_struct *napi, int budget)
4054 struct lan78xx_net *dev = container_of(napi, struct lan78xx_net, napi);
4055 int result = budget;
4058 /* Don't do any work if the device is suspended */
4060 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
4061 napi_complete_done(napi, 0);
4065 /* Process completed URBs and submit new URBs */
4067 work_done = lan78xx_bh(dev, budget);
4069 if (work_done < budget) {
4070 napi_complete_done(napi, work_done);
4072 /* Start a new polling cycle if data was received or
4073 * data is waiting to be transmitted.
4075 if (!skb_queue_empty(&dev->rxq_done)) {
4076 napi_schedule(napi);
4077 } else if (netif_carrier_ok(dev->net)) {
4078 if (skb_queue_empty(&dev->txq) &&
4079 !skb_queue_empty(&dev->txq_pend)) {
4080 napi_schedule(napi);
4082 netif_tx_lock(dev->net);
4083 if (netif_queue_stopped(dev->net)) {
4084 netif_wake_queue(dev->net);
4085 napi_schedule(napi);
4087 netif_tx_unlock(dev->net);
4096 static void lan78xx_delayedwork(struct work_struct *work)
4099 struct lan78xx_net *dev;
4101 dev = container_of(work, struct lan78xx_net, wq.work);
4103 if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
4106 if (usb_autopm_get_interface(dev->intf) < 0)
4109 if (test_bit(EVENT_TX_HALT, &dev->flags)) {
4110 unlink_urbs(dev, &dev->txq);
4112 status = usb_clear_halt(dev->udev, dev->pipe_out);
4115 status != -ESHUTDOWN) {
4116 if (netif_msg_tx_err(dev))
4117 netdev_err(dev->net,
4118 "can't clear tx halt, status %d\n",
4121 clear_bit(EVENT_TX_HALT, &dev->flags);
4122 if (status != -ESHUTDOWN)
4123 netif_wake_queue(dev->net);
4127 if (test_bit(EVENT_RX_HALT, &dev->flags)) {
4128 unlink_urbs(dev, &dev->rxq);
4129 status = usb_clear_halt(dev->udev, dev->pipe_in);
4132 status != -ESHUTDOWN) {
4133 if (netif_msg_rx_err(dev))
4134 netdev_err(dev->net,
4135 "can't clear rx halt, status %d\n",
4138 clear_bit(EVENT_RX_HALT, &dev->flags);
4139 napi_schedule(&dev->napi);
4143 if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
4146 clear_bit(EVENT_LINK_RESET, &dev->flags);
4147 if (lan78xx_link_reset(dev) < 0) {
4148 netdev_info(dev->net, "link reset failed (%d)\n",
4153 if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
4154 lan78xx_update_stats(dev);
4156 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
4158 mod_timer(&dev->stat_monitor,
4159 jiffies + (STAT_UPDATE_TIMER * dev->delta));
4161 dev->delta = min((dev->delta * 2), 50);
4164 usb_autopm_put_interface(dev->intf);
4167 static void intr_complete(struct urb *urb)
4169 struct lan78xx_net *dev = urb->context;
4170 int status = urb->status;
4175 lan78xx_status(dev, urb);
4178 /* software-driven interface shutdown */
4179 case -ENOENT: /* urb killed */
4180 case -ENODEV: /* hardware gone */
4181 case -ESHUTDOWN: /* hardware gone */
4182 netif_dbg(dev, ifdown, dev->net,
4183 "intr shutdown, code %d\n", status);
4186 /* NOTE: not throttling like RX/TX, since this endpoint
4187 * already polls infrequently
4190 netdev_dbg(dev->net, "intr status %d\n", status);
4194 if (!netif_device_present(dev->net) ||
4195 !netif_running(dev->net)) {
4196 netdev_warn(dev->net, "not submitting new status URB");
4200 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
4201 status = usb_submit_urb(urb, GFP_ATOMIC);
4208 netif_dbg(dev, timer, dev->net,
4209 "intr resubmit %d (disconnect?)", status);
4210 netif_device_detach(dev->net);
4213 netif_err(dev, timer, dev->net,
4214 "intr resubmit --> %d\n", status);
4219 static void lan78xx_disconnect(struct usb_interface *intf)
4221 struct lan78xx_net *dev;
4222 struct usb_device *udev;
4223 struct net_device *net;
4224 struct phy_device *phydev;
4226 dev = usb_get_intfdata(intf);
4227 usb_set_intfdata(intf, NULL);
4231 netif_napi_del(&dev->napi);
4233 udev = interface_to_usbdev(intf);
4236 unregister_netdev(net);
4238 timer_shutdown_sync(&dev->stat_monitor);
4239 set_bit(EVENT_DEV_DISCONNECT, &dev->flags);
4240 cancel_delayed_work_sync(&dev->wq);
4242 phydev = net->phydev;
4244 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
4245 phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
4247 phy_disconnect(net->phydev);
4249 if (phy_is_pseudo_fixed_link(phydev))
4250 fixed_phy_unregister(phydev);
4252 usb_scuttle_anchored_urbs(&dev->deferred);
4254 lan78xx_unbind(dev, intf);
4256 lan78xx_free_tx_resources(dev);
4257 lan78xx_free_rx_resources(dev);
4259 usb_kill_urb(dev->urb_intr);
4260 usb_free_urb(dev->urb_intr);
4266 static void lan78xx_tx_timeout(struct net_device *net, unsigned int txqueue)
4268 struct lan78xx_net *dev = netdev_priv(net);
4270 unlink_urbs(dev, &dev->txq);
4271 napi_schedule(&dev->napi);
4274 static netdev_features_t lan78xx_features_check(struct sk_buff *skb,
4275 struct net_device *netdev,
4276 netdev_features_t features)
4278 struct lan78xx_net *dev = netdev_priv(netdev);
4280 if (skb->len > LAN78XX_TSO_SIZE(dev))
4281 features &= ~NETIF_F_GSO_MASK;
4283 features = vlan_features_check(skb, features);
4284 features = vxlan_features_check(skb, features);
4289 static const struct net_device_ops lan78xx_netdev_ops = {
4290 .ndo_open = lan78xx_open,
4291 .ndo_stop = lan78xx_stop,
4292 .ndo_start_xmit = lan78xx_start_xmit,
4293 .ndo_tx_timeout = lan78xx_tx_timeout,
4294 .ndo_change_mtu = lan78xx_change_mtu,
4295 .ndo_set_mac_address = lan78xx_set_mac_addr,
4296 .ndo_validate_addr = eth_validate_addr,
4297 .ndo_eth_ioctl = phy_do_ioctl_running,
4298 .ndo_set_rx_mode = lan78xx_set_multicast,
4299 .ndo_set_features = lan78xx_set_features,
4300 .ndo_vlan_rx_add_vid = lan78xx_vlan_rx_add_vid,
4301 .ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid,
4302 .ndo_features_check = lan78xx_features_check,
4305 static void lan78xx_stat_monitor(struct timer_list *t)
4307 struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
4309 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
4312 static int lan78xx_probe(struct usb_interface *intf,
4313 const struct usb_device_id *id)
4315 struct usb_host_endpoint *ep_blkin, *ep_blkout, *ep_intr;
4316 struct lan78xx_net *dev;
4317 struct net_device *netdev;
4318 struct usb_device *udev;
4321 unsigned int period;
4324 udev = interface_to_usbdev(intf);
4325 udev = usb_get_dev(udev);
4327 netdev = alloc_etherdev(sizeof(struct lan78xx_net));
4329 dev_err(&intf->dev, "Error: OOM\n");
4334 /* netdev_printk() needs this */
4335 SET_NETDEV_DEV(netdev, &intf->dev);
4337 dev = netdev_priv(netdev);
4341 dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
4342 | NETIF_MSG_PROBE | NETIF_MSG_LINK);
4344 skb_queue_head_init(&dev->rxq);
4345 skb_queue_head_init(&dev->txq);
4346 skb_queue_head_init(&dev->rxq_done);
4347 skb_queue_head_init(&dev->txq_pend);
4348 skb_queue_head_init(&dev->rxq_overflow);
4349 mutex_init(&dev->phy_mutex);
4350 mutex_init(&dev->dev_mutex);
4352 ret = lan78xx_urb_config_init(dev);
4356 ret = lan78xx_alloc_tx_resources(dev);
4360 ret = lan78xx_alloc_rx_resources(dev);
4364 /* MTU range: 68 - 9000 */
4365 netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
4367 netif_set_tso_max_size(netdev, LAN78XX_TSO_SIZE(dev));
4369 netif_napi_add(netdev, &dev->napi, lan78xx_poll);
4371 INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
4372 init_usb_anchor(&dev->deferred);
4374 netdev->netdev_ops = &lan78xx_netdev_ops;
4375 netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
4376 netdev->ethtool_ops = &lan78xx_ethtool_ops;
4379 timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
4381 mutex_init(&dev->stats.access_lock);
4383 if (intf->cur_altsetting->desc.bNumEndpoints < 3) {
4388 dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
4389 ep_blkin = usb_pipe_endpoint(udev, dev->pipe_in);
4390 if (!ep_blkin || !usb_endpoint_is_bulk_in(&ep_blkin->desc)) {
4395 dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
4396 ep_blkout = usb_pipe_endpoint(udev, dev->pipe_out);
4397 if (!ep_blkout || !usb_endpoint_is_bulk_out(&ep_blkout->desc)) {
4402 ep_intr = &intf->cur_altsetting->endpoint[2];
4403 if (!usb_endpoint_is_int_in(&ep_intr->desc)) {
4408 dev->pipe_intr = usb_rcvintpipe(dev->udev,
4409 usb_endpoint_num(&ep_intr->desc));
4411 ret = lan78xx_bind(dev, intf);
4415 period = ep_intr->desc.bInterval;
4416 maxp = usb_maxpacket(dev->udev, dev->pipe_intr);
4417 buf = kmalloc(maxp, GFP_KERNEL);
4423 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
4424 if (!dev->urb_intr) {
4428 usb_fill_int_urb(dev->urb_intr, dev->udev,
4429 dev->pipe_intr, buf, maxp,
4430 intr_complete, dev, period);
4431 dev->urb_intr->transfer_flags |= URB_FREE_BUFFER;
4434 dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out);
4436 /* Reject broken descriptors. */
4437 if (dev->maxpacket == 0) {
4442 /* driver requires remote-wakeup capability during autosuspend. */
4443 intf->needs_remote_wakeup = 1;
4445 ret = lan78xx_phy_init(dev);
4449 ret = register_netdev(netdev);
4451 netif_err(dev, probe, netdev, "couldn't register the device\n");
4455 usb_set_intfdata(intf, dev);
4457 ret = device_set_wakeup_enable(&udev->dev, true);
4459 /* Default delay of 2sec has more overhead than advantage.
4460 * Set to 10sec as default.
4462 pm_runtime_set_autosuspend_delay(&udev->dev,
4463 DEFAULT_AUTOSUSPEND_DELAY);
4468 phy_disconnect(netdev->phydev);
4470 usb_free_urb(dev->urb_intr);
4474 lan78xx_unbind(dev, intf);
4476 netif_napi_del(&dev->napi);
4477 lan78xx_free_rx_resources(dev);
4479 lan78xx_free_tx_resources(dev);
4481 free_netdev(netdev);
4488 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
4490 const u16 crc16poly = 0x8005;
4496 for (i = 0; i < len; i++) {
4498 for (bit = 0; bit < 8; bit++) {
4502 if (msb ^ (u16)(data & 1)) {
4504 crc |= (u16)0x0001U;
4513 static int lan78xx_set_auto_suspend(struct lan78xx_net *dev)
4518 ret = lan78xx_stop_tx_path(dev);
4522 ret = lan78xx_stop_rx_path(dev);
4526 /* auto suspend (selective suspend) */
4528 ret = lan78xx_write_reg(dev, WUCSR, 0);
4531 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4534 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4538 /* set goodframe wakeup */
4540 ret = lan78xx_read_reg(dev, WUCSR, &buf);
4544 buf |= WUCSR_RFE_WAKE_EN_;
4545 buf |= WUCSR_STORE_WAKE_;
4547 ret = lan78xx_write_reg(dev, WUCSR, buf);
4551 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4555 buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4556 buf |= PMT_CTL_RES_CLR_WKP_STS_;
4557 buf |= PMT_CTL_PHY_WAKE_EN_;
4558 buf |= PMT_CTL_WOL_EN_;
4559 buf &= ~PMT_CTL_SUS_MODE_MASK_;
4560 buf |= PMT_CTL_SUS_MODE_3_;
4562 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4566 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4570 buf |= PMT_CTL_WUPS_MASK_;
4572 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4576 ret = lan78xx_start_rx_path(dev);
4581 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
4583 const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
4584 const u8 ipv6_multicast[3] = { 0x33, 0x33 };
4585 const u8 arp_type[2] = { 0x08, 0x06 };
4593 ret = lan78xx_stop_tx_path(dev);
4596 ret = lan78xx_stop_rx_path(dev);
4600 ret = lan78xx_write_reg(dev, WUCSR, 0);
4603 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4606 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4614 ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
4618 temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
4619 temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
4621 for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++) {
4622 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
4628 if (wol & WAKE_PHY) {
4629 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
4631 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4632 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4633 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4635 if (wol & WAKE_MAGIC) {
4636 temp_wucsr |= WUCSR_MPEN_;
4638 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4639 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4640 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
4642 if (wol & WAKE_BCAST) {
4643 temp_wucsr |= WUCSR_BCST_EN_;
4645 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4646 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4647 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4649 if (wol & WAKE_MCAST) {
4650 temp_wucsr |= WUCSR_WAKE_EN_;
4652 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
4653 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
4654 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4656 WUF_CFGX_TYPE_MCAST_ |
4657 (0 << WUF_CFGX_OFFSET_SHIFT_) |
4658 (crc & WUF_CFGX_CRC16_MASK_));
4662 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
4665 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4668 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4671 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4677 /* for IPv6 Multicast */
4678 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
4679 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4681 WUF_CFGX_TYPE_MCAST_ |
4682 (0 << WUF_CFGX_OFFSET_SHIFT_) |
4683 (crc & WUF_CFGX_CRC16_MASK_));
4687 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
4690 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4693 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4696 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4702 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4703 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4704 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4706 if (wol & WAKE_UCAST) {
4707 temp_wucsr |= WUCSR_PFDA_EN_;
4709 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4710 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4711 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4713 if (wol & WAKE_ARP) {
4714 temp_wucsr |= WUCSR_WAKE_EN_;
4716 /* set WUF_CFG & WUF_MASK
4717 * for packettype (offset 12,13) = ARP (0x0806)
4719 crc = lan78xx_wakeframe_crc16(arp_type, 2);
4720 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4722 WUF_CFGX_TYPE_ALL_ |
4723 (0 << WUF_CFGX_OFFSET_SHIFT_) |
4724 (crc & WUF_CFGX_CRC16_MASK_));
4728 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
4731 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4734 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4737 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4743 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4744 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4745 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4748 ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
4752 /* when multiple WOL bits are set */
4753 if (hweight_long((unsigned long)wol) > 1) {
4754 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4755 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4756 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4758 ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
4763 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4767 buf |= PMT_CTL_WUPS_MASK_;
4769 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4773 ret = lan78xx_start_rx_path(dev);
4778 static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
4780 struct lan78xx_net *dev = usb_get_intfdata(intf);
4784 mutex_lock(&dev->dev_mutex);
4786 netif_dbg(dev, ifdown, dev->net,
4787 "suspending: pm event %#x", message.event);
4789 dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);
4792 spin_lock_irq(&dev->txq.lock);
4793 /* don't autosuspend while transmitting */
4794 if ((skb_queue_len(&dev->txq) ||
4795 skb_queue_len(&dev->txq_pend)) &&
4796 PMSG_IS_AUTO(message)) {
4797 spin_unlock_irq(&dev->txq.lock);
4801 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
4802 spin_unlock_irq(&dev->txq.lock);
4806 ret = lan78xx_stop_rx_path(dev);
4810 ret = lan78xx_flush_rx_fifo(dev);
4815 ret = lan78xx_stop_tx_path(dev);
4819 /* empty out the Rx and Tx queues */
4820 netif_device_detach(dev->net);
4821 lan78xx_terminate_urbs(dev);
4822 usb_kill_urb(dev->urb_intr);
4825 netif_device_attach(dev->net);
4827 del_timer(&dev->stat_monitor);
4829 if (PMSG_IS_AUTO(message)) {
4830 ret = lan78xx_set_auto_suspend(dev);
4834 struct lan78xx_priv *pdata;
4836 pdata = (struct lan78xx_priv *)(dev->data[0]);
4837 netif_carrier_off(dev->net);
4838 ret = lan78xx_set_suspend(dev, pdata->wol);
4843 /* Interface is down; don't allow WOL and PHY
4844 * events to wake up the host
4848 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
4850 ret = lan78xx_write_reg(dev, WUCSR, 0);
4853 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4857 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4861 buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4862 buf |= PMT_CTL_RES_CLR_WKP_STS_;
4863 buf &= ~PMT_CTL_SUS_MODE_MASK_;
4864 buf |= PMT_CTL_SUS_MODE_3_;
4866 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4870 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4874 buf |= PMT_CTL_WUPS_MASK_;
4876 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4883 mutex_unlock(&dev->dev_mutex);
4888 static bool lan78xx_submit_deferred_urbs(struct lan78xx_net *dev)
4890 bool pipe_halted = false;
4893 while ((urb = usb_get_from_anchor(&dev->deferred))) {
4894 struct sk_buff *skb = urb->context;
4897 if (!netif_device_present(dev->net) ||
4898 !netif_carrier_ok(dev->net) ||
4900 lan78xx_release_tx_buf(dev, skb);
4904 ret = usb_submit_urb(urb, GFP_ATOMIC);
4907 netif_trans_update(dev->net);
4908 lan78xx_queue_skb(&dev->txq, skb, tx_start);
4910 if (ret == -EPIPE) {
4911 netif_stop_queue(dev->net);
4913 } else if (ret == -ENODEV) {
4914 netif_device_detach(dev->net);
4917 lan78xx_release_tx_buf(dev, skb);
4924 static int lan78xx_resume(struct usb_interface *intf)
4926 struct lan78xx_net *dev = usb_get_intfdata(intf);
4930 mutex_lock(&dev->dev_mutex);
4932 netif_dbg(dev, ifup, dev->net, "resuming device");
4934 dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);
4937 bool pipe_halted = false;
4939 ret = lan78xx_flush_tx_fifo(dev);
4943 if (dev->urb_intr) {
4944 int ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
4948 netif_device_detach(dev->net);
4949 netdev_warn(dev->net, "Failed to submit intr URB");
4953 spin_lock_irq(&dev->txq.lock);
4955 if (netif_device_present(dev->net)) {
4956 pipe_halted = lan78xx_submit_deferred_urbs(dev);
4959 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
4962 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4964 spin_unlock_irq(&dev->txq.lock);
4967 netif_device_present(dev->net) &&
4968 (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev)))
4969 netif_start_queue(dev->net);
4971 ret = lan78xx_start_tx_path(dev);
4975 napi_schedule(&dev->napi);
4977 if (!timer_pending(&dev->stat_monitor)) {
4979 mod_timer(&dev->stat_monitor,
4980 jiffies + STAT_UPDATE_TIMER);
4984 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4987 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4990 ret = lan78xx_write_reg(dev, WUCSR, 0);
4993 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4997 ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
4999 WUCSR2_IPV6_TCPSYN_RCD_ |
5000 WUCSR2_IPV4_TCPSYN_RCD_);
5004 ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
5005 WUCSR_EEE_RX_WAKE_ |
5007 WUCSR_RFE_WAKE_FR_ |
5016 mutex_unlock(&dev->dev_mutex);
5021 static int lan78xx_reset_resume(struct usb_interface *intf)
5023 struct lan78xx_net *dev = usb_get_intfdata(intf);
5026 netif_dbg(dev, ifup, dev->net, "(reset) resuming device");
5028 ret = lan78xx_reset(dev);
5032 phy_start(dev->net->phydev);
5034 ret = lan78xx_resume(intf);
5039 static const struct usb_device_id products[] = {
5041 /* LAN7800 USB Gigabit Ethernet Device */
5042 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
5045 /* LAN7850 USB Gigabit Ethernet Device */
5046 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
5049 /* LAN7801 USB Gigabit Ethernet Device */
5050 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
5053 /* ATM2-AF USB Gigabit Ethernet Device */
5054 USB_DEVICE(AT29M2AF_USB_VENDOR_ID, AT29M2AF_USB_PRODUCT_ID),
5058 MODULE_DEVICE_TABLE(usb, products);
5060 static struct usb_driver lan78xx_driver = {
5061 .name = DRIVER_NAME,
5062 .id_table = products,
5063 .probe = lan78xx_probe,
5064 .disconnect = lan78xx_disconnect,
5065 .suspend = lan78xx_suspend,
5066 .resume = lan78xx_resume,
5067 .reset_resume = lan78xx_reset_resume,
5068 .supports_autosuspend = 1,
5069 .disable_hub_initiated_lpm = 1,
5072 module_usb_driver(lan78xx_driver);
5074 MODULE_AUTHOR(DRIVER_AUTHOR);
5075 MODULE_DESCRIPTION(DRIVER_DESC);
5076 MODULE_LICENSE("GPL");