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>
33 #define DRIVER_AUTHOR "WOOJUNG HUH <woojung.huh@microchip.com>"
34 #define DRIVER_DESC "LAN78XX USB 3.0 Gigabit Ethernet Devices"
35 #define DRIVER_NAME "lan78xx"
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)
49 #define DEFAULT_BURST_CAP_SIZE (MAX_TX_FIFO_SIZE)
50 #define DEFAULT_BULK_IN_DELAY (0x0800)
51 #define MAX_SINGLE_PACKET_SIZE (9000)
52 #define DEFAULT_TX_CSUM_ENABLE (true)
53 #define DEFAULT_RX_CSUM_ENABLE (true)
54 #define DEFAULT_TSO_CSUM_ENABLE (true)
55 #define DEFAULT_VLAN_FILTER_ENABLE (true)
56 #define DEFAULT_VLAN_RX_OFFLOAD (true)
57 #define TX_OVERHEAD (8)
60 #define LAN78XX_USB_VENDOR_ID (0x0424)
61 #define LAN7800_USB_PRODUCT_ID (0x7800)
62 #define LAN7850_USB_PRODUCT_ID (0x7850)
63 #define LAN7801_USB_PRODUCT_ID (0x7801)
64 #define LAN78XX_EEPROM_MAGIC (0x78A5)
65 #define LAN78XX_OTP_MAGIC (0x78F3)
70 #define EEPROM_INDICATOR (0xA5)
71 #define EEPROM_MAC_OFFSET (0x01)
72 #define MAX_EEPROM_SIZE 512
73 #define OTP_INDICATOR_1 (0xF3)
74 #define OTP_INDICATOR_2 (0xF7)
76 #define WAKE_ALL (WAKE_PHY | WAKE_UCAST | \
77 WAKE_MCAST | WAKE_BCAST | \
78 WAKE_ARP | WAKE_MAGIC)
80 /* USB related defines */
81 #define BULK_IN_PIPE 1
82 #define BULK_OUT_PIPE 2
84 /* default autosuspend delay (mSec)*/
85 #define DEFAULT_AUTOSUSPEND_DELAY (10 * 1000)
87 /* statistic update interval (mSec) */
88 #define STAT_UPDATE_TIMER (1 * 1000)
90 /* defines interrupts from interrupt EP */
91 #define MAX_INT_EP (32)
92 #define INT_EP_INTEP (31)
93 #define INT_EP_OTP_WR_DONE (28)
94 #define INT_EP_EEE_TX_LPI_START (26)
95 #define INT_EP_EEE_TX_LPI_STOP (25)
96 #define INT_EP_EEE_RX_LPI (24)
97 #define INT_EP_MAC_RESET_TIMEOUT (23)
98 #define INT_EP_RDFO (22)
99 #define INT_EP_TXE (21)
100 #define INT_EP_USB_STATUS (20)
101 #define INT_EP_TX_DIS (19)
102 #define INT_EP_RX_DIS (18)
103 #define INT_EP_PHY (17)
104 #define INT_EP_DP (16)
105 #define INT_EP_MAC_ERR (15)
106 #define INT_EP_TDFU (14)
107 #define INT_EP_TDFO (13)
108 #define INT_EP_UTX (12)
109 #define INT_EP_GPIO_11 (11)
110 #define INT_EP_GPIO_10 (10)
111 #define INT_EP_GPIO_9 (9)
112 #define INT_EP_GPIO_8 (8)
113 #define INT_EP_GPIO_7 (7)
114 #define INT_EP_GPIO_6 (6)
115 #define INT_EP_GPIO_5 (5)
116 #define INT_EP_GPIO_4 (4)
117 #define INT_EP_GPIO_3 (3)
118 #define INT_EP_GPIO_2 (2)
119 #define INT_EP_GPIO_1 (1)
120 #define INT_EP_GPIO_0 (0)
122 static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {
124 "RX Alignment Errors",
125 "Rx Fragment Errors",
127 "RX Undersize Frame Errors",
128 "RX Oversize Frame Errors",
130 "RX Unicast Byte Count",
131 "RX Broadcast Byte Count",
132 "RX Multicast Byte Count",
134 "RX Broadcast Frames",
135 "RX Multicast Frames",
138 "RX 65 - 127 Byte Frames",
139 "RX 128 - 255 Byte Frames",
140 "RX 256 - 511 Bytes Frames",
141 "RX 512 - 1023 Byte Frames",
142 "RX 1024 - 1518 Byte Frames",
143 "RX Greater 1518 Byte Frames",
144 "EEE RX LPI Transitions",
147 "TX Excess Deferral Errors",
150 "TX Single Collisions",
151 "TX Multiple Collisions",
152 "TX Excessive Collision",
153 "TX Late Collisions",
154 "TX Unicast Byte Count",
155 "TX Broadcast Byte Count",
156 "TX Multicast Byte Count",
158 "TX Broadcast Frames",
159 "TX Multicast Frames",
162 "TX 65 - 127 Byte Frames",
163 "TX 128 - 255 Byte Frames",
164 "TX 256 - 511 Bytes Frames",
165 "TX 512 - 1023 Byte Frames",
166 "TX 1024 - 1518 Byte Frames",
167 "TX Greater 1518 Byte Frames",
168 "EEE TX LPI Transitions",
172 struct lan78xx_statstage {
174 u32 rx_alignment_errors;
175 u32 rx_fragment_errors;
176 u32 rx_jabber_errors;
177 u32 rx_undersize_frame_errors;
178 u32 rx_oversize_frame_errors;
179 u32 rx_dropped_frames;
180 u32 rx_unicast_byte_count;
181 u32 rx_broadcast_byte_count;
182 u32 rx_multicast_byte_count;
183 u32 rx_unicast_frames;
184 u32 rx_broadcast_frames;
185 u32 rx_multicast_frames;
187 u32 rx_64_byte_frames;
188 u32 rx_65_127_byte_frames;
189 u32 rx_128_255_byte_frames;
190 u32 rx_256_511_bytes_frames;
191 u32 rx_512_1023_byte_frames;
192 u32 rx_1024_1518_byte_frames;
193 u32 rx_greater_1518_byte_frames;
194 u32 eee_rx_lpi_transitions;
197 u32 tx_excess_deferral_errors;
198 u32 tx_carrier_errors;
199 u32 tx_bad_byte_count;
200 u32 tx_single_collisions;
201 u32 tx_multiple_collisions;
202 u32 tx_excessive_collision;
203 u32 tx_late_collisions;
204 u32 tx_unicast_byte_count;
205 u32 tx_broadcast_byte_count;
206 u32 tx_multicast_byte_count;
207 u32 tx_unicast_frames;
208 u32 tx_broadcast_frames;
209 u32 tx_multicast_frames;
211 u32 tx_64_byte_frames;
212 u32 tx_65_127_byte_frames;
213 u32 tx_128_255_byte_frames;
214 u32 tx_256_511_bytes_frames;
215 u32 tx_512_1023_byte_frames;
216 u32 tx_1024_1518_byte_frames;
217 u32 tx_greater_1518_byte_frames;
218 u32 eee_tx_lpi_transitions;
222 struct lan78xx_statstage64 {
224 u64 rx_alignment_errors;
225 u64 rx_fragment_errors;
226 u64 rx_jabber_errors;
227 u64 rx_undersize_frame_errors;
228 u64 rx_oversize_frame_errors;
229 u64 rx_dropped_frames;
230 u64 rx_unicast_byte_count;
231 u64 rx_broadcast_byte_count;
232 u64 rx_multicast_byte_count;
233 u64 rx_unicast_frames;
234 u64 rx_broadcast_frames;
235 u64 rx_multicast_frames;
237 u64 rx_64_byte_frames;
238 u64 rx_65_127_byte_frames;
239 u64 rx_128_255_byte_frames;
240 u64 rx_256_511_bytes_frames;
241 u64 rx_512_1023_byte_frames;
242 u64 rx_1024_1518_byte_frames;
243 u64 rx_greater_1518_byte_frames;
244 u64 eee_rx_lpi_transitions;
247 u64 tx_excess_deferral_errors;
248 u64 tx_carrier_errors;
249 u64 tx_bad_byte_count;
250 u64 tx_single_collisions;
251 u64 tx_multiple_collisions;
252 u64 tx_excessive_collision;
253 u64 tx_late_collisions;
254 u64 tx_unicast_byte_count;
255 u64 tx_broadcast_byte_count;
256 u64 tx_multicast_byte_count;
257 u64 tx_unicast_frames;
258 u64 tx_broadcast_frames;
259 u64 tx_multicast_frames;
261 u64 tx_64_byte_frames;
262 u64 tx_65_127_byte_frames;
263 u64 tx_128_255_byte_frames;
264 u64 tx_256_511_bytes_frames;
265 u64 tx_512_1023_byte_frames;
266 u64 tx_1024_1518_byte_frames;
267 u64 tx_greater_1518_byte_frames;
268 u64 eee_tx_lpi_transitions;
272 static u32 lan78xx_regs[] = {
294 #define PHY_REG_SIZE (32 * sizeof(u32))
298 struct lan78xx_priv {
299 struct lan78xx_net *dev;
301 u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicat hash table */
302 u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */
303 u32 vlan_table[DP_SEL_VHF_VLAN_LEN];
304 struct mutex dataport_mutex; /* for dataport access */
305 spinlock_t rfe_ctl_lock; /* for rfe register access */
306 struct work_struct set_multicast;
307 struct work_struct set_vlan;
321 struct skb_data { /* skb->cb is one of these */
323 struct lan78xx_net *dev;
324 enum skb_state state;
330 struct usb_ctrlrequest req;
331 struct lan78xx_net *dev;
334 #define EVENT_TX_HALT 0
335 #define EVENT_RX_HALT 1
336 #define EVENT_RX_MEMORY 2
337 #define EVENT_STS_SPLIT 3
338 #define EVENT_LINK_RESET 4
339 #define EVENT_RX_PAUSED 5
340 #define EVENT_DEV_WAKING 6
341 #define EVENT_DEV_ASLEEP 7
342 #define EVENT_DEV_OPEN 8
343 #define EVENT_STAT_UPDATE 9
346 struct mutex access_lock; /* for stats access */
347 struct lan78xx_statstage saved;
348 struct lan78xx_statstage rollover_count;
349 struct lan78xx_statstage rollover_max;
350 struct lan78xx_statstage64 curr_stat;
353 struct irq_domain_data {
354 struct irq_domain *irqdomain;
356 struct irq_chip *irqchip;
357 irq_flow_handler_t irq_handler;
359 struct mutex irq_lock; /* for irq bus access */
363 struct net_device *net;
364 struct usb_device *udev;
365 struct usb_interface *intf;
370 struct sk_buff_head rxq;
371 struct sk_buff_head txq;
372 struct sk_buff_head done;
373 struct sk_buff_head rxq_pause;
374 struct sk_buff_head txq_pend;
376 struct tasklet_struct bh;
377 struct delayed_work wq;
381 struct urb *urb_intr;
382 struct usb_anchor deferred;
384 struct mutex phy_mutex; /* for phy access */
385 unsigned pipe_in, pipe_out, pipe_intr;
387 u32 hard_mtu; /* count any extra framing */
388 size_t rx_urb_size; /* size for rx urbs */
392 wait_queue_head_t *wait;
393 unsigned char suspend_count;
396 struct timer_list delay;
397 struct timer_list stat_monitor;
399 unsigned long data[5];
406 struct mii_bus *mdiobus;
407 phy_interface_t interface;
410 u8 fc_request_control;
413 struct statstage stats;
415 struct irq_domain_data domain_data;
418 /* define external phy id */
419 #define PHY_LAN8835 (0x0007C130)
420 #define PHY_KSZ9031RNX (0x00221620)
422 /* use ethtool to change the level for any given device */
423 static int msg_level = -1;
424 module_param(msg_level, int, 0);
425 MODULE_PARM_DESC(msg_level, "Override default message level");
427 static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
429 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
435 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
436 USB_VENDOR_REQUEST_READ_REGISTER,
437 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
438 0, index, buf, 4, USB_CTRL_GET_TIMEOUT);
439 if (likely(ret >= 0)) {
443 netdev_warn(dev->net,
444 "Failed to read register index 0x%08x. ret = %d",
453 static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
455 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
464 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
465 USB_VENDOR_REQUEST_WRITE_REGISTER,
466 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
467 0, index, buf, 4, USB_CTRL_SET_TIMEOUT);
468 if (unlikely(ret < 0)) {
469 netdev_warn(dev->net,
470 "Failed to write register index 0x%08x. ret = %d",
479 static int lan78xx_read_stats(struct lan78xx_net *dev,
480 struct lan78xx_statstage *data)
484 struct lan78xx_statstage *stats;
488 stats = kmalloc(sizeof(*stats), GFP_KERNEL);
492 ret = usb_control_msg(dev->udev,
493 usb_rcvctrlpipe(dev->udev, 0),
494 USB_VENDOR_REQUEST_GET_STATS,
495 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
500 USB_CTRL_SET_TIMEOUT);
501 if (likely(ret >= 0)) {
504 for (i = 0; i < sizeof(*stats)/sizeof(u32); i++) {
505 le32_to_cpus(&src[i]);
509 netdev_warn(dev->net,
510 "Failed to read stat ret = %d", ret);
518 #define check_counter_rollover(struct1, dev_stats, member) { \
519 if (struct1->member < dev_stats.saved.member) \
520 dev_stats.rollover_count.member++; \
523 static void lan78xx_check_stat_rollover(struct lan78xx_net *dev,
524 struct lan78xx_statstage *stats)
526 check_counter_rollover(stats, dev->stats, rx_fcs_errors);
527 check_counter_rollover(stats, dev->stats, rx_alignment_errors);
528 check_counter_rollover(stats, dev->stats, rx_fragment_errors);
529 check_counter_rollover(stats, dev->stats, rx_jabber_errors);
530 check_counter_rollover(stats, dev->stats, rx_undersize_frame_errors);
531 check_counter_rollover(stats, dev->stats, rx_oversize_frame_errors);
532 check_counter_rollover(stats, dev->stats, rx_dropped_frames);
533 check_counter_rollover(stats, dev->stats, rx_unicast_byte_count);
534 check_counter_rollover(stats, dev->stats, rx_broadcast_byte_count);
535 check_counter_rollover(stats, dev->stats, rx_multicast_byte_count);
536 check_counter_rollover(stats, dev->stats, rx_unicast_frames);
537 check_counter_rollover(stats, dev->stats, rx_broadcast_frames);
538 check_counter_rollover(stats, dev->stats, rx_multicast_frames);
539 check_counter_rollover(stats, dev->stats, rx_pause_frames);
540 check_counter_rollover(stats, dev->stats, rx_64_byte_frames);
541 check_counter_rollover(stats, dev->stats, rx_65_127_byte_frames);
542 check_counter_rollover(stats, dev->stats, rx_128_255_byte_frames);
543 check_counter_rollover(stats, dev->stats, rx_256_511_bytes_frames);
544 check_counter_rollover(stats, dev->stats, rx_512_1023_byte_frames);
545 check_counter_rollover(stats, dev->stats, rx_1024_1518_byte_frames);
546 check_counter_rollover(stats, dev->stats, rx_greater_1518_byte_frames);
547 check_counter_rollover(stats, dev->stats, eee_rx_lpi_transitions);
548 check_counter_rollover(stats, dev->stats, eee_rx_lpi_time);
549 check_counter_rollover(stats, dev->stats, tx_fcs_errors);
550 check_counter_rollover(stats, dev->stats, tx_excess_deferral_errors);
551 check_counter_rollover(stats, dev->stats, tx_carrier_errors);
552 check_counter_rollover(stats, dev->stats, tx_bad_byte_count);
553 check_counter_rollover(stats, dev->stats, tx_single_collisions);
554 check_counter_rollover(stats, dev->stats, tx_multiple_collisions);
555 check_counter_rollover(stats, dev->stats, tx_excessive_collision);
556 check_counter_rollover(stats, dev->stats, tx_late_collisions);
557 check_counter_rollover(stats, dev->stats, tx_unicast_byte_count);
558 check_counter_rollover(stats, dev->stats, tx_broadcast_byte_count);
559 check_counter_rollover(stats, dev->stats, tx_multicast_byte_count);
560 check_counter_rollover(stats, dev->stats, tx_unicast_frames);
561 check_counter_rollover(stats, dev->stats, tx_broadcast_frames);
562 check_counter_rollover(stats, dev->stats, tx_multicast_frames);
563 check_counter_rollover(stats, dev->stats, tx_pause_frames);
564 check_counter_rollover(stats, dev->stats, tx_64_byte_frames);
565 check_counter_rollover(stats, dev->stats, tx_65_127_byte_frames);
566 check_counter_rollover(stats, dev->stats, tx_128_255_byte_frames);
567 check_counter_rollover(stats, dev->stats, tx_256_511_bytes_frames);
568 check_counter_rollover(stats, dev->stats, tx_512_1023_byte_frames);
569 check_counter_rollover(stats, dev->stats, tx_1024_1518_byte_frames);
570 check_counter_rollover(stats, dev->stats, tx_greater_1518_byte_frames);
571 check_counter_rollover(stats, dev->stats, eee_tx_lpi_transitions);
572 check_counter_rollover(stats, dev->stats, eee_tx_lpi_time);
574 memcpy(&dev->stats.saved, stats, sizeof(struct lan78xx_statstage));
577 static void lan78xx_update_stats(struct lan78xx_net *dev)
579 u32 *p, *count, *max;
582 struct lan78xx_statstage lan78xx_stats;
584 if (usb_autopm_get_interface(dev->intf) < 0)
587 p = (u32 *)&lan78xx_stats;
588 count = (u32 *)&dev->stats.rollover_count;
589 max = (u32 *)&dev->stats.rollover_max;
590 data = (u64 *)&dev->stats.curr_stat;
592 mutex_lock(&dev->stats.access_lock);
594 if (lan78xx_read_stats(dev, &lan78xx_stats) > 0)
595 lan78xx_check_stat_rollover(dev, &lan78xx_stats);
597 for (i = 0; i < (sizeof(lan78xx_stats) / (sizeof(u32))); i++)
598 data[i] = (u64)p[i] + ((u64)count[i] * ((u64)max[i] + 1));
600 mutex_unlock(&dev->stats.access_lock);
602 usb_autopm_put_interface(dev->intf);
605 /* Loop until the read is completed with timeout called with phy_mutex held */
606 static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)
608 unsigned long start_time = jiffies;
613 ret = lan78xx_read_reg(dev, MII_ACC, &val);
614 if (unlikely(ret < 0))
617 if (!(val & MII_ACC_MII_BUSY_))
619 } while (!time_after(jiffies, start_time + HZ));
624 static inline u32 mii_access(int id, int index, int read)
628 ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;
629 ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;
631 ret |= MII_ACC_MII_READ_;
633 ret |= MII_ACC_MII_WRITE_;
634 ret |= MII_ACC_MII_BUSY_;
639 static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
641 unsigned long start_time = jiffies;
646 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
647 if (unlikely(ret < 0))
650 if (!(val & E2P_CMD_EPC_BUSY_) ||
651 (val & E2P_CMD_EPC_TIMEOUT_))
653 usleep_range(40, 100);
654 } while (!time_after(jiffies, start_time + HZ));
656 if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
657 netdev_warn(dev->net, "EEPROM read operation timeout");
664 static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
666 unsigned long start_time = jiffies;
671 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
672 if (unlikely(ret < 0))
675 if (!(val & E2P_CMD_EPC_BUSY_))
678 usleep_range(40, 100);
679 } while (!time_after(jiffies, start_time + HZ));
681 netdev_warn(dev->net, "EEPROM is busy");
685 static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
686 u32 length, u8 *data)
693 /* depends on chip, some EEPROM pins are muxed with LED function.
694 * disable & restore LED function to access EEPROM.
696 ret = lan78xx_read_reg(dev, HW_CFG, &val);
698 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
699 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
700 ret = lan78xx_write_reg(dev, HW_CFG, val);
703 retval = lan78xx_eeprom_confirm_not_busy(dev);
707 for (i = 0; i < length; i++) {
708 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
709 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
710 ret = lan78xx_write_reg(dev, E2P_CMD, val);
711 if (unlikely(ret < 0)) {
716 retval = lan78xx_wait_eeprom(dev);
720 ret = lan78xx_read_reg(dev, E2P_DATA, &val);
721 if (unlikely(ret < 0)) {
726 data[i] = val & 0xFF;
732 if (dev->chipid == ID_REV_CHIP_ID_7800_)
733 ret = lan78xx_write_reg(dev, HW_CFG, saved);
738 static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
739 u32 length, u8 *data)
744 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
745 if ((ret == 0) && (sig == EEPROM_INDICATOR))
746 ret = lan78xx_read_raw_eeprom(dev, offset, length, data);
753 static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
754 u32 length, u8 *data)
761 /* depends on chip, some EEPROM pins are muxed with LED function.
762 * disable & restore LED function to access EEPROM.
764 ret = lan78xx_read_reg(dev, HW_CFG, &val);
766 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
767 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
768 ret = lan78xx_write_reg(dev, HW_CFG, val);
771 retval = lan78xx_eeprom_confirm_not_busy(dev);
775 /* Issue write/erase enable command */
776 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
777 ret = lan78xx_write_reg(dev, E2P_CMD, val);
778 if (unlikely(ret < 0)) {
783 retval = lan78xx_wait_eeprom(dev);
787 for (i = 0; i < length; i++) {
788 /* Fill data register */
790 ret = lan78xx_write_reg(dev, E2P_DATA, val);
796 /* Send "write" command */
797 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
798 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
799 ret = lan78xx_write_reg(dev, E2P_CMD, val);
805 retval = lan78xx_wait_eeprom(dev);
814 if (dev->chipid == ID_REV_CHIP_ID_7800_)
815 ret = lan78xx_write_reg(dev, HW_CFG, saved);
820 static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
821 u32 length, u8 *data)
825 unsigned long timeout;
827 lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
829 if (buf & OTP_PWR_DN_PWRDN_N_) {
830 /* clear it and wait to be cleared */
831 lan78xx_write_reg(dev, OTP_PWR_DN, 0);
833 timeout = jiffies + HZ;
836 lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
837 if (time_after(jiffies, timeout)) {
838 netdev_warn(dev->net,
839 "timeout on OTP_PWR_DN");
842 } while (buf & OTP_PWR_DN_PWRDN_N_);
845 for (i = 0; i < length; i++) {
846 lan78xx_write_reg(dev, OTP_ADDR1,
847 ((offset + i) >> 8) & OTP_ADDR1_15_11);
848 lan78xx_write_reg(dev, OTP_ADDR2,
849 ((offset + i) & OTP_ADDR2_10_3));
851 lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
852 lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
854 timeout = jiffies + HZ;
857 lan78xx_read_reg(dev, OTP_STATUS, &buf);
858 if (time_after(jiffies, timeout)) {
859 netdev_warn(dev->net,
860 "timeout on OTP_STATUS");
863 } while (buf & OTP_STATUS_BUSY_);
865 lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
867 data[i] = (u8)(buf & 0xFF);
873 static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
874 u32 length, u8 *data)
878 unsigned long timeout;
880 lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
882 if (buf & OTP_PWR_DN_PWRDN_N_) {
883 /* clear it and wait to be cleared */
884 lan78xx_write_reg(dev, OTP_PWR_DN, 0);
886 timeout = jiffies + HZ;
889 lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
890 if (time_after(jiffies, timeout)) {
891 netdev_warn(dev->net,
892 "timeout on OTP_PWR_DN completion");
895 } while (buf & OTP_PWR_DN_PWRDN_N_);
898 /* set to BYTE program mode */
899 lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
901 for (i = 0; i < length; i++) {
902 lan78xx_write_reg(dev, OTP_ADDR1,
903 ((offset + i) >> 8) & OTP_ADDR1_15_11);
904 lan78xx_write_reg(dev, OTP_ADDR2,
905 ((offset + i) & OTP_ADDR2_10_3));
906 lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
907 lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
908 lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
910 timeout = jiffies + HZ;
913 lan78xx_read_reg(dev, OTP_STATUS, &buf);
914 if (time_after(jiffies, timeout)) {
915 netdev_warn(dev->net,
916 "Timeout on OTP_STATUS completion");
919 } while (buf & OTP_STATUS_BUSY_);
925 static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
926 u32 length, u8 *data)
931 ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
934 if (sig == OTP_INDICATOR_2)
936 else if (sig != OTP_INDICATOR_1)
939 ret = lan78xx_read_raw_otp(dev, offset, length, data);
945 static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
949 for (i = 0; i < 100; i++) {
952 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
953 if (unlikely(ret < 0))
956 if (dp_sel & DP_SEL_DPRDY_)
959 usleep_range(40, 100);
962 netdev_warn(dev->net, "lan78xx_dataport_wait_not_busy timed out");
967 static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
968 u32 addr, u32 length, u32 *buf)
970 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
974 if (usb_autopm_get_interface(dev->intf) < 0)
977 mutex_lock(&pdata->dataport_mutex);
979 ret = lan78xx_dataport_wait_not_busy(dev);
983 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
985 dp_sel &= ~DP_SEL_RSEL_MASK_;
986 dp_sel |= ram_select;
987 ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);
989 for (i = 0; i < length; i++) {
990 ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
992 ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
994 ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
996 ret = lan78xx_dataport_wait_not_busy(dev);
1002 mutex_unlock(&pdata->dataport_mutex);
1003 usb_autopm_put_interface(dev->intf);
1008 static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,
1009 int index, u8 addr[ETH_ALEN])
1013 if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {
1015 temp = addr[2] | (temp << 8);
1016 temp = addr[1] | (temp << 8);
1017 temp = addr[0] | (temp << 8);
1018 pdata->pfilter_table[index][1] = temp;
1020 temp = addr[4] | (temp << 8);
1021 temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;
1022 pdata->pfilter_table[index][0] = temp;
1026 /* returns hash bit number for given MAC address */
1027 static inline u32 lan78xx_hash(char addr[ETH_ALEN])
1029 return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
1032 static void lan78xx_deferred_multicast_write(struct work_struct *param)
1034 struct lan78xx_priv *pdata =
1035 container_of(param, struct lan78xx_priv, set_multicast);
1036 struct lan78xx_net *dev = pdata->dev;
1039 netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
1042 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,
1043 DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
1045 for (i = 1; i < NUM_OF_MAF; i++) {
1046 lan78xx_write_reg(dev, MAF_HI(i), 0);
1047 lan78xx_write_reg(dev, MAF_LO(i),
1048 pdata->pfilter_table[i][1]);
1049 lan78xx_write_reg(dev, MAF_HI(i),
1050 pdata->pfilter_table[i][0]);
1053 lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1056 static void lan78xx_set_multicast(struct net_device *netdev)
1058 struct lan78xx_net *dev = netdev_priv(netdev);
1059 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1060 unsigned long flags;
1063 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1065 pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |
1066 RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
1068 for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
1069 pdata->mchash_table[i] = 0;
1070 /* pfilter_table[0] has own HW address */
1071 for (i = 1; i < NUM_OF_MAF; i++) {
1072 pdata->pfilter_table[i][0] =
1073 pdata->pfilter_table[i][1] = 0;
1076 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;
1078 if (dev->net->flags & IFF_PROMISC) {
1079 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
1080 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;
1082 if (dev->net->flags & IFF_ALLMULTI) {
1083 netif_dbg(dev, drv, dev->net,
1084 "receive all multicast enabled");
1085 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;
1089 if (netdev_mc_count(dev->net)) {
1090 struct netdev_hw_addr *ha;
1093 netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
1095 pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;
1098 netdev_for_each_mc_addr(ha, netdev) {
1099 /* set first 32 into Perfect Filter */
1101 lan78xx_set_addr_filter(pdata, i, ha->addr);
1103 u32 bitnum = lan78xx_hash(ha->addr);
1105 pdata->mchash_table[bitnum / 32] |=
1106 (1 << (bitnum % 32));
1107 pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;
1113 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1115 /* defer register writes to a sleepable context */
1116 schedule_work(&pdata->set_multicast);
1119 static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1120 u16 lcladv, u16 rmtadv)
1122 u32 flow = 0, fct_flow = 0;
1125 if (dev->fc_autoneg)
1126 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1128 cap = dev->fc_request_control;
1130 if (cap & FLOW_CTRL_TX)
1131 flow |= (FLOW_CR_TX_FCEN_ | 0xFFFF);
1133 if (cap & FLOW_CTRL_RX)
1134 flow |= FLOW_CR_RX_FCEN_;
1136 if (dev->udev->speed == USB_SPEED_SUPER)
1138 else if (dev->udev->speed == USB_SPEED_HIGH)
1141 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1142 (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
1143 (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
1145 lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1147 /* threshold value should be set before enabling flow */
1148 lan78xx_write_reg(dev, FLOW, flow);
1153 static int lan78xx_link_reset(struct lan78xx_net *dev)
1155 struct phy_device *phydev = dev->net->phydev;
1156 struct ethtool_link_ksettings ecmd;
1157 int ladv, radv, ret;
1160 /* clear LAN78xx interrupt status */
1161 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1162 if (unlikely(ret < 0))
1165 phy_read_status(phydev);
1167 if (!phydev->link && dev->link_on) {
1168 dev->link_on = false;
1171 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1172 if (unlikely(ret < 0))
1175 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1176 if (unlikely(ret < 0))
1179 del_timer(&dev->stat_monitor);
1180 } else if (phydev->link && !dev->link_on) {
1181 dev->link_on = true;
1183 phy_ethtool_ksettings_get(phydev, &ecmd);
1185 if (dev->udev->speed == USB_SPEED_SUPER) {
1186 if (ecmd.base.speed == 1000) {
1188 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1189 buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1190 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1192 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1193 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1194 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1196 /* enable U1 & U2 */
1197 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1198 buf |= USB_CFG1_DEV_U2_INIT_EN_;
1199 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1200 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1204 ladv = phy_read(phydev, MII_ADVERTISE);
1208 radv = phy_read(phydev, MII_LPA);
1212 netif_dbg(dev, link, dev->net,
1213 "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1214 ecmd.base.speed, ecmd.base.duplex, ladv, radv);
1216 ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,
1219 if (!timer_pending(&dev->stat_monitor)) {
1221 mod_timer(&dev->stat_monitor,
1222 jiffies + STAT_UPDATE_TIMER);
1225 tasklet_schedule(&dev->bh);
1231 /* some work can't be done in tasklets, so we use keventd
1233 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
1234 * but tasklet_schedule() doesn't. hope the failure is rare.
1236 static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1238 set_bit(work, &dev->flags);
1239 if (!schedule_delayed_work(&dev->wq, 0))
1240 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1243 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1247 if (urb->actual_length != 4) {
1248 netdev_warn(dev->net,
1249 "unexpected urb length %d", urb->actual_length);
1253 intdata = get_unaligned_le32(urb->transfer_buffer);
1255 if (intdata & INT_ENP_PHY_INT) {
1256 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1257 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1259 if (dev->domain_data.phyirq > 0) {
1260 local_irq_disable();
1261 generic_handle_irq(dev->domain_data.phyirq);
1265 netdev_warn(dev->net,
1266 "unexpected interrupt: 0x%08x\n", intdata);
1269 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1271 return MAX_EEPROM_SIZE;
1274 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1275 struct ethtool_eeprom *ee, u8 *data)
1277 struct lan78xx_net *dev = netdev_priv(netdev);
1280 ret = usb_autopm_get_interface(dev->intf);
1284 ee->magic = LAN78XX_EEPROM_MAGIC;
1286 ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1288 usb_autopm_put_interface(dev->intf);
1293 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1294 struct ethtool_eeprom *ee, u8 *data)
1296 struct lan78xx_net *dev = netdev_priv(netdev);
1299 ret = usb_autopm_get_interface(dev->intf);
1303 /* Invalid EEPROM_INDICATOR at offset zero will result in a failure
1304 * to load data from EEPROM
1306 if (ee->magic == LAN78XX_EEPROM_MAGIC)
1307 ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1308 else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1309 (ee->offset == 0) &&
1311 (data[0] == OTP_INDICATOR_1))
1312 ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1314 usb_autopm_put_interface(dev->intf);
1319 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1322 if (stringset == ETH_SS_STATS)
1323 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1326 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1328 if (sset == ETH_SS_STATS)
1329 return ARRAY_SIZE(lan78xx_gstrings);
1334 static void lan78xx_get_stats(struct net_device *netdev,
1335 struct ethtool_stats *stats, u64 *data)
1337 struct lan78xx_net *dev = netdev_priv(netdev);
1339 lan78xx_update_stats(dev);
1341 mutex_lock(&dev->stats.access_lock);
1342 memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1343 mutex_unlock(&dev->stats.access_lock);
1346 static void lan78xx_get_wol(struct net_device *netdev,
1347 struct ethtool_wolinfo *wol)
1349 struct lan78xx_net *dev = netdev_priv(netdev);
1352 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1354 if (usb_autopm_get_interface(dev->intf) < 0)
1357 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1358 if (unlikely(ret < 0)) {
1362 if (buf & USB_CFG_RMT_WKP_) {
1363 wol->supported = WAKE_ALL;
1364 wol->wolopts = pdata->wol;
1371 usb_autopm_put_interface(dev->intf);
1374 static int lan78xx_set_wol(struct net_device *netdev,
1375 struct ethtool_wolinfo *wol)
1377 struct lan78xx_net *dev = netdev_priv(netdev);
1378 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1381 ret = usb_autopm_get_interface(dev->intf);
1385 if (wol->wolopts & ~WAKE_ALL)
1388 pdata->wol = wol->wolopts;
1390 device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1392 phy_ethtool_set_wol(netdev->phydev, wol);
1394 usb_autopm_put_interface(dev->intf);
1399 static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1401 struct lan78xx_net *dev = netdev_priv(net);
1402 struct phy_device *phydev = net->phydev;
1406 ret = usb_autopm_get_interface(dev->intf);
1410 ret = phy_ethtool_get_eee(phydev, edata);
1414 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1415 if (buf & MAC_CR_EEE_EN_) {
1416 edata->eee_enabled = true;
1417 edata->eee_active = !!(edata->advertised &
1418 edata->lp_advertised);
1419 edata->tx_lpi_enabled = true;
1420 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1421 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1422 edata->tx_lpi_timer = buf;
1424 edata->eee_enabled = false;
1425 edata->eee_active = false;
1426 edata->tx_lpi_enabled = false;
1427 edata->tx_lpi_timer = 0;
1432 usb_autopm_put_interface(dev->intf);
1437 static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1439 struct lan78xx_net *dev = netdev_priv(net);
1443 ret = usb_autopm_get_interface(dev->intf);
1447 if (edata->eee_enabled) {
1448 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1449 buf |= MAC_CR_EEE_EN_;
1450 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1452 phy_ethtool_set_eee(net->phydev, edata);
1454 buf = (u32)edata->tx_lpi_timer;
1455 ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1457 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1458 buf &= ~MAC_CR_EEE_EN_;
1459 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1462 usb_autopm_put_interface(dev->intf);
1467 static u32 lan78xx_get_link(struct net_device *net)
1469 phy_read_status(net->phydev);
1471 return net->phydev->link;
1474 static void lan78xx_get_drvinfo(struct net_device *net,
1475 struct ethtool_drvinfo *info)
1477 struct lan78xx_net *dev = netdev_priv(net);
1479 strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1480 usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1483 static u32 lan78xx_get_msglevel(struct net_device *net)
1485 struct lan78xx_net *dev = netdev_priv(net);
1487 return dev->msg_enable;
1490 static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1492 struct lan78xx_net *dev = netdev_priv(net);
1494 dev->msg_enable = level;
1497 static int lan78xx_get_link_ksettings(struct net_device *net,
1498 struct ethtool_link_ksettings *cmd)
1500 struct lan78xx_net *dev = netdev_priv(net);
1501 struct phy_device *phydev = net->phydev;
1504 ret = usb_autopm_get_interface(dev->intf);
1508 phy_ethtool_ksettings_get(phydev, cmd);
1510 usb_autopm_put_interface(dev->intf);
1515 static int lan78xx_set_link_ksettings(struct net_device *net,
1516 const struct ethtool_link_ksettings *cmd)
1518 struct lan78xx_net *dev = netdev_priv(net);
1519 struct phy_device *phydev = net->phydev;
1523 ret = usb_autopm_get_interface(dev->intf);
1527 /* change speed & duplex */
1528 ret = phy_ethtool_ksettings_set(phydev, cmd);
1530 if (!cmd->base.autoneg) {
1531 /* force link down */
1532 temp = phy_read(phydev, MII_BMCR);
1533 phy_write(phydev, MII_BMCR, temp | BMCR_LOOPBACK);
1535 phy_write(phydev, MII_BMCR, temp);
1538 usb_autopm_put_interface(dev->intf);
1543 static void lan78xx_get_pause(struct net_device *net,
1544 struct ethtool_pauseparam *pause)
1546 struct lan78xx_net *dev = netdev_priv(net);
1547 struct phy_device *phydev = net->phydev;
1548 struct ethtool_link_ksettings ecmd;
1550 phy_ethtool_ksettings_get(phydev, &ecmd);
1552 pause->autoneg = dev->fc_autoneg;
1554 if (dev->fc_request_control & FLOW_CTRL_TX)
1555 pause->tx_pause = 1;
1557 if (dev->fc_request_control & FLOW_CTRL_RX)
1558 pause->rx_pause = 1;
1561 static int lan78xx_set_pause(struct net_device *net,
1562 struct ethtool_pauseparam *pause)
1564 struct lan78xx_net *dev = netdev_priv(net);
1565 struct phy_device *phydev = net->phydev;
1566 struct ethtool_link_ksettings ecmd;
1569 phy_ethtool_ksettings_get(phydev, &ecmd);
1571 if (pause->autoneg && !ecmd.base.autoneg) {
1576 dev->fc_request_control = 0;
1577 if (pause->rx_pause)
1578 dev->fc_request_control |= FLOW_CTRL_RX;
1580 if (pause->tx_pause)
1581 dev->fc_request_control |= FLOW_CTRL_TX;
1583 if (ecmd.base.autoneg) {
1584 __ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
1587 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
1588 ecmd.link_modes.advertising);
1589 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
1590 ecmd.link_modes.advertising);
1591 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
1592 mii_adv_to_linkmode_adv_t(fc, mii_adv);
1593 linkmode_or(ecmd.link_modes.advertising, fc,
1594 ecmd.link_modes.advertising);
1596 phy_ethtool_ksettings_set(phydev, &ecmd);
1599 dev->fc_autoneg = pause->autoneg;
1606 static int lan78xx_get_regs_len(struct net_device *netdev)
1608 if (!netdev->phydev)
1609 return (sizeof(lan78xx_regs));
1611 return (sizeof(lan78xx_regs) + PHY_REG_SIZE);
1615 lan78xx_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
1620 struct lan78xx_net *dev = netdev_priv(netdev);
1622 /* Read Device/MAC registers */
1623 for (i = 0; i < ARRAY_SIZE(lan78xx_regs); i++)
1624 lan78xx_read_reg(dev, lan78xx_regs[i], &data[i]);
1626 if (!netdev->phydev)
1629 /* Read PHY registers */
1630 for (j = 0; j < 32; i++, j++)
1631 data[i] = phy_read(netdev->phydev, j);
1634 static const struct ethtool_ops lan78xx_ethtool_ops = {
1635 .get_link = lan78xx_get_link,
1636 .nway_reset = phy_ethtool_nway_reset,
1637 .get_drvinfo = lan78xx_get_drvinfo,
1638 .get_msglevel = lan78xx_get_msglevel,
1639 .set_msglevel = lan78xx_set_msglevel,
1640 .get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1641 .get_eeprom = lan78xx_ethtool_get_eeprom,
1642 .set_eeprom = lan78xx_ethtool_set_eeprom,
1643 .get_ethtool_stats = lan78xx_get_stats,
1644 .get_sset_count = lan78xx_get_sset_count,
1645 .get_strings = lan78xx_get_strings,
1646 .get_wol = lan78xx_get_wol,
1647 .set_wol = lan78xx_set_wol,
1648 .get_ts_info = ethtool_op_get_ts_info,
1649 .get_eee = lan78xx_get_eee,
1650 .set_eee = lan78xx_set_eee,
1651 .get_pauseparam = lan78xx_get_pause,
1652 .set_pauseparam = lan78xx_set_pause,
1653 .get_link_ksettings = lan78xx_get_link_ksettings,
1654 .set_link_ksettings = lan78xx_set_link_ksettings,
1655 .get_regs_len = lan78xx_get_regs_len,
1656 .get_regs = lan78xx_get_regs,
1659 static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1661 u32 addr_lo, addr_hi;
1664 lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1665 lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1667 addr[0] = addr_lo & 0xFF;
1668 addr[1] = (addr_lo >> 8) & 0xFF;
1669 addr[2] = (addr_lo >> 16) & 0xFF;
1670 addr[3] = (addr_lo >> 24) & 0xFF;
1671 addr[4] = addr_hi & 0xFF;
1672 addr[5] = (addr_hi >> 8) & 0xFF;
1674 if (!is_valid_ether_addr(addr)) {
1675 if (!eth_platform_get_mac_address(&dev->udev->dev, addr)) {
1676 /* valid address present in Device Tree */
1677 netif_dbg(dev, ifup, dev->net,
1678 "MAC address read from Device Tree");
1679 } else if (((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET,
1680 ETH_ALEN, addr) == 0) ||
1681 (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET,
1682 ETH_ALEN, addr) == 0)) &&
1683 is_valid_ether_addr(addr)) {
1684 /* eeprom values are valid so use them */
1685 netif_dbg(dev, ifup, dev->net,
1686 "MAC address read from EEPROM");
1688 /* generate random MAC */
1689 eth_random_addr(addr);
1690 netif_dbg(dev, ifup, dev->net,
1691 "MAC address set to random addr");
1694 addr_lo = addr[0] | (addr[1] << 8) |
1695 (addr[2] << 16) | (addr[3] << 24);
1696 addr_hi = addr[4] | (addr[5] << 8);
1698 lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1699 lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1702 lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1703 lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1705 ether_addr_copy(dev->net->dev_addr, addr);
1708 /* MDIO read and write wrappers for phylib */
1709 static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
1711 struct lan78xx_net *dev = bus->priv;
1715 ret = usb_autopm_get_interface(dev->intf);
1719 mutex_lock(&dev->phy_mutex);
1721 /* confirm MII not busy */
1722 ret = lan78xx_phy_wait_not_busy(dev);
1726 /* set the address, index & direction (read from PHY) */
1727 addr = mii_access(phy_id, idx, MII_READ);
1728 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1730 ret = lan78xx_phy_wait_not_busy(dev);
1734 ret = lan78xx_read_reg(dev, MII_DATA, &val);
1736 ret = (int)(val & 0xFFFF);
1739 mutex_unlock(&dev->phy_mutex);
1740 usb_autopm_put_interface(dev->intf);
1745 static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
1748 struct lan78xx_net *dev = bus->priv;
1752 ret = usb_autopm_get_interface(dev->intf);
1756 mutex_lock(&dev->phy_mutex);
1758 /* confirm MII not busy */
1759 ret = lan78xx_phy_wait_not_busy(dev);
1764 ret = lan78xx_write_reg(dev, MII_DATA, val);
1766 /* set the address, index & direction (write to PHY) */
1767 addr = mii_access(phy_id, idx, MII_WRITE);
1768 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1770 ret = lan78xx_phy_wait_not_busy(dev);
1775 mutex_unlock(&dev->phy_mutex);
1776 usb_autopm_put_interface(dev->intf);
1780 static int lan78xx_mdio_init(struct lan78xx_net *dev)
1782 struct device_node *node;
1785 dev->mdiobus = mdiobus_alloc();
1786 if (!dev->mdiobus) {
1787 netdev_err(dev->net, "can't allocate MDIO bus\n");
1791 dev->mdiobus->priv = (void *)dev;
1792 dev->mdiobus->read = lan78xx_mdiobus_read;
1793 dev->mdiobus->write = lan78xx_mdiobus_write;
1794 dev->mdiobus->name = "lan78xx-mdiobus";
1795 dev->mdiobus->parent = &dev->udev->dev;
1797 snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
1798 dev->udev->bus->busnum, dev->udev->devnum);
1800 switch (dev->chipid) {
1801 case ID_REV_CHIP_ID_7800_:
1802 case ID_REV_CHIP_ID_7850_:
1803 /* set to internal PHY id */
1804 dev->mdiobus->phy_mask = ~(1 << 1);
1806 case ID_REV_CHIP_ID_7801_:
1807 /* scan thru PHYAD[2..0] */
1808 dev->mdiobus->phy_mask = ~(0xFF);
1812 node = of_get_child_by_name(dev->udev->dev.of_node, "mdio");
1813 ret = of_mdiobus_register(dev->mdiobus, node);
1816 netdev_err(dev->net, "can't register MDIO bus\n");
1820 netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
1823 mdiobus_free(dev->mdiobus);
1827 static void lan78xx_remove_mdio(struct lan78xx_net *dev)
1829 mdiobus_unregister(dev->mdiobus);
1830 mdiobus_free(dev->mdiobus);
1833 static void lan78xx_link_status_change(struct net_device *net)
1835 struct phy_device *phydev = net->phydev;
1838 /* At forced 100 F/H mode, chip may fail to set mode correctly
1839 * when cable is switched between long(~50+m) and short one.
1840 * As workaround, set to 10 before setting to 100
1841 * at forced 100 F/H mode.
1843 if (!phydev->autoneg && (phydev->speed == 100)) {
1844 /* disable phy interrupt */
1845 temp = phy_read(phydev, LAN88XX_INT_MASK);
1846 temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_;
1847 phy_write(phydev, LAN88XX_INT_MASK, temp);
1849 temp = phy_read(phydev, MII_BMCR);
1850 temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000);
1851 phy_write(phydev, MII_BMCR, temp); /* set to 10 first */
1852 temp |= BMCR_SPEED100;
1853 phy_write(phydev, MII_BMCR, temp); /* set to 100 later */
1855 /* clear pending interrupt generated while workaround */
1856 temp = phy_read(phydev, LAN88XX_INT_STS);
1858 /* enable phy interrupt back */
1859 temp = phy_read(phydev, LAN88XX_INT_MASK);
1860 temp |= LAN88XX_INT_MASK_MDINTPIN_EN_;
1861 phy_write(phydev, LAN88XX_INT_MASK, temp);
1865 static int irq_map(struct irq_domain *d, unsigned int irq,
1866 irq_hw_number_t hwirq)
1868 struct irq_domain_data *data = d->host_data;
1870 irq_set_chip_data(irq, data);
1871 irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);
1872 irq_set_noprobe(irq);
1877 static void irq_unmap(struct irq_domain *d, unsigned int irq)
1879 irq_set_chip_and_handler(irq, NULL, NULL);
1880 irq_set_chip_data(irq, NULL);
1883 static const struct irq_domain_ops chip_domain_ops = {
1888 static void lan78xx_irq_mask(struct irq_data *irqd)
1890 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1892 data->irqenable &= ~BIT(irqd_to_hwirq(irqd));
1895 static void lan78xx_irq_unmask(struct irq_data *irqd)
1897 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1899 data->irqenable |= BIT(irqd_to_hwirq(irqd));
1902 static void lan78xx_irq_bus_lock(struct irq_data *irqd)
1904 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1906 mutex_lock(&data->irq_lock);
1909 static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
1911 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1912 struct lan78xx_net *dev =
1913 container_of(data, struct lan78xx_net, domain_data);
1916 /* call register access here because irq_bus_lock & irq_bus_sync_unlock
1917 * are only two callbacks executed in non-atomic contex.
1919 lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1920 if (buf != data->irqenable)
1921 lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
1923 mutex_unlock(&data->irq_lock);
1926 static struct irq_chip lan78xx_irqchip = {
1927 .name = "lan78xx-irqs",
1928 .irq_mask = lan78xx_irq_mask,
1929 .irq_unmask = lan78xx_irq_unmask,
1930 .irq_bus_lock = lan78xx_irq_bus_lock,
1931 .irq_bus_sync_unlock = lan78xx_irq_bus_sync_unlock,
1934 static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
1936 struct device_node *of_node;
1937 struct irq_domain *irqdomain;
1938 unsigned int irqmap = 0;
1942 of_node = dev->udev->dev.parent->of_node;
1944 mutex_init(&dev->domain_data.irq_lock);
1946 lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1947 dev->domain_data.irqenable = buf;
1949 dev->domain_data.irqchip = &lan78xx_irqchip;
1950 dev->domain_data.irq_handler = handle_simple_irq;
1952 irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,
1953 &chip_domain_ops, &dev->domain_data);
1955 /* create mapping for PHY interrupt */
1956 irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);
1958 irq_domain_remove(irqdomain);
1967 dev->domain_data.irqdomain = irqdomain;
1968 dev->domain_data.phyirq = irqmap;
1973 static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
1975 if (dev->domain_data.phyirq > 0) {
1976 irq_dispose_mapping(dev->domain_data.phyirq);
1978 if (dev->domain_data.irqdomain)
1979 irq_domain_remove(dev->domain_data.irqdomain);
1981 dev->domain_data.phyirq = 0;
1982 dev->domain_data.irqdomain = NULL;
1985 static int lan8835_fixup(struct phy_device *phydev)
1988 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
1990 /* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */
1991 buf = phy_read_mmd(phydev, MDIO_MMD_PCS, 0x8010);
1994 phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf);
1996 /* RGMII MAC TXC Delay Enable */
1997 lan78xx_write_reg(dev, MAC_RGMII_ID,
1998 MAC_RGMII_ID_TXC_DELAY_EN_);
2000 /* RGMII TX DLL Tune Adjust */
2001 lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2003 dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
2008 static int ksz9031rnx_fixup(struct phy_device *phydev)
2010 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2012 /* Micrel9301RNX PHY configuration */
2013 /* RGMII Control Signal Pad Skew */
2014 phy_write_mmd(phydev, MDIO_MMD_WIS, 4, 0x0077);
2015 /* RGMII RX Data Pad Skew */
2016 phy_write_mmd(phydev, MDIO_MMD_WIS, 5, 0x7777);
2017 /* RGMII RX Clock Pad Skew */
2018 phy_write_mmd(phydev, MDIO_MMD_WIS, 8, 0x1FF);
2020 dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;
2025 static struct phy_device *lan7801_phy_init(struct lan78xx_net *dev)
2029 struct fixed_phy_status fphy_status = {
2031 .speed = SPEED_1000,
2032 .duplex = DUPLEX_FULL,
2034 struct phy_device *phydev;
2036 phydev = phy_find_first(dev->mdiobus);
2038 netdev_dbg(dev->net, "PHY Not Found!! Registering Fixed PHY\n");
2039 phydev = fixed_phy_register(PHY_POLL, &fphy_status, NULL);
2040 if (IS_ERR(phydev)) {
2041 netdev_err(dev->net, "No PHY/fixed_PHY found\n");
2044 netdev_dbg(dev->net, "Registered FIXED PHY\n");
2045 dev->interface = PHY_INTERFACE_MODE_RGMII;
2046 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
2047 MAC_RGMII_ID_TXC_DELAY_EN_);
2048 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2049 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2050 buf |= HW_CFG_CLK125_EN_;
2051 buf |= HW_CFG_REFCLK25_EN_;
2052 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2055 netdev_err(dev->net, "no PHY driver found\n");
2058 dev->interface = PHY_INTERFACE_MODE_RGMII;
2059 /* external PHY fixup for KSZ9031RNX */
2060 ret = phy_register_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0,
2063 netdev_err(dev->net, "Failed to register fixup for PHY_KSZ9031RNX\n");
2066 /* external PHY fixup for LAN8835 */
2067 ret = phy_register_fixup_for_uid(PHY_LAN8835, 0xfffffff0,
2070 netdev_err(dev->net, "Failed to register fixup for PHY_LAN8835\n");
2073 /* add more external PHY fixup here if needed */
2075 phydev->is_internal = false;
2080 static int lan78xx_phy_init(struct lan78xx_net *dev)
2082 __ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
2085 struct phy_device *phydev;
2087 switch (dev->chipid) {
2088 case ID_REV_CHIP_ID_7801_:
2089 phydev = lan7801_phy_init(dev);
2091 netdev_err(dev->net, "lan7801: PHY Init Failed");
2096 case ID_REV_CHIP_ID_7800_:
2097 case ID_REV_CHIP_ID_7850_:
2098 phydev = phy_find_first(dev->mdiobus);
2100 netdev_err(dev->net, "no PHY found\n");
2103 phydev->is_internal = true;
2104 dev->interface = PHY_INTERFACE_MODE_GMII;
2108 netdev_err(dev->net, "Unknown CHIP ID found\n");
2112 /* if phyirq is not set, use polling mode in phylib */
2113 if (dev->domain_data.phyirq > 0)
2114 phydev->irq = dev->domain_data.phyirq;
2117 netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2119 /* set to AUTOMDIX */
2120 phydev->mdix = ETH_TP_MDI_AUTO;
2122 ret = phy_connect_direct(dev->net, phydev,
2123 lan78xx_link_status_change,
2126 netdev_err(dev->net, "can't attach PHY to %s\n",
2128 if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2129 if (phy_is_pseudo_fixed_link(phydev)) {
2130 fixed_phy_unregister(phydev);
2132 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX,
2134 phy_unregister_fixup_for_uid(PHY_LAN8835,
2141 /* MAC doesn't support 1000T Half */
2142 phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
2144 /* support both flow controls */
2145 dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2146 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2147 phydev->advertising);
2148 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2149 phydev->advertising);
2150 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2151 mii_adv_to_linkmode_adv_t(fc, mii_adv);
2152 linkmode_or(phydev->advertising, fc, phydev->advertising);
2154 if (phydev->mdio.dev.of_node) {
2158 len = of_property_count_elems_of_size(phydev->mdio.dev.of_node,
2159 "microchip,led-modes",
2162 /* Ensure the appropriate LEDs are enabled */
2163 lan78xx_read_reg(dev, HW_CFG, ®);
2164 reg &= ~(HW_CFG_LED0_EN_ |
2168 reg |= (len > 0) * HW_CFG_LED0_EN_ |
2169 (len > 1) * HW_CFG_LED1_EN_ |
2170 (len > 2) * HW_CFG_LED2_EN_ |
2171 (len > 3) * HW_CFG_LED3_EN_;
2172 lan78xx_write_reg(dev, HW_CFG, reg);
2176 genphy_config_aneg(phydev);
2178 dev->fc_autoneg = phydev->autoneg;
2183 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2188 lan78xx_read_reg(dev, MAC_RX, &buf);
2190 rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2193 buf &= ~MAC_RX_RXEN_;
2194 lan78xx_write_reg(dev, MAC_RX, buf);
2197 /* add 4 to size for FCS */
2198 buf &= ~MAC_RX_MAX_SIZE_MASK_;
2199 buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2201 lan78xx_write_reg(dev, MAC_RX, buf);
2204 buf |= MAC_RX_RXEN_;
2205 lan78xx_write_reg(dev, MAC_RX, buf);
2211 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2213 struct sk_buff *skb;
2214 unsigned long flags;
2217 spin_lock_irqsave(&q->lock, flags);
2218 while (!skb_queue_empty(q)) {
2219 struct skb_data *entry;
2223 skb_queue_walk(q, skb) {
2224 entry = (struct skb_data *)skb->cb;
2225 if (entry->state != unlink_start)
2230 entry->state = unlink_start;
2233 /* Get reference count of the URB to avoid it to be
2234 * freed during usb_unlink_urb, which may trigger
2235 * use-after-free problem inside usb_unlink_urb since
2236 * usb_unlink_urb is always racing with .complete
2237 * handler(include defer_bh).
2240 spin_unlock_irqrestore(&q->lock, flags);
2241 /* during some PM-driven resume scenarios,
2242 * these (async) unlinks complete immediately
2244 ret = usb_unlink_urb(urb);
2245 if (ret != -EINPROGRESS && ret != 0)
2246 netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2250 spin_lock_irqsave(&q->lock, flags);
2252 spin_unlock_irqrestore(&q->lock, flags);
2256 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2258 struct lan78xx_net *dev = netdev_priv(netdev);
2259 int ll_mtu = new_mtu + netdev->hard_header_len;
2260 int old_hard_mtu = dev->hard_mtu;
2261 int old_rx_urb_size = dev->rx_urb_size;
2263 /* no second zero-length packet read wanted after mtu-sized packets */
2264 if ((ll_mtu % dev->maxpacket) == 0)
2267 lan78xx_set_rx_max_frame_length(dev, new_mtu + VLAN_ETH_HLEN);
2269 netdev->mtu = new_mtu;
2271 dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
2272 if (dev->rx_urb_size == old_hard_mtu) {
2273 dev->rx_urb_size = dev->hard_mtu;
2274 if (dev->rx_urb_size > old_rx_urb_size) {
2275 if (netif_running(dev->net)) {
2276 unlink_urbs(dev, &dev->rxq);
2277 tasklet_schedule(&dev->bh);
2285 static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2287 struct lan78xx_net *dev = netdev_priv(netdev);
2288 struct sockaddr *addr = p;
2289 u32 addr_lo, addr_hi;
2291 if (netif_running(netdev))
2294 if (!is_valid_ether_addr(addr->sa_data))
2295 return -EADDRNOTAVAIL;
2297 ether_addr_copy(netdev->dev_addr, addr->sa_data);
2299 addr_lo = netdev->dev_addr[0] |
2300 netdev->dev_addr[1] << 8 |
2301 netdev->dev_addr[2] << 16 |
2302 netdev->dev_addr[3] << 24;
2303 addr_hi = netdev->dev_addr[4] |
2304 netdev->dev_addr[5] << 8;
2306 lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2307 lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2309 /* Added to support MAC address changes */
2310 lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2311 lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2316 /* Enable or disable Rx checksum offload engine */
2317 static int lan78xx_set_features(struct net_device *netdev,
2318 netdev_features_t features)
2320 struct lan78xx_net *dev = netdev_priv(netdev);
2321 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2322 unsigned long flags;
2324 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2326 if (features & NETIF_F_RXCSUM) {
2327 pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
2328 pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
2330 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2331 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2334 if (features & NETIF_F_HW_VLAN_CTAG_RX)
2335 pdata->rfe_ctl |= RFE_CTL_VLAN_STRIP_;
2337 pdata->rfe_ctl &= ~RFE_CTL_VLAN_STRIP_;
2339 if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
2340 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2342 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2344 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2346 lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2351 static void lan78xx_deferred_vlan_write(struct work_struct *param)
2353 struct lan78xx_priv *pdata =
2354 container_of(param, struct lan78xx_priv, set_vlan);
2355 struct lan78xx_net *dev = pdata->dev;
2357 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2358 DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2361 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2362 __be16 proto, u16 vid)
2364 struct lan78xx_net *dev = netdev_priv(netdev);
2365 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2367 u16 vid_dword_index;
2369 vid_dword_index = (vid >> 5) & 0x7F;
2370 vid_bit_index = vid & 0x1F;
2372 pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2374 /* defer register writes to a sleepable context */
2375 schedule_work(&pdata->set_vlan);
2380 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2381 __be16 proto, u16 vid)
2383 struct lan78xx_net *dev = netdev_priv(netdev);
2384 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2386 u16 vid_dword_index;
2388 vid_dword_index = (vid >> 5) & 0x7F;
2389 vid_bit_index = vid & 0x1F;
2391 pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2393 /* defer register writes to a sleepable context */
2394 schedule_work(&pdata->set_vlan);
2399 static void lan78xx_init_ltm(struct lan78xx_net *dev)
2403 u32 regs[6] = { 0 };
2405 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2406 if (buf & USB_CFG1_LTM_ENABLE_) {
2408 /* Get values from EEPROM first */
2409 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2410 if (temp[0] == 24) {
2411 ret = lan78xx_read_raw_eeprom(dev,
2418 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2419 if (temp[0] == 24) {
2420 ret = lan78xx_read_raw_otp(dev,
2430 lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2431 lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2432 lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2433 lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2434 lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2435 lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2438 static int lan78xx_reset(struct lan78xx_net *dev)
2440 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2443 unsigned long timeout;
2446 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2447 buf |= HW_CFG_LRST_;
2448 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2450 timeout = jiffies + HZ;
2453 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2454 if (time_after(jiffies, timeout)) {
2455 netdev_warn(dev->net,
2456 "timeout on completion of LiteReset");
2459 } while (buf & HW_CFG_LRST_);
2461 lan78xx_init_mac_address(dev);
2463 /* save DEVID for later usage */
2464 ret = lan78xx_read_reg(dev, ID_REV, &buf);
2465 dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2466 dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2468 /* Respond to the IN token with a NAK */
2469 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2470 buf |= USB_CFG_BIR_;
2471 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2474 lan78xx_init_ltm(dev);
2476 if (dev->udev->speed == USB_SPEED_SUPER) {
2477 buf = DEFAULT_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2478 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2481 } else if (dev->udev->speed == USB_SPEED_HIGH) {
2482 buf = DEFAULT_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2483 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2484 dev->rx_qlen = RX_MAX_QUEUE_MEMORY / dev->rx_urb_size;
2485 dev->tx_qlen = RX_MAX_QUEUE_MEMORY / dev->hard_mtu;
2487 buf = DEFAULT_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2488 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2493 ret = lan78xx_write_reg(dev, BURST_CAP, buf);
2494 ret = lan78xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
2496 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2498 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2500 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2501 buf |= USB_CFG_BCE_;
2502 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2504 /* set FIFO sizes */
2505 buf = (MAX_RX_FIFO_SIZE - 512) / 512;
2506 ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2508 buf = (MAX_TX_FIFO_SIZE - 512) / 512;
2509 ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2511 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2512 ret = lan78xx_write_reg(dev, FLOW, 0);
2513 ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2515 /* Don't need rfe_ctl_lock during initialisation */
2516 ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2517 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
2518 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2520 /* Enable or disable checksum offload engines */
2521 lan78xx_set_features(dev->net, dev->net->features);
2523 lan78xx_set_multicast(dev->net);
2526 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2527 buf |= PMT_CTL_PHY_RST_;
2528 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
2530 timeout = jiffies + HZ;
2533 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2534 if (time_after(jiffies, timeout)) {
2535 netdev_warn(dev->net, "timeout waiting for PHY Reset");
2538 } while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
2540 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
2541 /* LAN7801 only has RGMII mode */
2542 if (dev->chipid == ID_REV_CHIP_ID_7801_)
2543 buf &= ~MAC_CR_GMII_EN_;
2545 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
2546 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
2547 if (!ret && sig != EEPROM_INDICATOR) {
2548 /* Implies there is no external eeprom. Set mac speed */
2549 netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");
2550 buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
2553 ret = lan78xx_write_reg(dev, MAC_CR, buf);
2555 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
2556 buf |= MAC_TX_TXEN_;
2557 ret = lan78xx_write_reg(dev, MAC_TX, buf);
2559 ret = lan78xx_read_reg(dev, FCT_TX_CTL, &buf);
2560 buf |= FCT_TX_CTL_EN_;
2561 ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
2563 ret = lan78xx_set_rx_max_frame_length(dev,
2564 dev->net->mtu + VLAN_ETH_HLEN);
2566 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2567 buf |= MAC_RX_RXEN_;
2568 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2570 ret = lan78xx_read_reg(dev, FCT_RX_CTL, &buf);
2571 buf |= FCT_RX_CTL_EN_;
2572 ret = lan78xx_write_reg(dev, FCT_RX_CTL, buf);
2577 static void lan78xx_init_stats(struct lan78xx_net *dev)
2582 /* initialize for stats update
2583 * some counters are 20bits and some are 32bits
2585 p = (u32 *)&dev->stats.rollover_max;
2586 for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
2589 dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
2590 dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
2591 dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
2592 dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
2593 dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
2594 dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
2595 dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
2596 dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
2597 dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
2598 dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
2600 set_bit(EVENT_STAT_UPDATE, &dev->flags);
2603 static int lan78xx_open(struct net_device *net)
2605 struct lan78xx_net *dev = netdev_priv(net);
2608 ret = usb_autopm_get_interface(dev->intf);
2612 phy_start(net->phydev);
2614 netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
2616 /* for Link Check */
2617 if (dev->urb_intr) {
2618 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
2620 netif_err(dev, ifup, dev->net,
2621 "intr submit %d\n", ret);
2626 lan78xx_init_stats(dev);
2628 set_bit(EVENT_DEV_OPEN, &dev->flags);
2630 netif_start_queue(net);
2632 dev->link_on = false;
2634 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
2636 usb_autopm_put_interface(dev->intf);
2642 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
2644 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
2645 DECLARE_WAITQUEUE(wait, current);
2648 /* ensure there are no more active urbs */
2649 add_wait_queue(&unlink_wakeup, &wait);
2650 set_current_state(TASK_UNINTERRUPTIBLE);
2651 dev->wait = &unlink_wakeup;
2652 temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
2654 /* maybe wait for deletions to finish. */
2655 while (!skb_queue_empty(&dev->rxq) &&
2656 !skb_queue_empty(&dev->txq) &&
2657 !skb_queue_empty(&dev->done)) {
2658 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
2659 set_current_state(TASK_UNINTERRUPTIBLE);
2660 netif_dbg(dev, ifdown, dev->net,
2661 "waited for %d urb completions\n", temp);
2663 set_current_state(TASK_RUNNING);
2665 remove_wait_queue(&unlink_wakeup, &wait);
2668 static int lan78xx_stop(struct net_device *net)
2670 struct lan78xx_net *dev = netdev_priv(net);
2672 if (timer_pending(&dev->stat_monitor))
2673 del_timer_sync(&dev->stat_monitor);
2676 phy_stop(net->phydev);
2678 clear_bit(EVENT_DEV_OPEN, &dev->flags);
2679 netif_stop_queue(net);
2681 netif_info(dev, ifdown, dev->net,
2682 "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
2683 net->stats.rx_packets, net->stats.tx_packets,
2684 net->stats.rx_errors, net->stats.tx_errors);
2686 lan78xx_terminate_urbs(dev);
2688 usb_kill_urb(dev->urb_intr);
2690 skb_queue_purge(&dev->rxq_pause);
2692 /* deferred work (task, timer, softirq) must also stop.
2693 * can't flush_scheduled_work() until we drop rtnl (later),
2694 * else workers could deadlock; so make workers a NOP.
2697 cancel_delayed_work_sync(&dev->wq);
2698 tasklet_kill(&dev->bh);
2700 usb_autopm_put_interface(dev->intf);
2705 static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
2706 struct sk_buff *skb, gfp_t flags)
2708 u32 tx_cmd_a, tx_cmd_b;
2711 if (skb_cow_head(skb, TX_OVERHEAD)) {
2712 dev_kfree_skb_any(skb);
2716 if (skb_linearize(skb)) {
2717 dev_kfree_skb_any(skb);
2721 tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
2723 if (skb->ip_summed == CHECKSUM_PARTIAL)
2724 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
2727 if (skb_is_gso(skb)) {
2728 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
2730 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
2732 tx_cmd_a |= TX_CMD_A_LSO_;
2735 if (skb_vlan_tag_present(skb)) {
2736 tx_cmd_a |= TX_CMD_A_IVTG_;
2737 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
2740 ptr = skb_push(skb, 8);
2741 put_unaligned_le32(tx_cmd_a, ptr);
2742 put_unaligned_le32(tx_cmd_b, ptr + 4);
2747 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
2748 struct sk_buff_head *list, enum skb_state state)
2750 unsigned long flags;
2751 enum skb_state old_state;
2752 struct skb_data *entry = (struct skb_data *)skb->cb;
2754 spin_lock_irqsave(&list->lock, flags);
2755 old_state = entry->state;
2756 entry->state = state;
2758 __skb_unlink(skb, list);
2759 spin_unlock(&list->lock);
2760 spin_lock(&dev->done.lock);
2762 __skb_queue_tail(&dev->done, skb);
2763 if (skb_queue_len(&dev->done) == 1)
2764 tasklet_schedule(&dev->bh);
2765 spin_unlock_irqrestore(&dev->done.lock, flags);
2770 static void tx_complete(struct urb *urb)
2772 struct sk_buff *skb = (struct sk_buff *)urb->context;
2773 struct skb_data *entry = (struct skb_data *)skb->cb;
2774 struct lan78xx_net *dev = entry->dev;
2776 if (urb->status == 0) {
2777 dev->net->stats.tx_packets += entry->num_of_packet;
2778 dev->net->stats.tx_bytes += entry->length;
2780 dev->net->stats.tx_errors++;
2782 switch (urb->status) {
2784 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2787 /* software-driven interface shutdown */
2795 netif_stop_queue(dev->net);
2798 netif_dbg(dev, tx_err, dev->net,
2799 "tx err %d\n", entry->urb->status);
2804 usb_autopm_put_interface_async(dev->intf);
2806 defer_bh(dev, skb, &dev->txq, tx_done);
2809 static void lan78xx_queue_skb(struct sk_buff_head *list,
2810 struct sk_buff *newsk, enum skb_state state)
2812 struct skb_data *entry = (struct skb_data *)newsk->cb;
2814 __skb_queue_tail(list, newsk);
2815 entry->state = state;
2819 lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
2821 struct lan78xx_net *dev = netdev_priv(net);
2822 struct sk_buff *skb2 = NULL;
2825 skb_tx_timestamp(skb);
2826 skb2 = lan78xx_tx_prep(dev, skb, GFP_ATOMIC);
2830 skb_queue_tail(&dev->txq_pend, skb2);
2832 /* throttle TX patch at slower than SUPER SPEED USB */
2833 if ((dev->udev->speed < USB_SPEED_SUPER) &&
2834 (skb_queue_len(&dev->txq_pend) > 10))
2835 netif_stop_queue(net);
2837 netif_dbg(dev, tx_err, dev->net,
2838 "lan78xx_tx_prep return NULL\n");
2839 dev->net->stats.tx_errors++;
2840 dev->net->stats.tx_dropped++;
2843 tasklet_schedule(&dev->bh);
2845 return NETDEV_TX_OK;
2848 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
2850 struct lan78xx_priv *pdata = NULL;
2854 dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
2856 pdata = (struct lan78xx_priv *)(dev->data[0]);
2858 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
2864 spin_lock_init(&pdata->rfe_ctl_lock);
2865 mutex_init(&pdata->dataport_mutex);
2867 INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
2869 for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
2870 pdata->vlan_table[i] = 0;
2872 INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
2874 dev->net->features = 0;
2876 if (DEFAULT_TX_CSUM_ENABLE)
2877 dev->net->features |= NETIF_F_HW_CSUM;
2879 if (DEFAULT_RX_CSUM_ENABLE)
2880 dev->net->features |= NETIF_F_RXCSUM;
2882 if (DEFAULT_TSO_CSUM_ENABLE)
2883 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
2885 if (DEFAULT_VLAN_RX_OFFLOAD)
2886 dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX;
2888 if (DEFAULT_VLAN_FILTER_ENABLE)
2889 dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
2891 dev->net->hw_features = dev->net->features;
2893 ret = lan78xx_setup_irq_domain(dev);
2895 netdev_warn(dev->net,
2896 "lan78xx_setup_irq_domain() failed : %d", ret);
2900 dev->net->hard_header_len += TX_OVERHEAD;
2901 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
2903 /* Init all registers */
2904 ret = lan78xx_reset(dev);
2906 netdev_warn(dev->net, "Registers INIT FAILED....");
2910 ret = lan78xx_mdio_init(dev);
2912 netdev_warn(dev->net, "MDIO INIT FAILED.....");
2916 dev->net->flags |= IFF_MULTICAST;
2918 pdata->wol = WAKE_MAGIC;
2923 lan78xx_remove_irq_domain(dev);
2926 netdev_warn(dev->net, "Bind routine FAILED");
2927 cancel_work_sync(&pdata->set_multicast);
2928 cancel_work_sync(&pdata->set_vlan);
2933 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
2935 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2937 lan78xx_remove_irq_domain(dev);
2939 lan78xx_remove_mdio(dev);
2942 cancel_work_sync(&pdata->set_multicast);
2943 cancel_work_sync(&pdata->set_vlan);
2944 netif_dbg(dev, ifdown, dev->net, "free pdata");
2951 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
2952 struct sk_buff *skb,
2953 u32 rx_cmd_a, u32 rx_cmd_b)
2955 /* HW Checksum offload appears to be flawed if used when not stripping
2956 * VLAN headers. Drop back to S/W checksums under these conditions.
2958 if (!(dev->net->features & NETIF_F_RXCSUM) ||
2959 unlikely(rx_cmd_a & RX_CMD_A_ICSM_) ||
2960 ((rx_cmd_a & RX_CMD_A_FVTG_) &&
2961 !(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) {
2962 skb->ip_summed = CHECKSUM_NONE;
2964 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
2965 skb->ip_summed = CHECKSUM_COMPLETE;
2969 static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev,
2970 struct sk_buff *skb,
2971 u32 rx_cmd_a, u32 rx_cmd_b)
2973 if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) &&
2974 (rx_cmd_a & RX_CMD_A_FVTG_))
2975 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
2976 (rx_cmd_b & 0xffff));
2979 static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
2983 if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
2984 skb_queue_tail(&dev->rxq_pause, skb);
2988 dev->net->stats.rx_packets++;
2989 dev->net->stats.rx_bytes += skb->len;
2991 skb->protocol = eth_type_trans(skb, dev->net);
2993 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
2994 skb->len + sizeof(struct ethhdr), skb->protocol);
2995 memset(skb->cb, 0, sizeof(struct skb_data));
2997 if (skb_defer_rx_timestamp(skb))
3000 status = netif_rx(skb);
3001 if (status != NET_RX_SUCCESS)
3002 netif_dbg(dev, rx_err, dev->net,
3003 "netif_rx status %d\n", status);
3006 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb)
3008 if (skb->len < dev->net->hard_header_len)
3011 while (skb->len > 0) {
3012 u32 rx_cmd_a, rx_cmd_b, align_count, size;
3014 struct sk_buff *skb2;
3015 unsigned char *packet;
3017 rx_cmd_a = get_unaligned_le32(skb->data);
3018 skb_pull(skb, sizeof(rx_cmd_a));
3020 rx_cmd_b = get_unaligned_le32(skb->data);
3021 skb_pull(skb, sizeof(rx_cmd_b));
3023 rx_cmd_c = get_unaligned_le16(skb->data);
3024 skb_pull(skb, sizeof(rx_cmd_c));
3028 /* get the packet length */
3029 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
3030 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
3032 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
3033 netif_dbg(dev, rx_err, dev->net,
3034 "Error rx_cmd_a=0x%08x", rx_cmd_a);
3036 /* last frame in this batch */
3037 if (skb->len == size) {
3038 lan78xx_rx_csum_offload(dev, skb,
3039 rx_cmd_a, rx_cmd_b);
3040 lan78xx_rx_vlan_offload(dev, skb,
3041 rx_cmd_a, rx_cmd_b);
3043 skb_trim(skb, skb->len - 4); /* remove fcs */
3044 skb->truesize = size + sizeof(struct sk_buff);
3049 skb2 = skb_clone(skb, GFP_ATOMIC);
3050 if (unlikely(!skb2)) {
3051 netdev_warn(dev->net, "Error allocating skb");
3056 skb2->data = packet;
3057 skb_set_tail_pointer(skb2, size);
3059 lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3060 lan78xx_rx_vlan_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3062 skb_trim(skb2, skb2->len - 4); /* remove fcs */
3063 skb2->truesize = size + sizeof(struct sk_buff);
3065 lan78xx_skb_return(dev, skb2);
3068 skb_pull(skb, size);
3070 /* padding bytes before the next frame starts */
3072 skb_pull(skb, align_count);
3078 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb)
3080 if (!lan78xx_rx(dev, skb)) {
3081 dev->net->stats.rx_errors++;
3086 lan78xx_skb_return(dev, skb);
3090 netif_dbg(dev, rx_err, dev->net, "drop\n");
3091 dev->net->stats.rx_errors++;
3093 skb_queue_tail(&dev->done, skb);
3096 static void rx_complete(struct urb *urb);
3098 static int rx_submit(struct lan78xx_net *dev, struct urb *urb, gfp_t flags)
3100 struct sk_buff *skb;
3101 struct skb_data *entry;
3102 unsigned long lockflags;
3103 size_t size = dev->rx_urb_size;
3106 skb = netdev_alloc_skb_ip_align(dev->net, size);
3112 entry = (struct skb_data *)skb->cb;
3117 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3118 skb->data, size, rx_complete, skb);
3120 spin_lock_irqsave(&dev->rxq.lock, lockflags);
3122 if (netif_device_present(dev->net) &&
3123 netif_running(dev->net) &&
3124 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3125 !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3126 ret = usb_submit_urb(urb, GFP_ATOMIC);
3129 lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3132 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3135 netif_dbg(dev, ifdown, dev->net, "device gone\n");
3136 netif_device_detach(dev->net);
3142 netif_dbg(dev, rx_err, dev->net,
3143 "rx submit, %d\n", ret);
3144 tasklet_schedule(&dev->bh);
3147 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3150 spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3152 dev_kfree_skb_any(skb);
3158 static void rx_complete(struct urb *urb)
3160 struct sk_buff *skb = (struct sk_buff *)urb->context;
3161 struct skb_data *entry = (struct skb_data *)skb->cb;
3162 struct lan78xx_net *dev = entry->dev;
3163 int urb_status = urb->status;
3164 enum skb_state state;
3166 skb_put(skb, urb->actual_length);
3170 switch (urb_status) {
3172 if (skb->len < dev->net->hard_header_len) {
3174 dev->net->stats.rx_errors++;
3175 dev->net->stats.rx_length_errors++;
3176 netif_dbg(dev, rx_err, dev->net,
3177 "rx length %d\n", skb->len);
3179 usb_mark_last_busy(dev->udev);
3182 dev->net->stats.rx_errors++;
3183 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3185 case -ECONNRESET: /* async unlink */
3186 case -ESHUTDOWN: /* hardware gone */
3187 netif_dbg(dev, ifdown, dev->net,
3188 "rx shutdown, code %d\n", urb_status);
3196 dev->net->stats.rx_errors++;
3202 /* data overrun ... flush fifo? */
3204 dev->net->stats.rx_over_errors++;
3209 dev->net->stats.rx_errors++;
3210 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3214 state = defer_bh(dev, skb, &dev->rxq, state);
3217 if (netif_running(dev->net) &&
3218 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3219 state != unlink_start) {
3220 rx_submit(dev, urb, GFP_ATOMIC);
3225 netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
3228 static void lan78xx_tx_bh(struct lan78xx_net *dev)
3231 struct urb *urb = NULL;
3232 struct skb_data *entry;
3233 unsigned long flags;
3234 struct sk_buff_head *tqp = &dev->txq_pend;
3235 struct sk_buff *skb, *skb2;
3238 int skb_totallen, pkt_cnt;
3244 spin_lock_irqsave(&tqp->lock, flags);
3245 skb_queue_walk(tqp, skb) {
3246 if (skb_is_gso(skb)) {
3247 if (!skb_queue_is_first(tqp, skb)) {
3248 /* handle previous packets first */
3252 length = skb->len - TX_OVERHEAD;
3253 __skb_unlink(skb, tqp);
3254 spin_unlock_irqrestore(&tqp->lock, flags);
3258 if ((skb_totallen + skb->len) > MAX_SINGLE_PACKET_SIZE)
3260 skb_totallen = skb->len + roundup(skb_totallen, sizeof(u32));
3263 spin_unlock_irqrestore(&tqp->lock, flags);
3265 /* copy to a single skb */
3266 skb = alloc_skb(skb_totallen, GFP_ATOMIC);
3270 skb_put(skb, skb_totallen);
3272 for (count = pos = 0; count < pkt_cnt; count++) {
3273 skb2 = skb_dequeue(tqp);
3275 length += (skb2->len - TX_OVERHEAD);
3276 memcpy(skb->data + pos, skb2->data, skb2->len);
3277 pos += roundup(skb2->len, sizeof(u32));
3278 dev_kfree_skb(skb2);
3283 urb = usb_alloc_urb(0, GFP_ATOMIC);
3287 entry = (struct skb_data *)skb->cb;
3290 entry->length = length;
3291 entry->num_of_packet = count;
3293 spin_lock_irqsave(&dev->txq.lock, flags);
3294 ret = usb_autopm_get_interface_async(dev->intf);
3296 spin_unlock_irqrestore(&dev->txq.lock, flags);
3300 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_out,
3301 skb->data, skb->len, tx_complete, skb);
3303 if (length % dev->maxpacket == 0) {
3304 /* send USB_ZERO_PACKET */
3305 urb->transfer_flags |= URB_ZERO_PACKET;
3309 /* if this triggers the device is still a sleep */
3310 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3311 /* transmission will be done in resume */
3312 usb_anchor_urb(urb, &dev->deferred);
3313 /* no use to process more packets */
3314 netif_stop_queue(dev->net);
3316 spin_unlock_irqrestore(&dev->txq.lock, flags);
3317 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
3322 ret = usb_submit_urb(urb, GFP_ATOMIC);
3325 netif_trans_update(dev->net);
3326 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3327 if (skb_queue_len(&dev->txq) >= dev->tx_qlen)
3328 netif_stop_queue(dev->net);
3331 netif_stop_queue(dev->net);
3332 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3333 usb_autopm_put_interface_async(dev->intf);
3336 usb_autopm_put_interface_async(dev->intf);
3337 netif_dbg(dev, tx_err, dev->net,
3338 "tx: submit urb err %d\n", ret);
3342 spin_unlock_irqrestore(&dev->txq.lock, flags);
3345 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", ret);
3347 dev->net->stats.tx_dropped++;
3349 dev_kfree_skb_any(skb);
3352 netif_dbg(dev, tx_queued, dev->net,
3353 "> tx, len %d, type 0x%x\n", length, skb->protocol);
3356 static void lan78xx_rx_bh(struct lan78xx_net *dev)
3361 if (skb_queue_len(&dev->rxq) < dev->rx_qlen) {
3362 for (i = 0; i < 10; i++) {
3363 if (skb_queue_len(&dev->rxq) >= dev->rx_qlen)
3365 urb = usb_alloc_urb(0, GFP_ATOMIC);
3367 if (rx_submit(dev, urb, GFP_ATOMIC) == -ENOLINK)
3371 if (skb_queue_len(&dev->rxq) < dev->rx_qlen)
3372 tasklet_schedule(&dev->bh);
3374 if (skb_queue_len(&dev->txq) < dev->tx_qlen)
3375 netif_wake_queue(dev->net);
3378 static void lan78xx_bh(struct tasklet_struct *t)
3380 struct lan78xx_net *dev = from_tasklet(dev, t, bh);
3381 struct sk_buff *skb;
3382 struct skb_data *entry;
3384 while ((skb = skb_dequeue(&dev->done))) {
3385 entry = (struct skb_data *)(skb->cb);
3386 switch (entry->state) {
3388 entry->state = rx_cleanup;
3389 rx_process(dev, skb);
3392 usb_free_urb(entry->urb);
3396 usb_free_urb(entry->urb);
3400 netdev_dbg(dev->net, "skb state %d\n", entry->state);
3405 if (netif_device_present(dev->net) && netif_running(dev->net)) {
3406 /* reset update timer delta */
3407 if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
3409 mod_timer(&dev->stat_monitor,
3410 jiffies + STAT_UPDATE_TIMER);
3413 if (!skb_queue_empty(&dev->txq_pend))
3416 if (!timer_pending(&dev->delay) &&
3417 !test_bit(EVENT_RX_HALT, &dev->flags))
3422 static void lan78xx_delayedwork(struct work_struct *work)
3425 struct lan78xx_net *dev;
3427 dev = container_of(work, struct lan78xx_net, wq.work);
3429 if (test_bit(EVENT_TX_HALT, &dev->flags)) {
3430 unlink_urbs(dev, &dev->txq);
3431 status = usb_autopm_get_interface(dev->intf);
3434 status = usb_clear_halt(dev->udev, dev->pipe_out);
3435 usb_autopm_put_interface(dev->intf);
3438 status != -ESHUTDOWN) {
3439 if (netif_msg_tx_err(dev))
3441 netdev_err(dev->net,
3442 "can't clear tx halt, status %d\n",
3445 clear_bit(EVENT_TX_HALT, &dev->flags);
3446 if (status != -ESHUTDOWN)
3447 netif_wake_queue(dev->net);
3450 if (test_bit(EVENT_RX_HALT, &dev->flags)) {
3451 unlink_urbs(dev, &dev->rxq);
3452 status = usb_autopm_get_interface(dev->intf);
3455 status = usb_clear_halt(dev->udev, dev->pipe_in);
3456 usb_autopm_put_interface(dev->intf);
3459 status != -ESHUTDOWN) {
3460 if (netif_msg_rx_err(dev))
3462 netdev_err(dev->net,
3463 "can't clear rx halt, status %d\n",
3466 clear_bit(EVENT_RX_HALT, &dev->flags);
3467 tasklet_schedule(&dev->bh);
3471 if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
3474 clear_bit(EVENT_LINK_RESET, &dev->flags);
3475 status = usb_autopm_get_interface(dev->intf);
3478 if (lan78xx_link_reset(dev) < 0) {
3479 usb_autopm_put_interface(dev->intf);
3481 netdev_info(dev->net, "link reset failed (%d)\n",
3484 usb_autopm_put_interface(dev->intf);
3488 if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
3489 lan78xx_update_stats(dev);
3491 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3493 mod_timer(&dev->stat_monitor,
3494 jiffies + (STAT_UPDATE_TIMER * dev->delta));
3496 dev->delta = min((dev->delta * 2), 50);
3500 static void intr_complete(struct urb *urb)
3502 struct lan78xx_net *dev = urb->context;
3503 int status = urb->status;
3508 lan78xx_status(dev, urb);
3511 /* software-driven interface shutdown */
3512 case -ENOENT: /* urb killed */
3513 case -ESHUTDOWN: /* hardware gone */
3514 netif_dbg(dev, ifdown, dev->net,
3515 "intr shutdown, code %d\n", status);
3518 /* NOTE: not throttling like RX/TX, since this endpoint
3519 * already polls infrequently
3522 netdev_dbg(dev->net, "intr status %d\n", status);
3526 if (!netif_running(dev->net))
3529 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
3530 status = usb_submit_urb(urb, GFP_ATOMIC);
3532 netif_err(dev, timer, dev->net,
3533 "intr resubmit --> %d\n", status);
3536 static void lan78xx_disconnect(struct usb_interface *intf)
3538 struct lan78xx_net *dev;
3539 struct usb_device *udev;
3540 struct net_device *net;
3541 struct phy_device *phydev;
3543 dev = usb_get_intfdata(intf);
3544 usb_set_intfdata(intf, NULL);
3548 udev = interface_to_usbdev(intf);
3550 phydev = net->phydev;
3552 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
3553 phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
3555 phy_disconnect(net->phydev);
3557 if (phy_is_pseudo_fixed_link(phydev))
3558 fixed_phy_unregister(phydev);
3560 unregister_netdev(net);
3562 cancel_delayed_work_sync(&dev->wq);
3564 usb_scuttle_anchored_urbs(&dev->deferred);
3566 lan78xx_unbind(dev, intf);
3568 usb_kill_urb(dev->urb_intr);
3569 usb_free_urb(dev->urb_intr);
3575 static void lan78xx_tx_timeout(struct net_device *net, unsigned int txqueue)
3577 struct lan78xx_net *dev = netdev_priv(net);
3579 unlink_urbs(dev, &dev->txq);
3580 tasklet_schedule(&dev->bh);
3583 static netdev_features_t lan78xx_features_check(struct sk_buff *skb,
3584 struct net_device *netdev,
3585 netdev_features_t features)
3587 if (skb->len + TX_OVERHEAD > MAX_SINGLE_PACKET_SIZE)
3588 features &= ~NETIF_F_GSO_MASK;
3590 features = vlan_features_check(skb, features);
3591 features = vxlan_features_check(skb, features);
3596 static const struct net_device_ops lan78xx_netdev_ops = {
3597 .ndo_open = lan78xx_open,
3598 .ndo_stop = lan78xx_stop,
3599 .ndo_start_xmit = lan78xx_start_xmit,
3600 .ndo_tx_timeout = lan78xx_tx_timeout,
3601 .ndo_change_mtu = lan78xx_change_mtu,
3602 .ndo_set_mac_address = lan78xx_set_mac_addr,
3603 .ndo_validate_addr = eth_validate_addr,
3604 .ndo_do_ioctl = phy_do_ioctl_running,
3605 .ndo_set_rx_mode = lan78xx_set_multicast,
3606 .ndo_set_features = lan78xx_set_features,
3607 .ndo_vlan_rx_add_vid = lan78xx_vlan_rx_add_vid,
3608 .ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid,
3609 .ndo_features_check = lan78xx_features_check,
3612 static void lan78xx_stat_monitor(struct timer_list *t)
3614 struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
3616 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
3619 static int lan78xx_probe(struct usb_interface *intf,
3620 const struct usb_device_id *id)
3622 struct usb_host_endpoint *ep_blkin, *ep_blkout, *ep_intr;
3623 struct lan78xx_net *dev;
3624 struct net_device *netdev;
3625 struct usb_device *udev;
3631 udev = interface_to_usbdev(intf);
3632 udev = usb_get_dev(udev);
3634 netdev = alloc_etherdev(sizeof(struct lan78xx_net));
3636 dev_err(&intf->dev, "Error: OOM\n");
3641 /* netdev_printk() needs this */
3642 SET_NETDEV_DEV(netdev, &intf->dev);
3644 dev = netdev_priv(netdev);
3648 dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
3649 | NETIF_MSG_PROBE | NETIF_MSG_LINK);
3651 skb_queue_head_init(&dev->rxq);
3652 skb_queue_head_init(&dev->txq);
3653 skb_queue_head_init(&dev->done);
3654 skb_queue_head_init(&dev->rxq_pause);
3655 skb_queue_head_init(&dev->txq_pend);
3656 mutex_init(&dev->phy_mutex);
3658 tasklet_setup(&dev->bh, lan78xx_bh);
3659 INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
3660 init_usb_anchor(&dev->deferred);
3662 netdev->netdev_ops = &lan78xx_netdev_ops;
3663 netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
3664 netdev->ethtool_ops = &lan78xx_ethtool_ops;
3667 timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
3669 mutex_init(&dev->stats.access_lock);
3671 if (intf->cur_altsetting->desc.bNumEndpoints < 3) {
3676 dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
3677 ep_blkin = usb_pipe_endpoint(udev, dev->pipe_in);
3678 if (!ep_blkin || !usb_endpoint_is_bulk_in(&ep_blkin->desc)) {
3683 dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
3684 ep_blkout = usb_pipe_endpoint(udev, dev->pipe_out);
3685 if (!ep_blkout || !usb_endpoint_is_bulk_out(&ep_blkout->desc)) {
3690 ep_intr = &intf->cur_altsetting->endpoint[2];
3691 if (!usb_endpoint_is_int_in(&ep_intr->desc)) {
3696 dev->pipe_intr = usb_rcvintpipe(dev->udev,
3697 usb_endpoint_num(&ep_intr->desc));
3699 ret = lan78xx_bind(dev, intf);
3703 if (netdev->mtu > (dev->hard_mtu - netdev->hard_header_len))
3704 netdev->mtu = dev->hard_mtu - netdev->hard_header_len;
3706 /* MTU range: 68 - 9000 */
3707 netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
3708 netif_set_gso_max_size(netdev, MAX_SINGLE_PACKET_SIZE - MAX_HEADER);
3710 period = ep_intr->desc.bInterval;
3711 maxp = usb_maxpacket(dev->udev, dev->pipe_intr, 0);
3712 buf = kmalloc(maxp, GFP_KERNEL);
3714 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
3715 if (!dev->urb_intr) {
3720 usb_fill_int_urb(dev->urb_intr, dev->udev,
3721 dev->pipe_intr, buf, maxp,
3722 intr_complete, dev, period);
3723 dev->urb_intr->transfer_flags |= URB_FREE_BUFFER;
3727 dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out, 1);
3729 /* driver requires remote-wakeup capability during autosuspend. */
3730 intf->needs_remote_wakeup = 1;
3732 ret = lan78xx_phy_init(dev);
3736 ret = register_netdev(netdev);
3738 netif_err(dev, probe, netdev, "couldn't register the device\n");
3742 usb_set_intfdata(intf, dev);
3744 ret = device_set_wakeup_enable(&udev->dev, true);
3746 /* Default delay of 2sec has more overhead than advantage.
3747 * Set to 10sec as default.
3749 pm_runtime_set_autosuspend_delay(&udev->dev,
3750 DEFAULT_AUTOSUSPEND_DELAY);
3755 phy_disconnect(netdev->phydev);
3757 usb_free_urb(dev->urb_intr);
3759 lan78xx_unbind(dev, intf);
3761 free_netdev(netdev);
3768 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
3770 const u16 crc16poly = 0x8005;
3776 for (i = 0; i < len; i++) {
3778 for (bit = 0; bit < 8; bit++) {
3782 if (msb ^ (u16)(data & 1)) {
3784 crc |= (u16)0x0001U;
3793 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
3800 const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
3801 const u8 ipv6_multicast[3] = { 0x33, 0x33 };
3802 const u8 arp_type[2] = { 0x08, 0x06 };
3804 lan78xx_read_reg(dev, MAC_TX, &buf);
3805 buf &= ~MAC_TX_TXEN_;
3806 lan78xx_write_reg(dev, MAC_TX, buf);
3807 lan78xx_read_reg(dev, MAC_RX, &buf);
3808 buf &= ~MAC_RX_RXEN_;
3809 lan78xx_write_reg(dev, MAC_RX, buf);
3811 lan78xx_write_reg(dev, WUCSR, 0);
3812 lan78xx_write_reg(dev, WUCSR2, 0);
3813 lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3818 lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
3819 temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
3820 temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
3822 for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
3823 lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
3826 if (wol & WAKE_PHY) {
3827 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
3829 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3830 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3831 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3833 if (wol & WAKE_MAGIC) {
3834 temp_wucsr |= WUCSR_MPEN_;
3836 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3837 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3838 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
3840 if (wol & WAKE_BCAST) {
3841 temp_wucsr |= WUCSR_BCST_EN_;
3843 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3844 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3845 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3847 if (wol & WAKE_MCAST) {
3848 temp_wucsr |= WUCSR_WAKE_EN_;
3850 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
3851 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
3852 lan78xx_write_reg(dev, WUF_CFG(mask_index),
3854 WUF_CFGX_TYPE_MCAST_ |
3855 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3856 (crc & WUF_CFGX_CRC16_MASK_));
3858 lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
3859 lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3860 lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3861 lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3864 /* for IPv6 Multicast */
3865 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
3866 lan78xx_write_reg(dev, WUF_CFG(mask_index),
3868 WUF_CFGX_TYPE_MCAST_ |
3869 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3870 (crc & WUF_CFGX_CRC16_MASK_));
3872 lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
3873 lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3874 lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3875 lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3878 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3879 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3880 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3882 if (wol & WAKE_UCAST) {
3883 temp_wucsr |= WUCSR_PFDA_EN_;
3885 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3886 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3887 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3889 if (wol & WAKE_ARP) {
3890 temp_wucsr |= WUCSR_WAKE_EN_;
3892 /* set WUF_CFG & WUF_MASK
3893 * for packettype (offset 12,13) = ARP (0x0806)
3895 crc = lan78xx_wakeframe_crc16(arp_type, 2);
3896 lan78xx_write_reg(dev, WUF_CFG(mask_index),
3898 WUF_CFGX_TYPE_ALL_ |
3899 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3900 (crc & WUF_CFGX_CRC16_MASK_));
3902 lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
3903 lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3904 lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3905 lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3908 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3909 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3910 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3913 lan78xx_write_reg(dev, WUCSR, temp_wucsr);
3915 /* when multiple WOL bits are set */
3916 if (hweight_long((unsigned long)wol) > 1) {
3917 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3918 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3919 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3921 lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
3924 lan78xx_read_reg(dev, PMT_CTL, &buf);
3925 buf |= PMT_CTL_WUPS_MASK_;
3926 lan78xx_write_reg(dev, PMT_CTL, buf);
3928 lan78xx_read_reg(dev, MAC_RX, &buf);
3929 buf |= MAC_RX_RXEN_;
3930 lan78xx_write_reg(dev, MAC_RX, buf);
3935 static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
3937 struct lan78xx_net *dev = usb_get_intfdata(intf);
3938 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3942 if (!dev->suspend_count++) {
3943 spin_lock_irq(&dev->txq.lock);
3944 /* don't autosuspend while transmitting */
3945 if ((skb_queue_len(&dev->txq) ||
3946 skb_queue_len(&dev->txq_pend)) &&
3947 PMSG_IS_AUTO(message)) {
3948 spin_unlock_irq(&dev->txq.lock);
3952 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
3953 spin_unlock_irq(&dev->txq.lock);
3957 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3958 buf &= ~MAC_TX_TXEN_;
3959 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3960 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3961 buf &= ~MAC_RX_RXEN_;
3962 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3964 /* empty out the rx and queues */
3965 netif_device_detach(dev->net);
3966 lan78xx_terminate_urbs(dev);
3967 usb_kill_urb(dev->urb_intr);
3970 netif_device_attach(dev->net);
3973 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3974 del_timer(&dev->stat_monitor);
3976 if (PMSG_IS_AUTO(message)) {
3977 /* auto suspend (selective suspend) */
3978 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3979 buf &= ~MAC_TX_TXEN_;
3980 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3981 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3982 buf &= ~MAC_RX_RXEN_;
3983 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3985 ret = lan78xx_write_reg(dev, WUCSR, 0);
3986 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3987 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3989 /* set goodframe wakeup */
3990 ret = lan78xx_read_reg(dev, WUCSR, &buf);
3992 buf |= WUCSR_RFE_WAKE_EN_;
3993 buf |= WUCSR_STORE_WAKE_;
3995 ret = lan78xx_write_reg(dev, WUCSR, buf);
3997 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3999 buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4000 buf |= PMT_CTL_RES_CLR_WKP_STS_;
4002 buf |= PMT_CTL_PHY_WAKE_EN_;
4003 buf |= PMT_CTL_WOL_EN_;
4004 buf &= ~PMT_CTL_SUS_MODE_MASK_;
4005 buf |= PMT_CTL_SUS_MODE_3_;
4007 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4009 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4011 buf |= PMT_CTL_WUPS_MASK_;
4013 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4015 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
4016 buf |= MAC_RX_RXEN_;
4017 ret = lan78xx_write_reg(dev, MAC_RX, buf);
4019 lan78xx_set_suspend(dev, pdata->wol);
4028 static int lan78xx_resume(struct usb_interface *intf)
4030 struct lan78xx_net *dev = usb_get_intfdata(intf);
4031 struct sk_buff *skb;
4036 if (!timer_pending(&dev->stat_monitor)) {
4038 mod_timer(&dev->stat_monitor,
4039 jiffies + STAT_UPDATE_TIMER);
4042 if (!--dev->suspend_count) {
4043 /* resume interrupt URBs */
4044 if (dev->urb_intr && test_bit(EVENT_DEV_OPEN, &dev->flags))
4045 usb_submit_urb(dev->urb_intr, GFP_NOIO);
4047 spin_lock_irq(&dev->txq.lock);
4048 while ((res = usb_get_from_anchor(&dev->deferred))) {
4049 skb = (struct sk_buff *)res->context;
4050 ret = usb_submit_urb(res, GFP_ATOMIC);
4052 dev_kfree_skb_any(skb);
4054 usb_autopm_put_interface_async(dev->intf);
4056 netif_trans_update(dev->net);
4057 lan78xx_queue_skb(&dev->txq, skb, tx_start);
4061 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4062 spin_unlock_irq(&dev->txq.lock);
4064 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
4065 if (!(skb_queue_len(&dev->txq) >= dev->tx_qlen))
4066 netif_start_queue(dev->net);
4067 tasklet_schedule(&dev->bh);
4071 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4072 ret = lan78xx_write_reg(dev, WUCSR, 0);
4073 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4075 ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
4077 WUCSR2_IPV6_TCPSYN_RCD_ |
4078 WUCSR2_IPV4_TCPSYN_RCD_);
4080 ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
4081 WUCSR_EEE_RX_WAKE_ |
4083 WUCSR_RFE_WAKE_FR_ |
4088 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
4089 buf |= MAC_TX_TXEN_;
4090 ret = lan78xx_write_reg(dev, MAC_TX, buf);
4095 static int lan78xx_reset_resume(struct usb_interface *intf)
4097 struct lan78xx_net *dev = usb_get_intfdata(intf);
4101 phy_start(dev->net->phydev);
4103 return lan78xx_resume(intf);
4106 static const struct usb_device_id products[] = {
4108 /* LAN7800 USB Gigabit Ethernet Device */
4109 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
4112 /* LAN7850 USB Gigabit Ethernet Device */
4113 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
4116 /* LAN7801 USB Gigabit Ethernet Device */
4117 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
4121 MODULE_DEVICE_TABLE(usb, products);
4123 static struct usb_driver lan78xx_driver = {
4124 .name = DRIVER_NAME,
4125 .id_table = products,
4126 .probe = lan78xx_probe,
4127 .disconnect = lan78xx_disconnect,
4128 .suspend = lan78xx_suspend,
4129 .resume = lan78xx_resume,
4130 .reset_resume = lan78xx_reset_resume,
4131 .supports_autosuspend = 1,
4132 .disable_hub_initiated_lpm = 1,
4135 module_usb_driver(lan78xx_driver);
4137 MODULE_AUTHOR(DRIVER_AUTHOR);
4138 MODULE_DESCRIPTION(DRIVER_DESC);
4139 MODULE_LICENSE("GPL");