2 * Copyright (C) 2015 Microchip Technology
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
17 #include <linux/version.h>
18 #include <linux/module.h>
19 #include <linux/netdevice.h>
20 #include <linux/etherdevice.h>
21 #include <linux/ethtool.h>
22 #include <linux/usb.h>
23 #include <linux/crc32.h>
24 #include <linux/signal.h>
25 #include <linux/slab.h>
26 #include <linux/if_vlan.h>
27 #include <linux/uaccess.h>
28 #include <linux/list.h>
30 #include <linux/ipv6.h>
31 #include <linux/mdio.h>
32 #include <net/ip6_checksum.h>
33 #include <linux/interrupt.h>
34 #include <linux/irqdomain.h>
35 #include <linux/irq.h>
36 #include <linux/irqchip/chained_irq.h>
37 #include <linux/microchipphy.h>
38 #include <linux/phy.h>
41 #define DRIVER_AUTHOR "WOOJUNG HUH <woojung.huh@microchip.com>"
42 #define DRIVER_DESC "LAN78XX USB 3.0 Gigabit Ethernet Devices"
43 #define DRIVER_NAME "lan78xx"
44 #define DRIVER_VERSION "1.0.6"
46 #define TX_TIMEOUT_JIFFIES (5 * HZ)
47 #define THROTTLE_JIFFIES (HZ / 8)
48 #define UNLINK_TIMEOUT_MS 3
50 #define RX_MAX_QUEUE_MEMORY (60 * 1518)
52 #define SS_USB_PKT_SIZE (1024)
53 #define HS_USB_PKT_SIZE (512)
54 #define FS_USB_PKT_SIZE (64)
56 #define MAX_RX_FIFO_SIZE (12 * 1024)
57 #define MAX_TX_FIFO_SIZE (12 * 1024)
58 #define DEFAULT_BURST_CAP_SIZE (MAX_TX_FIFO_SIZE)
59 #define DEFAULT_BULK_IN_DELAY (0x0800)
60 #define MAX_SINGLE_PACKET_SIZE (9000)
61 #define DEFAULT_TX_CSUM_ENABLE (true)
62 #define DEFAULT_RX_CSUM_ENABLE (true)
63 #define DEFAULT_TSO_CSUM_ENABLE (true)
64 #define DEFAULT_VLAN_FILTER_ENABLE (true)
65 #define TX_OVERHEAD (8)
68 #define LAN78XX_USB_VENDOR_ID (0x0424)
69 #define LAN7800_USB_PRODUCT_ID (0x7800)
70 #define LAN7850_USB_PRODUCT_ID (0x7850)
71 #define LAN7801_USB_PRODUCT_ID (0x7801)
72 #define LAN78XX_EEPROM_MAGIC (0x78A5)
73 #define LAN78XX_OTP_MAGIC (0x78F3)
78 #define EEPROM_INDICATOR (0xA5)
79 #define EEPROM_MAC_OFFSET (0x01)
80 #define MAX_EEPROM_SIZE 512
81 #define OTP_INDICATOR_1 (0xF3)
82 #define OTP_INDICATOR_2 (0xF7)
84 #define WAKE_ALL (WAKE_PHY | WAKE_UCAST | \
85 WAKE_MCAST | WAKE_BCAST | \
86 WAKE_ARP | WAKE_MAGIC)
88 /* USB related defines */
89 #define BULK_IN_PIPE 1
90 #define BULK_OUT_PIPE 2
92 /* default autosuspend delay (mSec)*/
93 #define DEFAULT_AUTOSUSPEND_DELAY (10 * 1000)
95 /* statistic update interval (mSec) */
96 #define STAT_UPDATE_TIMER (1 * 1000)
98 /* defines interrupts from interrupt EP */
99 #define MAX_INT_EP (32)
100 #define INT_EP_INTEP (31)
101 #define INT_EP_OTP_WR_DONE (28)
102 #define INT_EP_EEE_TX_LPI_START (26)
103 #define INT_EP_EEE_TX_LPI_STOP (25)
104 #define INT_EP_EEE_RX_LPI (24)
105 #define INT_EP_MAC_RESET_TIMEOUT (23)
106 #define INT_EP_RDFO (22)
107 #define INT_EP_TXE (21)
108 #define INT_EP_USB_STATUS (20)
109 #define INT_EP_TX_DIS (19)
110 #define INT_EP_RX_DIS (18)
111 #define INT_EP_PHY (17)
112 #define INT_EP_DP (16)
113 #define INT_EP_MAC_ERR (15)
114 #define INT_EP_TDFU (14)
115 #define INT_EP_TDFO (13)
116 #define INT_EP_UTX (12)
117 #define INT_EP_GPIO_11 (11)
118 #define INT_EP_GPIO_10 (10)
119 #define INT_EP_GPIO_9 (9)
120 #define INT_EP_GPIO_8 (8)
121 #define INT_EP_GPIO_7 (7)
122 #define INT_EP_GPIO_6 (6)
123 #define INT_EP_GPIO_5 (5)
124 #define INT_EP_GPIO_4 (4)
125 #define INT_EP_GPIO_3 (3)
126 #define INT_EP_GPIO_2 (2)
127 #define INT_EP_GPIO_1 (1)
128 #define INT_EP_GPIO_0 (0)
130 static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {
132 "RX Alignment Errors",
133 "Rx Fragment Errors",
135 "RX Undersize Frame Errors",
136 "RX Oversize Frame Errors",
138 "RX Unicast Byte Count",
139 "RX Broadcast Byte Count",
140 "RX Multicast Byte Count",
142 "RX Broadcast Frames",
143 "RX Multicast Frames",
146 "RX 65 - 127 Byte Frames",
147 "RX 128 - 255 Byte Frames",
148 "RX 256 - 511 Bytes Frames",
149 "RX 512 - 1023 Byte Frames",
150 "RX 1024 - 1518 Byte Frames",
151 "RX Greater 1518 Byte Frames",
152 "EEE RX LPI Transitions",
155 "TX Excess Deferral Errors",
158 "TX Single Collisions",
159 "TX Multiple Collisions",
160 "TX Excessive Collision",
161 "TX Late Collisions",
162 "TX Unicast Byte Count",
163 "TX Broadcast Byte Count",
164 "TX Multicast Byte Count",
166 "TX Broadcast Frames",
167 "TX Multicast Frames",
170 "TX 65 - 127 Byte Frames",
171 "TX 128 - 255 Byte Frames",
172 "TX 256 - 511 Bytes Frames",
173 "TX 512 - 1023 Byte Frames",
174 "TX 1024 - 1518 Byte Frames",
175 "TX Greater 1518 Byte Frames",
176 "EEE TX LPI Transitions",
180 struct lan78xx_statstage {
182 u32 rx_alignment_errors;
183 u32 rx_fragment_errors;
184 u32 rx_jabber_errors;
185 u32 rx_undersize_frame_errors;
186 u32 rx_oversize_frame_errors;
187 u32 rx_dropped_frames;
188 u32 rx_unicast_byte_count;
189 u32 rx_broadcast_byte_count;
190 u32 rx_multicast_byte_count;
191 u32 rx_unicast_frames;
192 u32 rx_broadcast_frames;
193 u32 rx_multicast_frames;
195 u32 rx_64_byte_frames;
196 u32 rx_65_127_byte_frames;
197 u32 rx_128_255_byte_frames;
198 u32 rx_256_511_bytes_frames;
199 u32 rx_512_1023_byte_frames;
200 u32 rx_1024_1518_byte_frames;
201 u32 rx_greater_1518_byte_frames;
202 u32 eee_rx_lpi_transitions;
205 u32 tx_excess_deferral_errors;
206 u32 tx_carrier_errors;
207 u32 tx_bad_byte_count;
208 u32 tx_single_collisions;
209 u32 tx_multiple_collisions;
210 u32 tx_excessive_collision;
211 u32 tx_late_collisions;
212 u32 tx_unicast_byte_count;
213 u32 tx_broadcast_byte_count;
214 u32 tx_multicast_byte_count;
215 u32 tx_unicast_frames;
216 u32 tx_broadcast_frames;
217 u32 tx_multicast_frames;
219 u32 tx_64_byte_frames;
220 u32 tx_65_127_byte_frames;
221 u32 tx_128_255_byte_frames;
222 u32 tx_256_511_bytes_frames;
223 u32 tx_512_1023_byte_frames;
224 u32 tx_1024_1518_byte_frames;
225 u32 tx_greater_1518_byte_frames;
226 u32 eee_tx_lpi_transitions;
230 struct lan78xx_statstage64 {
232 u64 rx_alignment_errors;
233 u64 rx_fragment_errors;
234 u64 rx_jabber_errors;
235 u64 rx_undersize_frame_errors;
236 u64 rx_oversize_frame_errors;
237 u64 rx_dropped_frames;
238 u64 rx_unicast_byte_count;
239 u64 rx_broadcast_byte_count;
240 u64 rx_multicast_byte_count;
241 u64 rx_unicast_frames;
242 u64 rx_broadcast_frames;
243 u64 rx_multicast_frames;
245 u64 rx_64_byte_frames;
246 u64 rx_65_127_byte_frames;
247 u64 rx_128_255_byte_frames;
248 u64 rx_256_511_bytes_frames;
249 u64 rx_512_1023_byte_frames;
250 u64 rx_1024_1518_byte_frames;
251 u64 rx_greater_1518_byte_frames;
252 u64 eee_rx_lpi_transitions;
255 u64 tx_excess_deferral_errors;
256 u64 tx_carrier_errors;
257 u64 tx_bad_byte_count;
258 u64 tx_single_collisions;
259 u64 tx_multiple_collisions;
260 u64 tx_excessive_collision;
261 u64 tx_late_collisions;
262 u64 tx_unicast_byte_count;
263 u64 tx_broadcast_byte_count;
264 u64 tx_multicast_byte_count;
265 u64 tx_unicast_frames;
266 u64 tx_broadcast_frames;
267 u64 tx_multicast_frames;
269 u64 tx_64_byte_frames;
270 u64 tx_65_127_byte_frames;
271 u64 tx_128_255_byte_frames;
272 u64 tx_256_511_bytes_frames;
273 u64 tx_512_1023_byte_frames;
274 u64 tx_1024_1518_byte_frames;
275 u64 tx_greater_1518_byte_frames;
276 u64 eee_tx_lpi_transitions;
282 struct lan78xx_priv {
283 struct lan78xx_net *dev;
285 u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicat hash table */
286 u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */
287 u32 vlan_table[DP_SEL_VHF_VLAN_LEN];
288 struct mutex dataport_mutex; /* for dataport access */
289 spinlock_t rfe_ctl_lock; /* for rfe register access */
290 struct work_struct set_multicast;
291 struct work_struct set_vlan;
305 struct skb_data { /* skb->cb is one of these */
307 struct lan78xx_net *dev;
308 enum skb_state state;
314 struct usb_ctrlrequest req;
315 struct lan78xx_net *dev;
318 #define EVENT_TX_HALT 0
319 #define EVENT_RX_HALT 1
320 #define EVENT_RX_MEMORY 2
321 #define EVENT_STS_SPLIT 3
322 #define EVENT_LINK_RESET 4
323 #define EVENT_RX_PAUSED 5
324 #define EVENT_DEV_WAKING 6
325 #define EVENT_DEV_ASLEEP 7
326 #define EVENT_DEV_OPEN 8
327 #define EVENT_STAT_UPDATE 9
330 struct mutex access_lock; /* for stats access */
331 struct lan78xx_statstage saved;
332 struct lan78xx_statstage rollover_count;
333 struct lan78xx_statstage rollover_max;
334 struct lan78xx_statstage64 curr_stat;
337 struct irq_domain_data {
338 struct irq_domain *irqdomain;
340 struct irq_chip *irqchip;
341 irq_flow_handler_t irq_handler;
343 struct mutex irq_lock; /* for irq bus access */
347 struct net_device *net;
348 struct usb_device *udev;
349 struct usb_interface *intf;
354 struct sk_buff_head rxq;
355 struct sk_buff_head txq;
356 struct sk_buff_head done;
357 struct sk_buff_head rxq_pause;
358 struct sk_buff_head txq_pend;
360 struct tasklet_struct bh;
361 struct delayed_work wq;
363 struct usb_host_endpoint *ep_blkin;
364 struct usb_host_endpoint *ep_blkout;
365 struct usb_host_endpoint *ep_intr;
369 struct urb *urb_intr;
370 struct usb_anchor deferred;
372 struct mutex phy_mutex; /* for phy access */
373 unsigned pipe_in, pipe_out, pipe_intr;
375 u32 hard_mtu; /* count any extra framing */
376 size_t rx_urb_size; /* size for rx urbs */
380 wait_queue_head_t *wait;
381 unsigned char suspend_count;
384 struct timer_list delay;
385 struct timer_list stat_monitor;
387 unsigned long data[5];
394 struct mii_bus *mdiobus;
395 phy_interface_t interface;
398 u8 fc_request_control;
401 struct statstage stats;
403 struct irq_domain_data domain_data;
406 /* define external phy id */
407 #define PHY_LAN8835 (0x0007C130)
408 #define PHY_KSZ9031RNX (0x00221620)
410 /* use ethtool to change the level for any given device */
411 static int msg_level = -1;
412 module_param(msg_level, int, 0);
413 MODULE_PARM_DESC(msg_level, "Override default message level");
415 static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
417 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
423 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
424 USB_VENDOR_REQUEST_READ_REGISTER,
425 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
426 0, index, buf, 4, USB_CTRL_GET_TIMEOUT);
427 if (likely(ret >= 0)) {
431 netdev_warn(dev->net,
432 "Failed to read register index 0x%08x. ret = %d",
441 static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
443 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
452 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
453 USB_VENDOR_REQUEST_WRITE_REGISTER,
454 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
455 0, index, buf, 4, USB_CTRL_SET_TIMEOUT);
456 if (unlikely(ret < 0)) {
457 netdev_warn(dev->net,
458 "Failed to write register index 0x%08x. ret = %d",
467 static int lan78xx_read_stats(struct lan78xx_net *dev,
468 struct lan78xx_statstage *data)
472 struct lan78xx_statstage *stats;
476 stats = kmalloc(sizeof(*stats), GFP_KERNEL);
480 ret = usb_control_msg(dev->udev,
481 usb_rcvctrlpipe(dev->udev, 0),
482 USB_VENDOR_REQUEST_GET_STATS,
483 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
488 USB_CTRL_SET_TIMEOUT);
489 if (likely(ret >= 0)) {
492 for (i = 0; i < sizeof(*stats)/sizeof(u32); i++) {
493 le32_to_cpus(&src[i]);
497 netdev_warn(dev->net,
498 "Failed to read stat ret = 0x%x", ret);
506 #define check_counter_rollover(struct1, dev_stats, member) { \
507 if (struct1->member < dev_stats.saved.member) \
508 dev_stats.rollover_count.member++; \
511 static void lan78xx_check_stat_rollover(struct lan78xx_net *dev,
512 struct lan78xx_statstage *stats)
514 check_counter_rollover(stats, dev->stats, rx_fcs_errors);
515 check_counter_rollover(stats, dev->stats, rx_alignment_errors);
516 check_counter_rollover(stats, dev->stats, rx_fragment_errors);
517 check_counter_rollover(stats, dev->stats, rx_jabber_errors);
518 check_counter_rollover(stats, dev->stats, rx_undersize_frame_errors);
519 check_counter_rollover(stats, dev->stats, rx_oversize_frame_errors);
520 check_counter_rollover(stats, dev->stats, rx_dropped_frames);
521 check_counter_rollover(stats, dev->stats, rx_unicast_byte_count);
522 check_counter_rollover(stats, dev->stats, rx_broadcast_byte_count);
523 check_counter_rollover(stats, dev->stats, rx_multicast_byte_count);
524 check_counter_rollover(stats, dev->stats, rx_unicast_frames);
525 check_counter_rollover(stats, dev->stats, rx_broadcast_frames);
526 check_counter_rollover(stats, dev->stats, rx_multicast_frames);
527 check_counter_rollover(stats, dev->stats, rx_pause_frames);
528 check_counter_rollover(stats, dev->stats, rx_64_byte_frames);
529 check_counter_rollover(stats, dev->stats, rx_65_127_byte_frames);
530 check_counter_rollover(stats, dev->stats, rx_128_255_byte_frames);
531 check_counter_rollover(stats, dev->stats, rx_256_511_bytes_frames);
532 check_counter_rollover(stats, dev->stats, rx_512_1023_byte_frames);
533 check_counter_rollover(stats, dev->stats, rx_1024_1518_byte_frames);
534 check_counter_rollover(stats, dev->stats, rx_greater_1518_byte_frames);
535 check_counter_rollover(stats, dev->stats, eee_rx_lpi_transitions);
536 check_counter_rollover(stats, dev->stats, eee_rx_lpi_time);
537 check_counter_rollover(stats, dev->stats, tx_fcs_errors);
538 check_counter_rollover(stats, dev->stats, tx_excess_deferral_errors);
539 check_counter_rollover(stats, dev->stats, tx_carrier_errors);
540 check_counter_rollover(stats, dev->stats, tx_bad_byte_count);
541 check_counter_rollover(stats, dev->stats, tx_single_collisions);
542 check_counter_rollover(stats, dev->stats, tx_multiple_collisions);
543 check_counter_rollover(stats, dev->stats, tx_excessive_collision);
544 check_counter_rollover(stats, dev->stats, tx_late_collisions);
545 check_counter_rollover(stats, dev->stats, tx_unicast_byte_count);
546 check_counter_rollover(stats, dev->stats, tx_broadcast_byte_count);
547 check_counter_rollover(stats, dev->stats, tx_multicast_byte_count);
548 check_counter_rollover(stats, dev->stats, tx_unicast_frames);
549 check_counter_rollover(stats, dev->stats, tx_broadcast_frames);
550 check_counter_rollover(stats, dev->stats, tx_multicast_frames);
551 check_counter_rollover(stats, dev->stats, tx_pause_frames);
552 check_counter_rollover(stats, dev->stats, tx_64_byte_frames);
553 check_counter_rollover(stats, dev->stats, tx_65_127_byte_frames);
554 check_counter_rollover(stats, dev->stats, tx_128_255_byte_frames);
555 check_counter_rollover(stats, dev->stats, tx_256_511_bytes_frames);
556 check_counter_rollover(stats, dev->stats, tx_512_1023_byte_frames);
557 check_counter_rollover(stats, dev->stats, tx_1024_1518_byte_frames);
558 check_counter_rollover(stats, dev->stats, tx_greater_1518_byte_frames);
559 check_counter_rollover(stats, dev->stats, eee_tx_lpi_transitions);
560 check_counter_rollover(stats, dev->stats, eee_tx_lpi_time);
562 memcpy(&dev->stats.saved, stats, sizeof(struct lan78xx_statstage));
565 static void lan78xx_update_stats(struct lan78xx_net *dev)
567 u32 *p, *count, *max;
570 struct lan78xx_statstage lan78xx_stats;
572 if (usb_autopm_get_interface(dev->intf) < 0)
575 p = (u32 *)&lan78xx_stats;
576 count = (u32 *)&dev->stats.rollover_count;
577 max = (u32 *)&dev->stats.rollover_max;
578 data = (u64 *)&dev->stats.curr_stat;
580 mutex_lock(&dev->stats.access_lock);
582 if (lan78xx_read_stats(dev, &lan78xx_stats) > 0)
583 lan78xx_check_stat_rollover(dev, &lan78xx_stats);
585 for (i = 0; i < (sizeof(lan78xx_stats) / (sizeof(u32))); i++)
586 data[i] = (u64)p[i] + ((u64)count[i] * ((u64)max[i] + 1));
588 mutex_unlock(&dev->stats.access_lock);
590 usb_autopm_put_interface(dev->intf);
593 /* Loop until the read is completed with timeout called with phy_mutex held */
594 static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)
596 unsigned long start_time = jiffies;
601 ret = lan78xx_read_reg(dev, MII_ACC, &val);
602 if (unlikely(ret < 0))
605 if (!(val & MII_ACC_MII_BUSY_))
607 } while (!time_after(jiffies, start_time + HZ));
612 static inline u32 mii_access(int id, int index, int read)
616 ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;
617 ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;
619 ret |= MII_ACC_MII_READ_;
621 ret |= MII_ACC_MII_WRITE_;
622 ret |= MII_ACC_MII_BUSY_;
627 static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
629 unsigned long start_time = jiffies;
634 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
635 if (unlikely(ret < 0))
638 if (!(val & E2P_CMD_EPC_BUSY_) ||
639 (val & E2P_CMD_EPC_TIMEOUT_))
641 usleep_range(40, 100);
642 } while (!time_after(jiffies, start_time + HZ));
644 if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
645 netdev_warn(dev->net, "EEPROM read operation timeout");
652 static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
654 unsigned long start_time = jiffies;
659 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
660 if (unlikely(ret < 0))
663 if (!(val & E2P_CMD_EPC_BUSY_))
666 usleep_range(40, 100);
667 } while (!time_after(jiffies, start_time + HZ));
669 netdev_warn(dev->net, "EEPROM is busy");
673 static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
674 u32 length, u8 *data)
681 /* depends on chip, some EEPROM pins are muxed with LED function.
682 * disable & restore LED function to access EEPROM.
684 ret = lan78xx_read_reg(dev, HW_CFG, &val);
686 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
687 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
688 ret = lan78xx_write_reg(dev, HW_CFG, val);
691 retval = lan78xx_eeprom_confirm_not_busy(dev);
695 for (i = 0; i < length; i++) {
696 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
697 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
698 ret = lan78xx_write_reg(dev, E2P_CMD, val);
699 if (unlikely(ret < 0)) {
704 retval = lan78xx_wait_eeprom(dev);
708 ret = lan78xx_read_reg(dev, E2P_DATA, &val);
709 if (unlikely(ret < 0)) {
714 data[i] = val & 0xFF;
720 if (dev->chipid == ID_REV_CHIP_ID_7800_)
721 ret = lan78xx_write_reg(dev, HW_CFG, saved);
726 static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
727 u32 length, u8 *data)
732 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
733 if ((ret == 0) && (sig == EEPROM_INDICATOR))
734 ret = lan78xx_read_raw_eeprom(dev, offset, length, data);
741 static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
742 u32 length, u8 *data)
749 /* depends on chip, some EEPROM pins are muxed with LED function.
750 * disable & restore LED function to access EEPROM.
752 ret = lan78xx_read_reg(dev, HW_CFG, &val);
754 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
755 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
756 ret = lan78xx_write_reg(dev, HW_CFG, val);
759 retval = lan78xx_eeprom_confirm_not_busy(dev);
763 /* Issue write/erase enable command */
764 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
765 ret = lan78xx_write_reg(dev, E2P_CMD, val);
766 if (unlikely(ret < 0)) {
771 retval = lan78xx_wait_eeprom(dev);
775 for (i = 0; i < length; i++) {
776 /* Fill data register */
778 ret = lan78xx_write_reg(dev, E2P_DATA, val);
784 /* Send "write" command */
785 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
786 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
787 ret = lan78xx_write_reg(dev, E2P_CMD, val);
793 retval = lan78xx_wait_eeprom(dev);
802 if (dev->chipid == ID_REV_CHIP_ID_7800_)
803 ret = lan78xx_write_reg(dev, HW_CFG, saved);
808 static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
809 u32 length, u8 *data)
814 unsigned long timeout;
816 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
818 if (buf & OTP_PWR_DN_PWRDN_N_) {
819 /* clear it and wait to be cleared */
820 ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
822 timeout = jiffies + HZ;
825 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
826 if (time_after(jiffies, timeout)) {
827 netdev_warn(dev->net,
828 "timeout on OTP_PWR_DN");
831 } while (buf & OTP_PWR_DN_PWRDN_N_);
834 for (i = 0; i < length; i++) {
835 ret = lan78xx_write_reg(dev, OTP_ADDR1,
836 ((offset + i) >> 8) & OTP_ADDR1_15_11);
837 ret = lan78xx_write_reg(dev, OTP_ADDR2,
838 ((offset + i) & OTP_ADDR2_10_3));
840 ret = lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
841 ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
843 timeout = jiffies + HZ;
846 ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
847 if (time_after(jiffies, timeout)) {
848 netdev_warn(dev->net,
849 "timeout on OTP_STATUS");
852 } while (buf & OTP_STATUS_BUSY_);
854 ret = lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
856 data[i] = (u8)(buf & 0xFF);
862 static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
863 u32 length, u8 *data)
868 unsigned long timeout;
870 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
872 if (buf & OTP_PWR_DN_PWRDN_N_) {
873 /* clear it and wait to be cleared */
874 ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
876 timeout = jiffies + HZ;
879 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
880 if (time_after(jiffies, timeout)) {
881 netdev_warn(dev->net,
882 "timeout on OTP_PWR_DN completion");
885 } while (buf & OTP_PWR_DN_PWRDN_N_);
888 /* set to BYTE program mode */
889 ret = lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
891 for (i = 0; i < length; i++) {
892 ret = lan78xx_write_reg(dev, OTP_ADDR1,
893 ((offset + i) >> 8) & OTP_ADDR1_15_11);
894 ret = lan78xx_write_reg(dev, OTP_ADDR2,
895 ((offset + i) & OTP_ADDR2_10_3));
896 ret = lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
897 ret = lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
898 ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
900 timeout = jiffies + HZ;
903 ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
904 if (time_after(jiffies, timeout)) {
905 netdev_warn(dev->net,
906 "Timeout on OTP_STATUS completion");
909 } while (buf & OTP_STATUS_BUSY_);
915 static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
916 u32 length, u8 *data)
921 ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
924 if (sig == OTP_INDICATOR_1)
926 else if (sig == OTP_INDICATOR_2)
930 ret = lan78xx_read_raw_otp(dev, offset, length, data);
936 static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
940 for (i = 0; i < 100; i++) {
943 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
944 if (unlikely(ret < 0))
947 if (dp_sel & DP_SEL_DPRDY_)
950 usleep_range(40, 100);
953 netdev_warn(dev->net, "lan78xx_dataport_wait_not_busy timed out");
958 static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
959 u32 addr, u32 length, u32 *buf)
961 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
965 if (usb_autopm_get_interface(dev->intf) < 0)
968 mutex_lock(&pdata->dataport_mutex);
970 ret = lan78xx_dataport_wait_not_busy(dev);
974 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
976 dp_sel &= ~DP_SEL_RSEL_MASK_;
977 dp_sel |= ram_select;
978 ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);
980 for (i = 0; i < length; i++) {
981 ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
983 ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
985 ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
987 ret = lan78xx_dataport_wait_not_busy(dev);
993 mutex_unlock(&pdata->dataport_mutex);
994 usb_autopm_put_interface(dev->intf);
999 static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,
1000 int index, u8 addr[ETH_ALEN])
1004 if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {
1006 temp = addr[2] | (temp << 8);
1007 temp = addr[1] | (temp << 8);
1008 temp = addr[0] | (temp << 8);
1009 pdata->pfilter_table[index][1] = temp;
1011 temp = addr[4] | (temp << 8);
1012 temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;
1013 pdata->pfilter_table[index][0] = temp;
1017 /* returns hash bit number for given MAC address */
1018 static inline u32 lan78xx_hash(char addr[ETH_ALEN])
1020 return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
1023 static void lan78xx_deferred_multicast_write(struct work_struct *param)
1025 struct lan78xx_priv *pdata =
1026 container_of(param, struct lan78xx_priv, set_multicast);
1027 struct lan78xx_net *dev = pdata->dev;
1031 netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
1034 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,
1035 DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
1037 for (i = 1; i < NUM_OF_MAF; i++) {
1038 ret = lan78xx_write_reg(dev, MAF_HI(i), 0);
1039 ret = lan78xx_write_reg(dev, MAF_LO(i),
1040 pdata->pfilter_table[i][1]);
1041 ret = lan78xx_write_reg(dev, MAF_HI(i),
1042 pdata->pfilter_table[i][0]);
1045 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1048 static void lan78xx_set_multicast(struct net_device *netdev)
1050 struct lan78xx_net *dev = netdev_priv(netdev);
1051 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1052 unsigned long flags;
1055 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1057 pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |
1058 RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
1060 for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
1061 pdata->mchash_table[i] = 0;
1062 /* pfilter_table[0] has own HW address */
1063 for (i = 1; i < NUM_OF_MAF; i++) {
1064 pdata->pfilter_table[i][0] =
1065 pdata->pfilter_table[i][1] = 0;
1068 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;
1070 if (dev->net->flags & IFF_PROMISC) {
1071 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
1072 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;
1074 if (dev->net->flags & IFF_ALLMULTI) {
1075 netif_dbg(dev, drv, dev->net,
1076 "receive all multicast enabled");
1077 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;
1081 if (netdev_mc_count(dev->net)) {
1082 struct netdev_hw_addr *ha;
1085 netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
1087 pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;
1090 netdev_for_each_mc_addr(ha, netdev) {
1091 /* set first 32 into Perfect Filter */
1093 lan78xx_set_addr_filter(pdata, i, ha->addr);
1095 u32 bitnum = lan78xx_hash(ha->addr);
1097 pdata->mchash_table[bitnum / 32] |=
1098 (1 << (bitnum % 32));
1099 pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;
1105 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1107 /* defer register writes to a sleepable context */
1108 schedule_work(&pdata->set_multicast);
1111 static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1112 u16 lcladv, u16 rmtadv)
1114 u32 flow = 0, fct_flow = 0;
1118 if (dev->fc_autoneg)
1119 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1121 cap = dev->fc_request_control;
1123 if (cap & FLOW_CTRL_TX)
1124 flow |= (FLOW_CR_TX_FCEN_ | 0xFFFF);
1126 if (cap & FLOW_CTRL_RX)
1127 flow |= FLOW_CR_RX_FCEN_;
1129 if (dev->udev->speed == USB_SPEED_SUPER)
1131 else if (dev->udev->speed == USB_SPEED_HIGH)
1134 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1135 (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
1136 (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
1138 ret = lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1140 /* threshold value should be set before enabling flow */
1141 ret = lan78xx_write_reg(dev, FLOW, flow);
1146 static int lan78xx_link_reset(struct lan78xx_net *dev)
1148 struct phy_device *phydev = dev->net->phydev;
1149 struct ethtool_link_ksettings ecmd;
1150 int ladv, radv, ret;
1153 /* clear LAN78xx interrupt status */
1154 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1155 if (unlikely(ret < 0))
1158 phy_read_status(phydev);
1160 if (!phydev->link && dev->link_on) {
1161 dev->link_on = false;
1164 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1165 if (unlikely(ret < 0))
1168 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1169 if (unlikely(ret < 0))
1172 del_timer(&dev->stat_monitor);
1173 } else if (phydev->link && !dev->link_on) {
1174 dev->link_on = true;
1176 phy_ethtool_ksettings_get(phydev, &ecmd);
1178 if (dev->udev->speed == USB_SPEED_SUPER) {
1179 if (ecmd.base.speed == 1000) {
1181 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1182 buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1183 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1185 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1186 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1187 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1189 /* enable U1 & U2 */
1190 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1191 buf |= USB_CFG1_DEV_U2_INIT_EN_;
1192 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1193 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1197 ladv = phy_read(phydev, MII_ADVERTISE);
1201 radv = phy_read(phydev, MII_LPA);
1205 netif_dbg(dev, link, dev->net,
1206 "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1207 ecmd.base.speed, ecmd.base.duplex, ladv, radv);
1209 ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,
1212 if (!timer_pending(&dev->stat_monitor)) {
1214 mod_timer(&dev->stat_monitor,
1215 jiffies + STAT_UPDATE_TIMER);
1222 /* some work can't be done in tasklets, so we use keventd
1224 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
1225 * but tasklet_schedule() doesn't. hope the failure is rare.
1227 static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1229 set_bit(work, &dev->flags);
1230 if (!schedule_delayed_work(&dev->wq, 0))
1231 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1234 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1238 if (urb->actual_length != 4) {
1239 netdev_warn(dev->net,
1240 "unexpected urb length %d", urb->actual_length);
1244 memcpy(&intdata, urb->transfer_buffer, 4);
1245 le32_to_cpus(&intdata);
1247 if (intdata & INT_ENP_PHY_INT) {
1248 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1249 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1251 if (dev->domain_data.phyirq > 0)
1252 generic_handle_irq(dev->domain_data.phyirq);
1254 netdev_warn(dev->net,
1255 "unexpected interrupt: 0x%08x\n", intdata);
1258 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1260 return MAX_EEPROM_SIZE;
1263 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1264 struct ethtool_eeprom *ee, u8 *data)
1266 struct lan78xx_net *dev = netdev_priv(netdev);
1268 ee->magic = LAN78XX_EEPROM_MAGIC;
1270 return lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1273 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1274 struct ethtool_eeprom *ee, u8 *data)
1276 struct lan78xx_net *dev = netdev_priv(netdev);
1278 /* Allow entire eeprom update only */
1279 if ((ee->magic == LAN78XX_EEPROM_MAGIC) &&
1280 (ee->offset == 0) &&
1282 (data[0] == EEPROM_INDICATOR))
1283 return lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1284 else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1285 (ee->offset == 0) &&
1287 (data[0] == OTP_INDICATOR_1))
1288 return lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1293 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1296 if (stringset == ETH_SS_STATS)
1297 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1300 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1302 if (sset == ETH_SS_STATS)
1303 return ARRAY_SIZE(lan78xx_gstrings);
1308 static void lan78xx_get_stats(struct net_device *netdev,
1309 struct ethtool_stats *stats, u64 *data)
1311 struct lan78xx_net *dev = netdev_priv(netdev);
1313 lan78xx_update_stats(dev);
1315 mutex_lock(&dev->stats.access_lock);
1316 memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1317 mutex_unlock(&dev->stats.access_lock);
1320 static void lan78xx_get_wol(struct net_device *netdev,
1321 struct ethtool_wolinfo *wol)
1323 struct lan78xx_net *dev = netdev_priv(netdev);
1326 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1328 if (usb_autopm_get_interface(dev->intf) < 0)
1331 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1332 if (unlikely(ret < 0)) {
1336 if (buf & USB_CFG_RMT_WKP_) {
1337 wol->supported = WAKE_ALL;
1338 wol->wolopts = pdata->wol;
1345 usb_autopm_put_interface(dev->intf);
1348 static int lan78xx_set_wol(struct net_device *netdev,
1349 struct ethtool_wolinfo *wol)
1351 struct lan78xx_net *dev = netdev_priv(netdev);
1352 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1355 ret = usb_autopm_get_interface(dev->intf);
1360 if (wol->wolopts & WAKE_UCAST)
1361 pdata->wol |= WAKE_UCAST;
1362 if (wol->wolopts & WAKE_MCAST)
1363 pdata->wol |= WAKE_MCAST;
1364 if (wol->wolopts & WAKE_BCAST)
1365 pdata->wol |= WAKE_BCAST;
1366 if (wol->wolopts & WAKE_MAGIC)
1367 pdata->wol |= WAKE_MAGIC;
1368 if (wol->wolopts & WAKE_PHY)
1369 pdata->wol |= WAKE_PHY;
1370 if (wol->wolopts & WAKE_ARP)
1371 pdata->wol |= WAKE_ARP;
1373 device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1375 phy_ethtool_set_wol(netdev->phydev, wol);
1377 usb_autopm_put_interface(dev->intf);
1382 static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1384 struct lan78xx_net *dev = netdev_priv(net);
1385 struct phy_device *phydev = net->phydev;
1389 ret = usb_autopm_get_interface(dev->intf);
1393 ret = phy_ethtool_get_eee(phydev, edata);
1397 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1398 if (buf & MAC_CR_EEE_EN_) {
1399 edata->eee_enabled = true;
1400 edata->eee_active = !!(edata->advertised &
1401 edata->lp_advertised);
1402 edata->tx_lpi_enabled = true;
1403 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1404 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1405 edata->tx_lpi_timer = buf;
1407 edata->eee_enabled = false;
1408 edata->eee_active = false;
1409 edata->tx_lpi_enabled = false;
1410 edata->tx_lpi_timer = 0;
1415 usb_autopm_put_interface(dev->intf);
1420 static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1422 struct lan78xx_net *dev = netdev_priv(net);
1426 ret = usb_autopm_get_interface(dev->intf);
1430 if (edata->eee_enabled) {
1431 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1432 buf |= MAC_CR_EEE_EN_;
1433 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1435 phy_ethtool_set_eee(net->phydev, edata);
1437 buf = (u32)edata->tx_lpi_timer;
1438 ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1440 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1441 buf &= ~MAC_CR_EEE_EN_;
1442 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1445 usb_autopm_put_interface(dev->intf);
1450 static u32 lan78xx_get_link(struct net_device *net)
1452 phy_read_status(net->phydev);
1454 return net->phydev->link;
1457 static void lan78xx_get_drvinfo(struct net_device *net,
1458 struct ethtool_drvinfo *info)
1460 struct lan78xx_net *dev = netdev_priv(net);
1462 strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1463 strncpy(info->version, DRIVER_VERSION, sizeof(info->version));
1464 usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1467 static u32 lan78xx_get_msglevel(struct net_device *net)
1469 struct lan78xx_net *dev = netdev_priv(net);
1471 return dev->msg_enable;
1474 static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1476 struct lan78xx_net *dev = netdev_priv(net);
1478 dev->msg_enable = level;
1481 static int lan78xx_get_link_ksettings(struct net_device *net,
1482 struct ethtool_link_ksettings *cmd)
1484 struct lan78xx_net *dev = netdev_priv(net);
1485 struct phy_device *phydev = net->phydev;
1488 ret = usb_autopm_get_interface(dev->intf);
1492 ret = phy_ethtool_ksettings_get(phydev, cmd);
1494 usb_autopm_put_interface(dev->intf);
1499 static int lan78xx_set_link_ksettings(struct net_device *net,
1500 const struct ethtool_link_ksettings *cmd)
1502 struct lan78xx_net *dev = netdev_priv(net);
1503 struct phy_device *phydev = net->phydev;
1507 ret = usb_autopm_get_interface(dev->intf);
1511 /* change speed & duplex */
1512 ret = phy_ethtool_ksettings_set(phydev, cmd);
1514 if (!cmd->base.autoneg) {
1515 /* force link down */
1516 temp = phy_read(phydev, MII_BMCR);
1517 phy_write(phydev, MII_BMCR, temp | BMCR_LOOPBACK);
1519 phy_write(phydev, MII_BMCR, temp);
1522 usb_autopm_put_interface(dev->intf);
1527 static void lan78xx_get_pause(struct net_device *net,
1528 struct ethtool_pauseparam *pause)
1530 struct lan78xx_net *dev = netdev_priv(net);
1531 struct phy_device *phydev = net->phydev;
1532 struct ethtool_link_ksettings ecmd;
1534 phy_ethtool_ksettings_get(phydev, &ecmd);
1536 pause->autoneg = dev->fc_autoneg;
1538 if (dev->fc_request_control & FLOW_CTRL_TX)
1539 pause->tx_pause = 1;
1541 if (dev->fc_request_control & FLOW_CTRL_RX)
1542 pause->rx_pause = 1;
1545 static int lan78xx_set_pause(struct net_device *net,
1546 struct ethtool_pauseparam *pause)
1548 struct lan78xx_net *dev = netdev_priv(net);
1549 struct phy_device *phydev = net->phydev;
1550 struct ethtool_link_ksettings ecmd;
1553 phy_ethtool_ksettings_get(phydev, &ecmd);
1555 if (pause->autoneg && !ecmd.base.autoneg) {
1560 dev->fc_request_control = 0;
1561 if (pause->rx_pause)
1562 dev->fc_request_control |= FLOW_CTRL_RX;
1564 if (pause->tx_pause)
1565 dev->fc_request_control |= FLOW_CTRL_TX;
1567 if (ecmd.base.autoneg) {
1571 ethtool_convert_link_mode_to_legacy_u32(
1572 &advertising, ecmd.link_modes.advertising);
1574 advertising &= ~(ADVERTISED_Pause | ADVERTISED_Asym_Pause);
1575 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
1576 advertising |= mii_adv_to_ethtool_adv_t(mii_adv);
1578 ethtool_convert_legacy_u32_to_link_mode(
1579 ecmd.link_modes.advertising, advertising);
1581 phy_ethtool_ksettings_set(phydev, &ecmd);
1584 dev->fc_autoneg = pause->autoneg;
1591 static const struct ethtool_ops lan78xx_ethtool_ops = {
1592 .get_link = lan78xx_get_link,
1593 .nway_reset = phy_ethtool_nway_reset,
1594 .get_drvinfo = lan78xx_get_drvinfo,
1595 .get_msglevel = lan78xx_get_msglevel,
1596 .set_msglevel = lan78xx_set_msglevel,
1597 .get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1598 .get_eeprom = lan78xx_ethtool_get_eeprom,
1599 .set_eeprom = lan78xx_ethtool_set_eeprom,
1600 .get_ethtool_stats = lan78xx_get_stats,
1601 .get_sset_count = lan78xx_get_sset_count,
1602 .get_strings = lan78xx_get_strings,
1603 .get_wol = lan78xx_get_wol,
1604 .set_wol = lan78xx_set_wol,
1605 .get_eee = lan78xx_get_eee,
1606 .set_eee = lan78xx_set_eee,
1607 .get_pauseparam = lan78xx_get_pause,
1608 .set_pauseparam = lan78xx_set_pause,
1609 .get_link_ksettings = lan78xx_get_link_ksettings,
1610 .set_link_ksettings = lan78xx_set_link_ksettings,
1613 static int lan78xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
1615 if (!netif_running(netdev))
1618 return phy_mii_ioctl(netdev->phydev, rq, cmd);
1621 static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1623 u32 addr_lo, addr_hi;
1627 ret = lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1628 ret = lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1630 addr[0] = addr_lo & 0xFF;
1631 addr[1] = (addr_lo >> 8) & 0xFF;
1632 addr[2] = (addr_lo >> 16) & 0xFF;
1633 addr[3] = (addr_lo >> 24) & 0xFF;
1634 addr[4] = addr_hi & 0xFF;
1635 addr[5] = (addr_hi >> 8) & 0xFF;
1637 if (!is_valid_ether_addr(addr)) {
1638 /* reading mac address from EEPROM or OTP */
1639 if ((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
1641 (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
1643 if (is_valid_ether_addr(addr)) {
1644 /* eeprom values are valid so use them */
1645 netif_dbg(dev, ifup, dev->net,
1646 "MAC address read from EEPROM");
1648 /* generate random MAC */
1649 random_ether_addr(addr);
1650 netif_dbg(dev, ifup, dev->net,
1651 "MAC address set to random addr");
1654 addr_lo = addr[0] | (addr[1] << 8) |
1655 (addr[2] << 16) | (addr[3] << 24);
1656 addr_hi = addr[4] | (addr[5] << 8);
1658 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1659 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1661 /* generate random MAC */
1662 random_ether_addr(addr);
1663 netif_dbg(dev, ifup, dev->net,
1664 "MAC address set to random addr");
1668 ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1669 ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1671 ether_addr_copy(dev->net->dev_addr, addr);
1674 /* MDIO read and write wrappers for phylib */
1675 static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
1677 struct lan78xx_net *dev = bus->priv;
1681 ret = usb_autopm_get_interface(dev->intf);
1685 mutex_lock(&dev->phy_mutex);
1687 /* confirm MII not busy */
1688 ret = lan78xx_phy_wait_not_busy(dev);
1692 /* set the address, index & direction (read from PHY) */
1693 addr = mii_access(phy_id, idx, MII_READ);
1694 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1696 ret = lan78xx_phy_wait_not_busy(dev);
1700 ret = lan78xx_read_reg(dev, MII_DATA, &val);
1702 ret = (int)(val & 0xFFFF);
1705 mutex_unlock(&dev->phy_mutex);
1706 usb_autopm_put_interface(dev->intf);
1711 static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
1714 struct lan78xx_net *dev = bus->priv;
1718 ret = usb_autopm_get_interface(dev->intf);
1722 mutex_lock(&dev->phy_mutex);
1724 /* confirm MII not busy */
1725 ret = lan78xx_phy_wait_not_busy(dev);
1730 ret = lan78xx_write_reg(dev, MII_DATA, val);
1732 /* set the address, index & direction (write to PHY) */
1733 addr = mii_access(phy_id, idx, MII_WRITE);
1734 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1736 ret = lan78xx_phy_wait_not_busy(dev);
1741 mutex_unlock(&dev->phy_mutex);
1742 usb_autopm_put_interface(dev->intf);
1746 static int lan78xx_mdio_init(struct lan78xx_net *dev)
1750 dev->mdiobus = mdiobus_alloc();
1751 if (!dev->mdiobus) {
1752 netdev_err(dev->net, "can't allocate MDIO bus\n");
1756 dev->mdiobus->priv = (void *)dev;
1757 dev->mdiobus->read = lan78xx_mdiobus_read;
1758 dev->mdiobus->write = lan78xx_mdiobus_write;
1759 dev->mdiobus->name = "lan78xx-mdiobus";
1761 snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
1762 dev->udev->bus->busnum, dev->udev->devnum);
1764 switch (dev->chipid) {
1765 case ID_REV_CHIP_ID_7800_:
1766 case ID_REV_CHIP_ID_7850_:
1767 /* set to internal PHY id */
1768 dev->mdiobus->phy_mask = ~(1 << 1);
1770 case ID_REV_CHIP_ID_7801_:
1771 /* scan thru PHYAD[2..0] */
1772 dev->mdiobus->phy_mask = ~(0xFF);
1776 ret = mdiobus_register(dev->mdiobus);
1778 netdev_err(dev->net, "can't register MDIO bus\n");
1782 netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
1785 mdiobus_free(dev->mdiobus);
1789 static void lan78xx_remove_mdio(struct lan78xx_net *dev)
1791 mdiobus_unregister(dev->mdiobus);
1792 mdiobus_free(dev->mdiobus);
1795 static void lan78xx_link_status_change(struct net_device *net)
1797 struct phy_device *phydev = net->phydev;
1800 /* At forced 100 F/H mode, chip may fail to set mode correctly
1801 * when cable is switched between long(~50+m) and short one.
1802 * As workaround, set to 10 before setting to 100
1803 * at forced 100 F/H mode.
1805 if (!phydev->autoneg && (phydev->speed == 100)) {
1806 /* disable phy interrupt */
1807 temp = phy_read(phydev, LAN88XX_INT_MASK);
1808 temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_;
1809 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1811 temp = phy_read(phydev, MII_BMCR);
1812 temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000);
1813 phy_write(phydev, MII_BMCR, temp); /* set to 10 first */
1814 temp |= BMCR_SPEED100;
1815 phy_write(phydev, MII_BMCR, temp); /* set to 100 later */
1817 /* clear pending interrupt generated while workaround */
1818 temp = phy_read(phydev, LAN88XX_INT_STS);
1820 /* enable phy interrupt back */
1821 temp = phy_read(phydev, LAN88XX_INT_MASK);
1822 temp |= LAN88XX_INT_MASK_MDINTPIN_EN_;
1823 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1827 static int irq_map(struct irq_domain *d, unsigned int irq,
1828 irq_hw_number_t hwirq)
1830 struct irq_domain_data *data = d->host_data;
1832 irq_set_chip_data(irq, data);
1833 irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);
1834 irq_set_noprobe(irq);
1839 static void irq_unmap(struct irq_domain *d, unsigned int irq)
1841 irq_set_chip_and_handler(irq, NULL, NULL);
1842 irq_set_chip_data(irq, NULL);
1845 static const struct irq_domain_ops chip_domain_ops = {
1850 static void lan78xx_irq_mask(struct irq_data *irqd)
1852 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1854 data->irqenable &= ~BIT(irqd_to_hwirq(irqd));
1857 static void lan78xx_irq_unmask(struct irq_data *irqd)
1859 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1861 data->irqenable |= BIT(irqd_to_hwirq(irqd));
1864 static void lan78xx_irq_bus_lock(struct irq_data *irqd)
1866 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1868 mutex_lock(&data->irq_lock);
1871 static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
1873 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1874 struct lan78xx_net *dev =
1875 container_of(data, struct lan78xx_net, domain_data);
1879 /* call register access here because irq_bus_lock & irq_bus_sync_unlock
1880 * are only two callbacks executed in non-atomic contex.
1882 ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1883 if (buf != data->irqenable)
1884 ret = lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
1886 mutex_unlock(&data->irq_lock);
1889 static struct irq_chip lan78xx_irqchip = {
1890 .name = "lan78xx-irqs",
1891 .irq_mask = lan78xx_irq_mask,
1892 .irq_unmask = lan78xx_irq_unmask,
1893 .irq_bus_lock = lan78xx_irq_bus_lock,
1894 .irq_bus_sync_unlock = lan78xx_irq_bus_sync_unlock,
1897 static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
1899 struct device_node *of_node;
1900 struct irq_domain *irqdomain;
1901 unsigned int irqmap = 0;
1905 of_node = dev->udev->dev.parent->of_node;
1907 mutex_init(&dev->domain_data.irq_lock);
1909 lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1910 dev->domain_data.irqenable = buf;
1912 dev->domain_data.irqchip = &lan78xx_irqchip;
1913 dev->domain_data.irq_handler = handle_simple_irq;
1915 irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,
1916 &chip_domain_ops, &dev->domain_data);
1918 /* create mapping for PHY interrupt */
1919 irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);
1921 irq_domain_remove(irqdomain);
1930 dev->domain_data.irqdomain = irqdomain;
1931 dev->domain_data.phyirq = irqmap;
1936 static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
1938 if (dev->domain_data.phyirq > 0) {
1939 irq_dispose_mapping(dev->domain_data.phyirq);
1941 if (dev->domain_data.irqdomain)
1942 irq_domain_remove(dev->domain_data.irqdomain);
1944 dev->domain_data.phyirq = 0;
1945 dev->domain_data.irqdomain = NULL;
1948 static int lan8835_fixup(struct phy_device *phydev)
1952 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
1954 /* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */
1955 buf = phy_read_mmd_indirect(phydev, 0x8010, 3);
1958 phy_write_mmd_indirect(phydev, 0x8010, 3, buf);
1960 /* RGMII MAC TXC Delay Enable */
1961 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
1962 MAC_RGMII_ID_TXC_DELAY_EN_);
1964 /* RGMII TX DLL Tune Adjust */
1965 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
1967 dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
1972 static int ksz9031rnx_fixup(struct phy_device *phydev)
1974 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
1976 /* Micrel9301RNX PHY configuration */
1977 /* RGMII Control Signal Pad Skew */
1978 phy_write_mmd_indirect(phydev, 4, 2, 0x0077);
1979 /* RGMII RX Data Pad Skew */
1980 phy_write_mmd_indirect(phydev, 5, 2, 0x7777);
1981 /* RGMII RX Clock Pad Skew */
1982 phy_write_mmd_indirect(phydev, 8, 2, 0x1FF);
1984 dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;
1989 static int lan78xx_phy_init(struct lan78xx_net *dev)
1993 struct phy_device *phydev = dev->net->phydev;
1995 phydev = phy_find_first(dev->mdiobus);
1997 netdev_err(dev->net, "no PHY found\n");
2001 if ((dev->chipid == ID_REV_CHIP_ID_7800_) ||
2002 (dev->chipid == ID_REV_CHIP_ID_7850_)) {
2003 phydev->is_internal = true;
2004 dev->interface = PHY_INTERFACE_MODE_GMII;
2006 } else if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2008 netdev_err(dev->net, "no PHY driver found\n");
2012 dev->interface = PHY_INTERFACE_MODE_RGMII;
2014 /* external PHY fixup for KSZ9031RNX */
2015 ret = phy_register_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0,
2018 netdev_err(dev->net, "fail to register fixup\n");
2021 /* external PHY fixup for LAN8835 */
2022 ret = phy_register_fixup_for_uid(PHY_LAN8835, 0xfffffff0,
2025 netdev_err(dev->net, "fail to register fixup\n");
2028 /* add more external PHY fixup here if needed */
2030 phydev->is_internal = false;
2032 netdev_err(dev->net, "unknown ID found\n");
2037 /* if phyirq is not set, use polling mode in phylib */
2038 if (dev->domain_data.phyirq > 0)
2039 phydev->irq = dev->domain_data.phyirq;
2042 netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2044 /* set to AUTOMDIX */
2045 phydev->mdix = ETH_TP_MDI_AUTO;
2047 ret = phy_connect_direct(dev->net, phydev,
2048 lan78xx_link_status_change,
2051 netdev_err(dev->net, "can't attach PHY to %s\n",
2056 /* MAC doesn't support 1000T Half */
2057 phydev->supported &= ~SUPPORTED_1000baseT_Half;
2059 /* support both flow controls */
2060 dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2061 phydev->advertising &= ~(ADVERTISED_Pause | ADVERTISED_Asym_Pause);
2062 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2063 phydev->advertising |= mii_adv_to_ethtool_adv_t(mii_adv);
2065 genphy_config_aneg(phydev);
2067 dev->fc_autoneg = phydev->autoneg;
2071 netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
2076 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
2077 phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
2082 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2088 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2090 rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2093 buf &= ~MAC_RX_RXEN_;
2094 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2097 /* add 4 to size for FCS */
2098 buf &= ~MAC_RX_MAX_SIZE_MASK_;
2099 buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2101 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2104 buf |= MAC_RX_RXEN_;
2105 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2111 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2113 struct sk_buff *skb;
2114 unsigned long flags;
2117 spin_lock_irqsave(&q->lock, flags);
2118 while (!skb_queue_empty(q)) {
2119 struct skb_data *entry;
2123 skb_queue_walk(q, skb) {
2124 entry = (struct skb_data *)skb->cb;
2125 if (entry->state != unlink_start)
2130 entry->state = unlink_start;
2133 /* Get reference count of the URB to avoid it to be
2134 * freed during usb_unlink_urb, which may trigger
2135 * use-after-free problem inside usb_unlink_urb since
2136 * usb_unlink_urb is always racing with .complete
2137 * handler(include defer_bh).
2140 spin_unlock_irqrestore(&q->lock, flags);
2141 /* during some PM-driven resume scenarios,
2142 * these (async) unlinks complete immediately
2144 ret = usb_unlink_urb(urb);
2145 if (ret != -EINPROGRESS && ret != 0)
2146 netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2150 spin_lock_irqsave(&q->lock, flags);
2152 spin_unlock_irqrestore(&q->lock, flags);
2156 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2158 struct lan78xx_net *dev = netdev_priv(netdev);
2159 int ll_mtu = new_mtu + netdev->hard_header_len;
2160 int old_hard_mtu = dev->hard_mtu;
2161 int old_rx_urb_size = dev->rx_urb_size;
2164 /* no second zero-length packet read wanted after mtu-sized packets */
2165 if ((ll_mtu % dev->maxpacket) == 0)
2168 ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + ETH_HLEN);
2170 netdev->mtu = new_mtu;
2172 dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
2173 if (dev->rx_urb_size == old_hard_mtu) {
2174 dev->rx_urb_size = dev->hard_mtu;
2175 if (dev->rx_urb_size > old_rx_urb_size) {
2176 if (netif_running(dev->net)) {
2177 unlink_urbs(dev, &dev->rxq);
2178 tasklet_schedule(&dev->bh);
2186 static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2188 struct lan78xx_net *dev = netdev_priv(netdev);
2189 struct sockaddr *addr = p;
2190 u32 addr_lo, addr_hi;
2193 if (netif_running(netdev))
2196 if (!is_valid_ether_addr(addr->sa_data))
2197 return -EADDRNOTAVAIL;
2199 ether_addr_copy(netdev->dev_addr, addr->sa_data);
2201 addr_lo = netdev->dev_addr[0] |
2202 netdev->dev_addr[1] << 8 |
2203 netdev->dev_addr[2] << 16 |
2204 netdev->dev_addr[3] << 24;
2205 addr_hi = netdev->dev_addr[4] |
2206 netdev->dev_addr[5] << 8;
2208 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2209 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2214 /* Enable or disable Rx checksum offload engine */
2215 static int lan78xx_set_features(struct net_device *netdev,
2216 netdev_features_t features)
2218 struct lan78xx_net *dev = netdev_priv(netdev);
2219 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2220 unsigned long flags;
2223 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2225 if (features & NETIF_F_RXCSUM) {
2226 pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
2227 pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
2229 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2230 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2233 if (features & NETIF_F_HW_VLAN_CTAG_RX)
2234 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2236 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2238 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2240 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2245 static void lan78xx_deferred_vlan_write(struct work_struct *param)
2247 struct lan78xx_priv *pdata =
2248 container_of(param, struct lan78xx_priv, set_vlan);
2249 struct lan78xx_net *dev = pdata->dev;
2251 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2252 DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2255 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2256 __be16 proto, u16 vid)
2258 struct lan78xx_net *dev = netdev_priv(netdev);
2259 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2261 u16 vid_dword_index;
2263 vid_dword_index = (vid >> 5) & 0x7F;
2264 vid_bit_index = vid & 0x1F;
2266 pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2268 /* defer register writes to a sleepable context */
2269 schedule_work(&pdata->set_vlan);
2274 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2275 __be16 proto, u16 vid)
2277 struct lan78xx_net *dev = netdev_priv(netdev);
2278 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2280 u16 vid_dword_index;
2282 vid_dword_index = (vid >> 5) & 0x7F;
2283 vid_bit_index = vid & 0x1F;
2285 pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2287 /* defer register writes to a sleepable context */
2288 schedule_work(&pdata->set_vlan);
2293 static void lan78xx_init_ltm(struct lan78xx_net *dev)
2297 u32 regs[6] = { 0 };
2299 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2300 if (buf & USB_CFG1_LTM_ENABLE_) {
2302 /* Get values from EEPROM first */
2303 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2304 if (temp[0] == 24) {
2305 ret = lan78xx_read_raw_eeprom(dev,
2312 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2313 if (temp[0] == 24) {
2314 ret = lan78xx_read_raw_otp(dev,
2324 lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2325 lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2326 lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2327 lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2328 lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2329 lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2332 static int lan78xx_reset(struct lan78xx_net *dev)
2334 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2337 unsigned long timeout;
2339 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2340 buf |= HW_CFG_LRST_;
2341 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2343 timeout = jiffies + HZ;
2346 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2347 if (time_after(jiffies, timeout)) {
2348 netdev_warn(dev->net,
2349 "timeout on completion of LiteReset");
2352 } while (buf & HW_CFG_LRST_);
2354 lan78xx_init_mac_address(dev);
2356 /* save DEVID for later usage */
2357 ret = lan78xx_read_reg(dev, ID_REV, &buf);
2358 dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2359 dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2361 /* Respond to the IN token with a NAK */
2362 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2363 buf |= USB_CFG_BIR_;
2364 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2367 lan78xx_init_ltm(dev);
2369 dev->net->hard_header_len += TX_OVERHEAD;
2370 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
2372 if (dev->udev->speed == USB_SPEED_SUPER) {
2373 buf = DEFAULT_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2374 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2377 } else if (dev->udev->speed == USB_SPEED_HIGH) {
2378 buf = DEFAULT_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2379 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2380 dev->rx_qlen = RX_MAX_QUEUE_MEMORY / dev->rx_urb_size;
2381 dev->tx_qlen = RX_MAX_QUEUE_MEMORY / dev->hard_mtu;
2383 buf = DEFAULT_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2384 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2388 ret = lan78xx_write_reg(dev, BURST_CAP, buf);
2389 ret = lan78xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
2391 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2393 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2395 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2396 buf |= USB_CFG_BCE_;
2397 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2399 /* set FIFO sizes */
2400 buf = (MAX_RX_FIFO_SIZE - 512) / 512;
2401 ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2403 buf = (MAX_TX_FIFO_SIZE - 512) / 512;
2404 ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2406 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2407 ret = lan78xx_write_reg(dev, FLOW, 0);
2408 ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2410 /* Don't need rfe_ctl_lock during initialisation */
2411 ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2412 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
2413 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2415 /* Enable or disable checksum offload engines */
2416 lan78xx_set_features(dev->net, dev->net->features);
2418 lan78xx_set_multicast(dev->net);
2421 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2422 buf |= PMT_CTL_PHY_RST_;
2423 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
2425 timeout = jiffies + HZ;
2428 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2429 if (time_after(jiffies, timeout)) {
2430 netdev_warn(dev->net, "timeout waiting for PHY Reset");
2433 } while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
2435 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
2436 /* LAN7801 only has RGMII mode */
2437 if (dev->chipid == ID_REV_CHIP_ID_7801_)
2438 buf &= ~MAC_CR_GMII_EN_;
2439 buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
2440 ret = lan78xx_write_reg(dev, MAC_CR, buf);
2442 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
2443 buf |= MAC_TX_TXEN_;
2444 ret = lan78xx_write_reg(dev, MAC_TX, buf);
2446 ret = lan78xx_read_reg(dev, FCT_TX_CTL, &buf);
2447 buf |= FCT_TX_CTL_EN_;
2448 ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
2450 ret = lan78xx_set_rx_max_frame_length(dev, dev->net->mtu + ETH_HLEN);
2452 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2453 buf |= MAC_RX_RXEN_;
2454 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2456 ret = lan78xx_read_reg(dev, FCT_RX_CTL, &buf);
2457 buf |= FCT_RX_CTL_EN_;
2458 ret = lan78xx_write_reg(dev, FCT_RX_CTL, buf);
2463 static void lan78xx_init_stats(struct lan78xx_net *dev)
2468 /* initialize for stats update
2469 * some counters are 20bits and some are 32bits
2471 p = (u32 *)&dev->stats.rollover_max;
2472 for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
2475 dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
2476 dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
2477 dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
2478 dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
2479 dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
2480 dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
2481 dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
2482 dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
2483 dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
2484 dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
2486 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
2489 static int lan78xx_open(struct net_device *net)
2491 struct lan78xx_net *dev = netdev_priv(net);
2494 ret = usb_autopm_get_interface(dev->intf);
2498 ret = lan78xx_reset(dev);
2502 ret = lan78xx_phy_init(dev);
2506 /* for Link Check */
2507 if (dev->urb_intr) {
2508 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
2510 netif_err(dev, ifup, dev->net,
2511 "intr submit %d\n", ret);
2516 lan78xx_init_stats(dev);
2518 set_bit(EVENT_DEV_OPEN, &dev->flags);
2520 netif_start_queue(net);
2522 dev->link_on = false;
2524 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
2526 usb_autopm_put_interface(dev->intf);
2532 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
2534 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
2535 DECLARE_WAITQUEUE(wait, current);
2538 /* ensure there are no more active urbs */
2539 add_wait_queue(&unlink_wakeup, &wait);
2540 set_current_state(TASK_UNINTERRUPTIBLE);
2541 dev->wait = &unlink_wakeup;
2542 temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
2544 /* maybe wait for deletions to finish. */
2545 while (!skb_queue_empty(&dev->rxq) &&
2546 !skb_queue_empty(&dev->txq) &&
2547 !skb_queue_empty(&dev->done)) {
2548 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
2549 set_current_state(TASK_UNINTERRUPTIBLE);
2550 netif_dbg(dev, ifdown, dev->net,
2551 "waited for %d urb completions\n", temp);
2553 set_current_state(TASK_RUNNING);
2555 remove_wait_queue(&unlink_wakeup, &wait);
2558 static int lan78xx_stop(struct net_device *net)
2560 struct lan78xx_net *dev = netdev_priv(net);
2562 if (timer_pending(&dev->stat_monitor))
2563 del_timer_sync(&dev->stat_monitor);
2565 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
2566 phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
2568 phy_stop(net->phydev);
2569 phy_disconnect(net->phydev);
2573 clear_bit(EVENT_DEV_OPEN, &dev->flags);
2574 netif_stop_queue(net);
2576 netif_info(dev, ifdown, dev->net,
2577 "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
2578 net->stats.rx_packets, net->stats.tx_packets,
2579 net->stats.rx_errors, net->stats.tx_errors);
2581 lan78xx_terminate_urbs(dev);
2583 usb_kill_urb(dev->urb_intr);
2585 skb_queue_purge(&dev->rxq_pause);
2587 /* deferred work (task, timer, softirq) must also stop.
2588 * can't flush_scheduled_work() until we drop rtnl (later),
2589 * else workers could deadlock; so make workers a NOP.
2592 cancel_delayed_work_sync(&dev->wq);
2593 tasklet_kill(&dev->bh);
2595 usb_autopm_put_interface(dev->intf);
2600 static int lan78xx_linearize(struct sk_buff *skb)
2602 return skb_linearize(skb);
2605 static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
2606 struct sk_buff *skb, gfp_t flags)
2608 u32 tx_cmd_a, tx_cmd_b;
2610 if (skb_cow_head(skb, TX_OVERHEAD)) {
2611 dev_kfree_skb_any(skb);
2615 if (lan78xx_linearize(skb) < 0)
2618 tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
2620 if (skb->ip_summed == CHECKSUM_PARTIAL)
2621 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
2624 if (skb_is_gso(skb)) {
2625 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
2627 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
2629 tx_cmd_a |= TX_CMD_A_LSO_;
2632 if (skb_vlan_tag_present(skb)) {
2633 tx_cmd_a |= TX_CMD_A_IVTG_;
2634 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
2638 cpu_to_le32s(&tx_cmd_b);
2639 memcpy(skb->data, &tx_cmd_b, 4);
2642 cpu_to_le32s(&tx_cmd_a);
2643 memcpy(skb->data, &tx_cmd_a, 4);
2648 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
2649 struct sk_buff_head *list, enum skb_state state)
2651 unsigned long flags;
2652 enum skb_state old_state;
2653 struct skb_data *entry = (struct skb_data *)skb->cb;
2655 spin_lock_irqsave(&list->lock, flags);
2656 old_state = entry->state;
2657 entry->state = state;
2659 __skb_unlink(skb, list);
2660 spin_unlock(&list->lock);
2661 spin_lock(&dev->done.lock);
2663 __skb_queue_tail(&dev->done, skb);
2664 if (skb_queue_len(&dev->done) == 1)
2665 tasklet_schedule(&dev->bh);
2666 spin_unlock_irqrestore(&dev->done.lock, flags);
2671 static void tx_complete(struct urb *urb)
2673 struct sk_buff *skb = (struct sk_buff *)urb->context;
2674 struct skb_data *entry = (struct skb_data *)skb->cb;
2675 struct lan78xx_net *dev = entry->dev;
2677 if (urb->status == 0) {
2678 dev->net->stats.tx_packets += entry->num_of_packet;
2679 dev->net->stats.tx_bytes += entry->length;
2681 dev->net->stats.tx_errors++;
2683 switch (urb->status) {
2685 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2688 /* software-driven interface shutdown */
2696 netif_stop_queue(dev->net);
2699 netif_dbg(dev, tx_err, dev->net,
2700 "tx err %d\n", entry->urb->status);
2705 usb_autopm_put_interface_async(dev->intf);
2707 defer_bh(dev, skb, &dev->txq, tx_done);
2710 static void lan78xx_queue_skb(struct sk_buff_head *list,
2711 struct sk_buff *newsk, enum skb_state state)
2713 struct skb_data *entry = (struct skb_data *)newsk->cb;
2715 __skb_queue_tail(list, newsk);
2716 entry->state = state;
2720 lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
2722 struct lan78xx_net *dev = netdev_priv(net);
2723 struct sk_buff *skb2 = NULL;
2726 skb_tx_timestamp(skb);
2727 skb2 = lan78xx_tx_prep(dev, skb, GFP_ATOMIC);
2731 skb_queue_tail(&dev->txq_pend, skb2);
2733 /* throttle TX patch at slower than SUPER SPEED USB */
2734 if ((dev->udev->speed < USB_SPEED_SUPER) &&
2735 (skb_queue_len(&dev->txq_pend) > 10))
2736 netif_stop_queue(net);
2738 netif_dbg(dev, tx_err, dev->net,
2739 "lan78xx_tx_prep return NULL\n");
2740 dev->net->stats.tx_errors++;
2741 dev->net->stats.tx_dropped++;
2744 tasklet_schedule(&dev->bh);
2746 return NETDEV_TX_OK;
2750 lan78xx_get_endpoints(struct lan78xx_net *dev, struct usb_interface *intf)
2753 struct usb_host_interface *alt = NULL;
2754 struct usb_host_endpoint *in = NULL, *out = NULL;
2755 struct usb_host_endpoint *status = NULL;
2757 for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
2763 alt = intf->altsetting + tmp;
2765 for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
2766 struct usb_host_endpoint *e;
2769 e = alt->endpoint + ep;
2770 switch (e->desc.bmAttributes) {
2771 case USB_ENDPOINT_XFER_INT:
2772 if (!usb_endpoint_dir_in(&e->desc))
2776 case USB_ENDPOINT_XFER_BULK:
2781 if (usb_endpoint_dir_in(&e->desc)) {
2784 else if (intr && !status)
2794 if (!alt || !in || !out)
2797 dev->pipe_in = usb_rcvbulkpipe(dev->udev,
2798 in->desc.bEndpointAddress &
2799 USB_ENDPOINT_NUMBER_MASK);
2800 dev->pipe_out = usb_sndbulkpipe(dev->udev,
2801 out->desc.bEndpointAddress &
2802 USB_ENDPOINT_NUMBER_MASK);
2803 dev->ep_intr = status;
2808 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
2810 struct lan78xx_priv *pdata = NULL;
2814 ret = lan78xx_get_endpoints(dev, intf);
2816 dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
2818 pdata = (struct lan78xx_priv *)(dev->data[0]);
2820 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
2826 spin_lock_init(&pdata->rfe_ctl_lock);
2827 mutex_init(&pdata->dataport_mutex);
2829 INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
2831 for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
2832 pdata->vlan_table[i] = 0;
2834 INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
2836 dev->net->features = 0;
2838 if (DEFAULT_TX_CSUM_ENABLE)
2839 dev->net->features |= NETIF_F_HW_CSUM;
2841 if (DEFAULT_RX_CSUM_ENABLE)
2842 dev->net->features |= NETIF_F_RXCSUM;
2844 if (DEFAULT_TSO_CSUM_ENABLE)
2845 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
2847 dev->net->hw_features = dev->net->features;
2849 ret = lan78xx_setup_irq_domain(dev);
2851 netdev_warn(dev->net,
2852 "lan78xx_setup_irq_domain() failed : %d", ret);
2857 /* Init all registers */
2858 ret = lan78xx_reset(dev);
2860 lan78xx_mdio_init(dev);
2862 dev->net->flags |= IFF_MULTICAST;
2864 pdata->wol = WAKE_MAGIC;
2869 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
2871 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2873 lan78xx_remove_irq_domain(dev);
2875 lan78xx_remove_mdio(dev);
2878 netif_dbg(dev, ifdown, dev->net, "free pdata");
2885 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
2886 struct sk_buff *skb,
2887 u32 rx_cmd_a, u32 rx_cmd_b)
2889 if (!(dev->net->features & NETIF_F_RXCSUM) ||
2890 unlikely(rx_cmd_a & RX_CMD_A_ICSM_)) {
2891 skb->ip_summed = CHECKSUM_NONE;
2893 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
2894 skb->ip_summed = CHECKSUM_COMPLETE;
2898 static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
2902 if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
2903 skb_queue_tail(&dev->rxq_pause, skb);
2907 dev->net->stats.rx_packets++;
2908 dev->net->stats.rx_bytes += skb->len;
2910 skb->protocol = eth_type_trans(skb, dev->net);
2912 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
2913 skb->len + sizeof(struct ethhdr), skb->protocol);
2914 memset(skb->cb, 0, sizeof(struct skb_data));
2916 if (skb_defer_rx_timestamp(skb))
2919 status = netif_rx(skb);
2920 if (status != NET_RX_SUCCESS)
2921 netif_dbg(dev, rx_err, dev->net,
2922 "netif_rx status %d\n", status);
2925 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb)
2927 if (skb->len < dev->net->hard_header_len)
2930 while (skb->len > 0) {
2931 u32 rx_cmd_a, rx_cmd_b, align_count, size;
2933 struct sk_buff *skb2;
2934 unsigned char *packet;
2936 memcpy(&rx_cmd_a, skb->data, sizeof(rx_cmd_a));
2937 le32_to_cpus(&rx_cmd_a);
2938 skb_pull(skb, sizeof(rx_cmd_a));
2940 memcpy(&rx_cmd_b, skb->data, sizeof(rx_cmd_b));
2941 le32_to_cpus(&rx_cmd_b);
2942 skb_pull(skb, sizeof(rx_cmd_b));
2944 memcpy(&rx_cmd_c, skb->data, sizeof(rx_cmd_c));
2945 le16_to_cpus(&rx_cmd_c);
2946 skb_pull(skb, sizeof(rx_cmd_c));
2950 /* get the packet length */
2951 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
2952 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
2954 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
2955 netif_dbg(dev, rx_err, dev->net,
2956 "Error rx_cmd_a=0x%08x", rx_cmd_a);
2958 /* last frame in this batch */
2959 if (skb->len == size) {
2960 lan78xx_rx_csum_offload(dev, skb,
2961 rx_cmd_a, rx_cmd_b);
2963 skb_trim(skb, skb->len - 4); /* remove fcs */
2964 skb->truesize = size + sizeof(struct sk_buff);
2969 skb2 = skb_clone(skb, GFP_ATOMIC);
2970 if (unlikely(!skb2)) {
2971 netdev_warn(dev->net, "Error allocating skb");
2976 skb2->data = packet;
2977 skb_set_tail_pointer(skb2, size);
2979 lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
2981 skb_trim(skb2, skb2->len - 4); /* remove fcs */
2982 skb2->truesize = size + sizeof(struct sk_buff);
2984 lan78xx_skb_return(dev, skb2);
2987 skb_pull(skb, size);
2989 /* padding bytes before the next frame starts */
2991 skb_pull(skb, align_count);
2997 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb)
2999 if (!lan78xx_rx(dev, skb)) {
3000 dev->net->stats.rx_errors++;
3005 lan78xx_skb_return(dev, skb);
3009 netif_dbg(dev, rx_err, dev->net, "drop\n");
3010 dev->net->stats.rx_errors++;
3012 skb_queue_tail(&dev->done, skb);
3015 static void rx_complete(struct urb *urb);
3017 static int rx_submit(struct lan78xx_net *dev, struct urb *urb, gfp_t flags)
3019 struct sk_buff *skb;
3020 struct skb_data *entry;
3021 unsigned long lockflags;
3022 size_t size = dev->rx_urb_size;
3025 skb = netdev_alloc_skb_ip_align(dev->net, size);
3031 entry = (struct skb_data *)skb->cb;
3036 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3037 skb->data, size, rx_complete, skb);
3039 spin_lock_irqsave(&dev->rxq.lock, lockflags);
3041 if (netif_device_present(dev->net) &&
3042 netif_running(dev->net) &&
3043 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3044 !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3045 ret = usb_submit_urb(urb, GFP_ATOMIC);
3048 lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3051 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3054 netif_dbg(dev, ifdown, dev->net, "device gone\n");
3055 netif_device_detach(dev->net);
3061 netif_dbg(dev, rx_err, dev->net,
3062 "rx submit, %d\n", ret);
3063 tasklet_schedule(&dev->bh);
3066 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3069 spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3071 dev_kfree_skb_any(skb);
3077 static void rx_complete(struct urb *urb)
3079 struct sk_buff *skb = (struct sk_buff *)urb->context;
3080 struct skb_data *entry = (struct skb_data *)skb->cb;
3081 struct lan78xx_net *dev = entry->dev;
3082 int urb_status = urb->status;
3083 enum skb_state state;
3085 skb_put(skb, urb->actual_length);
3089 switch (urb_status) {
3091 if (skb->len < dev->net->hard_header_len) {
3093 dev->net->stats.rx_errors++;
3094 dev->net->stats.rx_length_errors++;
3095 netif_dbg(dev, rx_err, dev->net,
3096 "rx length %d\n", skb->len);
3098 usb_mark_last_busy(dev->udev);
3101 dev->net->stats.rx_errors++;
3102 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3104 case -ECONNRESET: /* async unlink */
3105 case -ESHUTDOWN: /* hardware gone */
3106 netif_dbg(dev, ifdown, dev->net,
3107 "rx shutdown, code %d\n", urb_status);
3115 dev->net->stats.rx_errors++;
3121 /* data overrun ... flush fifo? */
3123 dev->net->stats.rx_over_errors++;
3128 dev->net->stats.rx_errors++;
3129 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3133 state = defer_bh(dev, skb, &dev->rxq, state);
3136 if (netif_running(dev->net) &&
3137 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3138 state != unlink_start) {
3139 rx_submit(dev, urb, GFP_ATOMIC);
3144 netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
3147 static void lan78xx_tx_bh(struct lan78xx_net *dev)
3150 struct urb *urb = NULL;
3151 struct skb_data *entry;
3152 unsigned long flags;
3153 struct sk_buff_head *tqp = &dev->txq_pend;
3154 struct sk_buff *skb, *skb2;
3157 int skb_totallen, pkt_cnt;
3163 for (skb = tqp->next; pkt_cnt < tqp->qlen; skb = skb->next) {
3164 if (skb_is_gso(skb)) {
3166 /* handle previous packets first */
3170 length = skb->len - TX_OVERHEAD;
3171 skb2 = skb_dequeue(tqp);
3175 if ((skb_totallen + skb->len) > MAX_SINGLE_PACKET_SIZE)
3177 skb_totallen = skb->len + roundup(skb_totallen, sizeof(u32));
3181 /* copy to a single skb */
3182 skb = alloc_skb(skb_totallen, GFP_ATOMIC);
3186 skb_put(skb, skb_totallen);
3188 for (count = pos = 0; count < pkt_cnt; count++) {
3189 skb2 = skb_dequeue(tqp);
3191 length += (skb2->len - TX_OVERHEAD);
3192 memcpy(skb->data + pos, skb2->data, skb2->len);
3193 pos += roundup(skb2->len, sizeof(u32));
3194 dev_kfree_skb(skb2);
3199 urb = usb_alloc_urb(0, GFP_ATOMIC);
3203 entry = (struct skb_data *)skb->cb;
3206 entry->length = length;
3207 entry->num_of_packet = count;
3209 spin_lock_irqsave(&dev->txq.lock, flags);
3210 ret = usb_autopm_get_interface_async(dev->intf);
3212 spin_unlock_irqrestore(&dev->txq.lock, flags);
3216 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_out,
3217 skb->data, skb->len, tx_complete, skb);
3219 if (length % dev->maxpacket == 0) {
3220 /* send USB_ZERO_PACKET */
3221 urb->transfer_flags |= URB_ZERO_PACKET;
3225 /* if this triggers the device is still a sleep */
3226 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3227 /* transmission will be done in resume */
3228 usb_anchor_urb(urb, &dev->deferred);
3229 /* no use to process more packets */
3230 netif_stop_queue(dev->net);
3232 spin_unlock_irqrestore(&dev->txq.lock, flags);
3233 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
3238 ret = usb_submit_urb(urb, GFP_ATOMIC);
3241 netif_trans_update(dev->net);
3242 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3243 if (skb_queue_len(&dev->txq) >= dev->tx_qlen)
3244 netif_stop_queue(dev->net);
3247 netif_stop_queue(dev->net);
3248 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3249 usb_autopm_put_interface_async(dev->intf);
3252 usb_autopm_put_interface_async(dev->intf);
3253 netif_dbg(dev, tx_err, dev->net,
3254 "tx: submit urb err %d\n", ret);
3258 spin_unlock_irqrestore(&dev->txq.lock, flags);
3261 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", ret);
3263 dev->net->stats.tx_dropped++;
3265 dev_kfree_skb_any(skb);
3268 netif_dbg(dev, tx_queued, dev->net,
3269 "> tx, len %d, type 0x%x\n", length, skb->protocol);
3272 static void lan78xx_rx_bh(struct lan78xx_net *dev)
3277 if (skb_queue_len(&dev->rxq) < dev->rx_qlen) {
3278 for (i = 0; i < 10; i++) {
3279 if (skb_queue_len(&dev->rxq) >= dev->rx_qlen)
3281 urb = usb_alloc_urb(0, GFP_ATOMIC);
3283 if (rx_submit(dev, urb, GFP_ATOMIC) == -ENOLINK)
3287 if (skb_queue_len(&dev->rxq) < dev->rx_qlen)
3288 tasklet_schedule(&dev->bh);
3290 if (skb_queue_len(&dev->txq) < dev->tx_qlen)
3291 netif_wake_queue(dev->net);
3294 static void lan78xx_bh(unsigned long param)
3296 struct lan78xx_net *dev = (struct lan78xx_net *)param;
3297 struct sk_buff *skb;
3298 struct skb_data *entry;
3300 while ((skb = skb_dequeue(&dev->done))) {
3301 entry = (struct skb_data *)(skb->cb);
3302 switch (entry->state) {
3304 entry->state = rx_cleanup;
3305 rx_process(dev, skb);
3308 usb_free_urb(entry->urb);
3312 usb_free_urb(entry->urb);
3316 netdev_dbg(dev->net, "skb state %d\n", entry->state);
3321 if (netif_device_present(dev->net) && netif_running(dev->net)) {
3322 /* reset update timer delta */
3323 if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
3325 mod_timer(&dev->stat_monitor,
3326 jiffies + STAT_UPDATE_TIMER);
3329 if (!skb_queue_empty(&dev->txq_pend))
3332 if (!timer_pending(&dev->delay) &&
3333 !test_bit(EVENT_RX_HALT, &dev->flags))
3338 static void lan78xx_delayedwork(struct work_struct *work)
3341 struct lan78xx_net *dev;
3343 dev = container_of(work, struct lan78xx_net, wq.work);
3345 if (test_bit(EVENT_TX_HALT, &dev->flags)) {
3346 unlink_urbs(dev, &dev->txq);
3347 status = usb_autopm_get_interface(dev->intf);
3350 status = usb_clear_halt(dev->udev, dev->pipe_out);
3351 usb_autopm_put_interface(dev->intf);
3354 status != -ESHUTDOWN) {
3355 if (netif_msg_tx_err(dev))
3357 netdev_err(dev->net,
3358 "can't clear tx halt, status %d\n",
3361 clear_bit(EVENT_TX_HALT, &dev->flags);
3362 if (status != -ESHUTDOWN)
3363 netif_wake_queue(dev->net);
3366 if (test_bit(EVENT_RX_HALT, &dev->flags)) {
3367 unlink_urbs(dev, &dev->rxq);
3368 status = usb_autopm_get_interface(dev->intf);
3371 status = usb_clear_halt(dev->udev, dev->pipe_in);
3372 usb_autopm_put_interface(dev->intf);
3375 status != -ESHUTDOWN) {
3376 if (netif_msg_rx_err(dev))
3378 netdev_err(dev->net,
3379 "can't clear rx halt, status %d\n",
3382 clear_bit(EVENT_RX_HALT, &dev->flags);
3383 tasklet_schedule(&dev->bh);
3387 if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
3390 clear_bit(EVENT_LINK_RESET, &dev->flags);
3391 status = usb_autopm_get_interface(dev->intf);
3394 if (lan78xx_link_reset(dev) < 0) {
3395 usb_autopm_put_interface(dev->intf);
3397 netdev_info(dev->net, "link reset failed (%d)\n",
3400 usb_autopm_put_interface(dev->intf);
3404 if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
3405 lan78xx_update_stats(dev);
3407 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3409 mod_timer(&dev->stat_monitor,
3410 jiffies + (STAT_UPDATE_TIMER * dev->delta));
3412 dev->delta = min((dev->delta * 2), 50);
3416 static void intr_complete(struct urb *urb)
3418 struct lan78xx_net *dev = urb->context;
3419 int status = urb->status;
3424 lan78xx_status(dev, urb);
3427 /* software-driven interface shutdown */
3428 case -ENOENT: /* urb killed */
3429 case -ESHUTDOWN: /* hardware gone */
3430 netif_dbg(dev, ifdown, dev->net,
3431 "intr shutdown, code %d\n", status);
3434 /* NOTE: not throttling like RX/TX, since this endpoint
3435 * already polls infrequently
3438 netdev_dbg(dev->net, "intr status %d\n", status);
3442 if (!netif_running(dev->net))
3445 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
3446 status = usb_submit_urb(urb, GFP_ATOMIC);
3448 netif_err(dev, timer, dev->net,
3449 "intr resubmit --> %d\n", status);
3452 static void lan78xx_disconnect(struct usb_interface *intf)
3454 struct lan78xx_net *dev;
3455 struct usb_device *udev;
3456 struct net_device *net;
3458 dev = usb_get_intfdata(intf);
3459 usb_set_intfdata(intf, NULL);
3463 udev = interface_to_usbdev(intf);
3466 unregister_netdev(net);
3468 cancel_delayed_work_sync(&dev->wq);
3470 usb_scuttle_anchored_urbs(&dev->deferred);
3472 lan78xx_unbind(dev, intf);
3474 usb_kill_urb(dev->urb_intr);
3475 usb_free_urb(dev->urb_intr);
3481 static void lan78xx_tx_timeout(struct net_device *net)
3483 struct lan78xx_net *dev = netdev_priv(net);
3485 unlink_urbs(dev, &dev->txq);
3486 tasklet_schedule(&dev->bh);
3489 static const struct net_device_ops lan78xx_netdev_ops = {
3490 .ndo_open = lan78xx_open,
3491 .ndo_stop = lan78xx_stop,
3492 .ndo_start_xmit = lan78xx_start_xmit,
3493 .ndo_tx_timeout = lan78xx_tx_timeout,
3494 .ndo_change_mtu = lan78xx_change_mtu,
3495 .ndo_set_mac_address = lan78xx_set_mac_addr,
3496 .ndo_validate_addr = eth_validate_addr,
3497 .ndo_do_ioctl = lan78xx_ioctl,
3498 .ndo_set_rx_mode = lan78xx_set_multicast,
3499 .ndo_set_features = lan78xx_set_features,
3500 .ndo_vlan_rx_add_vid = lan78xx_vlan_rx_add_vid,
3501 .ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid,
3504 static void lan78xx_stat_monitor(unsigned long param)
3506 struct lan78xx_net *dev;
3508 dev = (struct lan78xx_net *)param;
3510 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
3513 static int lan78xx_probe(struct usb_interface *intf,
3514 const struct usb_device_id *id)
3516 struct lan78xx_net *dev;
3517 struct net_device *netdev;
3518 struct usb_device *udev;
3524 udev = interface_to_usbdev(intf);
3525 udev = usb_get_dev(udev);
3528 netdev = alloc_etherdev(sizeof(struct lan78xx_net));
3530 dev_err(&intf->dev, "Error: OOM\n");
3534 /* netdev_printk() needs this */
3535 SET_NETDEV_DEV(netdev, &intf->dev);
3537 dev = netdev_priv(netdev);
3541 dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
3542 | NETIF_MSG_PROBE | NETIF_MSG_LINK);
3544 skb_queue_head_init(&dev->rxq);
3545 skb_queue_head_init(&dev->txq);
3546 skb_queue_head_init(&dev->done);
3547 skb_queue_head_init(&dev->rxq_pause);
3548 skb_queue_head_init(&dev->txq_pend);
3549 mutex_init(&dev->phy_mutex);
3551 tasklet_init(&dev->bh, lan78xx_bh, (unsigned long)dev);
3552 INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
3553 init_usb_anchor(&dev->deferred);
3555 netdev->netdev_ops = &lan78xx_netdev_ops;
3556 netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
3557 netdev->ethtool_ops = &lan78xx_ethtool_ops;
3559 dev->stat_monitor.function = lan78xx_stat_monitor;
3560 dev->stat_monitor.data = (unsigned long)dev;
3562 init_timer(&dev->stat_monitor);
3564 mutex_init(&dev->stats.access_lock);
3566 ret = lan78xx_bind(dev, intf);
3569 strcpy(netdev->name, "eth%d");
3571 if (netdev->mtu > (dev->hard_mtu - netdev->hard_header_len))
3572 netdev->mtu = dev->hard_mtu - netdev->hard_header_len;
3574 /* MTU range: 68 - 9000 */
3575 netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
3577 dev->ep_blkin = (intf->cur_altsetting)->endpoint + 0;
3578 dev->ep_blkout = (intf->cur_altsetting)->endpoint + 1;
3579 dev->ep_intr = (intf->cur_altsetting)->endpoint + 2;
3581 dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
3582 dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
3584 dev->pipe_intr = usb_rcvintpipe(dev->udev,
3585 dev->ep_intr->desc.bEndpointAddress &
3586 USB_ENDPOINT_NUMBER_MASK);
3587 period = dev->ep_intr->desc.bInterval;
3589 maxp = usb_maxpacket(dev->udev, dev->pipe_intr, 0);
3590 buf = kmalloc(maxp, GFP_KERNEL);
3592 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
3593 if (!dev->urb_intr) {
3598 usb_fill_int_urb(dev->urb_intr, dev->udev,
3599 dev->pipe_intr, buf, maxp,
3600 intr_complete, dev, period);
3604 dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out, 1);
3606 /* driver requires remote-wakeup capability during autosuspend. */
3607 intf->needs_remote_wakeup = 1;
3609 ret = register_netdev(netdev);
3611 netif_err(dev, probe, netdev, "couldn't register the device\n");
3615 usb_set_intfdata(intf, dev);
3617 ret = device_set_wakeup_enable(&udev->dev, true);
3619 /* Default delay of 2sec has more overhead than advantage.
3620 * Set to 10sec as default.
3622 pm_runtime_set_autosuspend_delay(&udev->dev,
3623 DEFAULT_AUTOSUSPEND_DELAY);
3628 lan78xx_unbind(dev, intf);
3630 free_netdev(netdev);
3637 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
3639 const u16 crc16poly = 0x8005;
3645 for (i = 0; i < len; i++) {
3647 for (bit = 0; bit < 8; bit++) {
3651 if (msb ^ (u16)(data & 1)) {
3653 crc |= (u16)0x0001U;
3662 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
3670 const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
3671 const u8 ipv6_multicast[3] = { 0x33, 0x33 };
3672 const u8 arp_type[2] = { 0x08, 0x06 };
3674 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3675 buf &= ~MAC_TX_TXEN_;
3676 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3677 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3678 buf &= ~MAC_RX_RXEN_;
3679 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3681 ret = lan78xx_write_reg(dev, WUCSR, 0);
3682 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3683 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3688 ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
3689 temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
3690 temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
3692 for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
3693 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
3696 if (wol & WAKE_PHY) {
3697 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
3699 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3700 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3701 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3703 if (wol & WAKE_MAGIC) {
3704 temp_wucsr |= WUCSR_MPEN_;
3706 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3707 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3708 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
3710 if (wol & WAKE_BCAST) {
3711 temp_wucsr |= WUCSR_BCST_EN_;
3713 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3714 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3715 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3717 if (wol & WAKE_MCAST) {
3718 temp_wucsr |= WUCSR_WAKE_EN_;
3720 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
3721 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
3722 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3724 WUF_CFGX_TYPE_MCAST_ |
3725 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3726 (crc & WUF_CFGX_CRC16_MASK_));
3728 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
3729 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3730 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3731 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3734 /* for IPv6 Multicast */
3735 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
3736 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3738 WUF_CFGX_TYPE_MCAST_ |
3739 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3740 (crc & WUF_CFGX_CRC16_MASK_));
3742 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
3743 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3744 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3745 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3748 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3749 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3750 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3752 if (wol & WAKE_UCAST) {
3753 temp_wucsr |= WUCSR_PFDA_EN_;
3755 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3756 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3757 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3759 if (wol & WAKE_ARP) {
3760 temp_wucsr |= WUCSR_WAKE_EN_;
3762 /* set WUF_CFG & WUF_MASK
3763 * for packettype (offset 12,13) = ARP (0x0806)
3765 crc = lan78xx_wakeframe_crc16(arp_type, 2);
3766 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3768 WUF_CFGX_TYPE_ALL_ |
3769 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3770 (crc & WUF_CFGX_CRC16_MASK_));
3772 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
3773 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3774 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3775 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3778 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3779 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3780 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3783 ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
3785 /* when multiple WOL bits are set */
3786 if (hweight_long((unsigned long)wol) > 1) {
3787 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3788 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3789 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3791 ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
3794 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3795 buf |= PMT_CTL_WUPS_MASK_;
3796 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3798 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3799 buf |= MAC_RX_RXEN_;
3800 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3805 static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
3807 struct lan78xx_net *dev = usb_get_intfdata(intf);
3808 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3813 event = message.event;
3815 if (!dev->suspend_count++) {
3816 spin_lock_irq(&dev->txq.lock);
3817 /* don't autosuspend while transmitting */
3818 if ((skb_queue_len(&dev->txq) ||
3819 skb_queue_len(&dev->txq_pend)) &&
3820 PMSG_IS_AUTO(message)) {
3821 spin_unlock_irq(&dev->txq.lock);
3825 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
3826 spin_unlock_irq(&dev->txq.lock);
3830 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3831 buf &= ~MAC_TX_TXEN_;
3832 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3833 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3834 buf &= ~MAC_RX_RXEN_;
3835 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3837 /* empty out the rx and queues */
3838 netif_device_detach(dev->net);
3839 lan78xx_terminate_urbs(dev);
3840 usb_kill_urb(dev->urb_intr);
3843 netif_device_attach(dev->net);
3846 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3847 del_timer(&dev->stat_monitor);
3849 if (PMSG_IS_AUTO(message)) {
3850 /* auto suspend (selective suspend) */
3851 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3852 buf &= ~MAC_TX_TXEN_;
3853 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3854 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3855 buf &= ~MAC_RX_RXEN_;
3856 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3858 ret = lan78xx_write_reg(dev, WUCSR, 0);
3859 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3860 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3862 /* set goodframe wakeup */
3863 ret = lan78xx_read_reg(dev, WUCSR, &buf);
3865 buf |= WUCSR_RFE_WAKE_EN_;
3866 buf |= WUCSR_STORE_WAKE_;
3868 ret = lan78xx_write_reg(dev, WUCSR, buf);
3870 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3872 buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
3873 buf |= PMT_CTL_RES_CLR_WKP_STS_;
3875 buf |= PMT_CTL_PHY_WAKE_EN_;
3876 buf |= PMT_CTL_WOL_EN_;
3877 buf &= ~PMT_CTL_SUS_MODE_MASK_;
3878 buf |= PMT_CTL_SUS_MODE_3_;
3880 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3882 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3884 buf |= PMT_CTL_WUPS_MASK_;
3886 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3888 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3889 buf |= MAC_RX_RXEN_;
3890 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3892 lan78xx_set_suspend(dev, pdata->wol);
3901 static int lan78xx_resume(struct usb_interface *intf)
3903 struct lan78xx_net *dev = usb_get_intfdata(intf);
3904 struct sk_buff *skb;
3909 if (!timer_pending(&dev->stat_monitor)) {
3911 mod_timer(&dev->stat_monitor,
3912 jiffies + STAT_UPDATE_TIMER);
3915 if (!--dev->suspend_count) {
3916 /* resume interrupt URBs */
3917 if (dev->urb_intr && test_bit(EVENT_DEV_OPEN, &dev->flags))
3918 usb_submit_urb(dev->urb_intr, GFP_NOIO);
3920 spin_lock_irq(&dev->txq.lock);
3921 while ((res = usb_get_from_anchor(&dev->deferred))) {
3922 skb = (struct sk_buff *)res->context;
3923 ret = usb_submit_urb(res, GFP_ATOMIC);
3925 dev_kfree_skb_any(skb);
3927 usb_autopm_put_interface_async(dev->intf);
3929 netif_trans_update(dev->net);
3930 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3934 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
3935 spin_unlock_irq(&dev->txq.lock);
3937 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
3938 if (!(skb_queue_len(&dev->txq) >= dev->tx_qlen))
3939 netif_start_queue(dev->net);
3940 tasklet_schedule(&dev->bh);
3944 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3945 ret = lan78xx_write_reg(dev, WUCSR, 0);
3946 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3948 ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
3950 WUCSR2_IPV6_TCPSYN_RCD_ |
3951 WUCSR2_IPV4_TCPSYN_RCD_);
3953 ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
3954 WUCSR_EEE_RX_WAKE_ |
3956 WUCSR_RFE_WAKE_FR_ |
3961 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3962 buf |= MAC_TX_TXEN_;
3963 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3968 static int lan78xx_reset_resume(struct usb_interface *intf)
3970 struct lan78xx_net *dev = usb_get_intfdata(intf);
3974 lan78xx_phy_init(dev);
3976 return lan78xx_resume(intf);
3979 static const struct usb_device_id products[] = {
3981 /* LAN7800 USB Gigabit Ethernet Device */
3982 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
3985 /* LAN7850 USB Gigabit Ethernet Device */
3986 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
3989 /* LAN7801 USB Gigabit Ethernet Device */
3990 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
3994 MODULE_DEVICE_TABLE(usb, products);
3996 static struct usb_driver lan78xx_driver = {
3997 .name = DRIVER_NAME,
3998 .id_table = products,
3999 .probe = lan78xx_probe,
4000 .disconnect = lan78xx_disconnect,
4001 .suspend = lan78xx_suspend,
4002 .resume = lan78xx_resume,
4003 .reset_resume = lan78xx_reset_resume,
4004 .supports_autosuspend = 1,
4005 .disable_hub_initiated_lpm = 1,
4008 module_usb_driver(lan78xx_driver);
4010 MODULE_AUTHOR(DRIVER_AUTHOR);
4011 MODULE_DESCRIPTION(DRIVER_DESC);
4012 MODULE_LICENSE("GPL");