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 <linux/phy.h>
33 #include <net/ip6_checksum.h>
34 #include <linux/interrupt.h>
35 #include <linux/irqdomain.h>
36 #include <linux/irq.h>
37 #include <linux/irqchip/chained_irq.h>
38 #include <linux/microchipphy.h>
39 #include <linux/phy.h>
42 #define DRIVER_AUTHOR "WOOJUNG HUH <woojung.huh@microchip.com>"
43 #define DRIVER_DESC "LAN78XX USB 3.0 Gigabit Ethernet Devices"
44 #define DRIVER_NAME "lan78xx"
45 #define DRIVER_VERSION "1.0.6"
47 #define TX_TIMEOUT_JIFFIES (5 * HZ)
48 #define THROTTLE_JIFFIES (HZ / 8)
49 #define UNLINK_TIMEOUT_MS 3
51 #define RX_MAX_QUEUE_MEMORY (60 * 1518)
53 #define SS_USB_PKT_SIZE (1024)
54 #define HS_USB_PKT_SIZE (512)
55 #define FS_USB_PKT_SIZE (64)
57 #define MAX_RX_FIFO_SIZE (12 * 1024)
58 #define MAX_TX_FIFO_SIZE (12 * 1024)
59 #define DEFAULT_BURST_CAP_SIZE (MAX_TX_FIFO_SIZE)
60 #define DEFAULT_BULK_IN_DELAY (0x0800)
61 #define MAX_SINGLE_PACKET_SIZE (9000)
62 #define DEFAULT_TX_CSUM_ENABLE (true)
63 #define DEFAULT_RX_CSUM_ENABLE (true)
64 #define DEFAULT_TSO_CSUM_ENABLE (true)
65 #define DEFAULT_VLAN_FILTER_ENABLE (true)
66 #define TX_OVERHEAD (8)
69 #define LAN78XX_USB_VENDOR_ID (0x0424)
70 #define LAN7800_USB_PRODUCT_ID (0x7800)
71 #define LAN7850_USB_PRODUCT_ID (0x7850)
72 #define LAN7801_USB_PRODUCT_ID (0x7801)
73 #define LAN78XX_EEPROM_MAGIC (0x78A5)
74 #define LAN78XX_OTP_MAGIC (0x78F3)
79 #define EEPROM_INDICATOR (0xA5)
80 #define EEPROM_MAC_OFFSET (0x01)
81 #define MAX_EEPROM_SIZE 512
82 #define OTP_INDICATOR_1 (0xF3)
83 #define OTP_INDICATOR_2 (0xF7)
85 #define WAKE_ALL (WAKE_PHY | WAKE_UCAST | \
86 WAKE_MCAST | WAKE_BCAST | \
87 WAKE_ARP | WAKE_MAGIC)
89 /* USB related defines */
90 #define BULK_IN_PIPE 1
91 #define BULK_OUT_PIPE 2
93 /* default autosuspend delay (mSec)*/
94 #define DEFAULT_AUTOSUSPEND_DELAY (10 * 1000)
96 /* statistic update interval (mSec) */
97 #define STAT_UPDATE_TIMER (1 * 1000)
99 /* defines interrupts from interrupt EP */
100 #define MAX_INT_EP (32)
101 #define INT_EP_INTEP (31)
102 #define INT_EP_OTP_WR_DONE (28)
103 #define INT_EP_EEE_TX_LPI_START (26)
104 #define INT_EP_EEE_TX_LPI_STOP (25)
105 #define INT_EP_EEE_RX_LPI (24)
106 #define INT_EP_MAC_RESET_TIMEOUT (23)
107 #define INT_EP_RDFO (22)
108 #define INT_EP_TXE (21)
109 #define INT_EP_USB_STATUS (20)
110 #define INT_EP_TX_DIS (19)
111 #define INT_EP_RX_DIS (18)
112 #define INT_EP_PHY (17)
113 #define INT_EP_DP (16)
114 #define INT_EP_MAC_ERR (15)
115 #define INT_EP_TDFU (14)
116 #define INT_EP_TDFO (13)
117 #define INT_EP_UTX (12)
118 #define INT_EP_GPIO_11 (11)
119 #define INT_EP_GPIO_10 (10)
120 #define INT_EP_GPIO_9 (9)
121 #define INT_EP_GPIO_8 (8)
122 #define INT_EP_GPIO_7 (7)
123 #define INT_EP_GPIO_6 (6)
124 #define INT_EP_GPIO_5 (5)
125 #define INT_EP_GPIO_4 (4)
126 #define INT_EP_GPIO_3 (3)
127 #define INT_EP_GPIO_2 (2)
128 #define INT_EP_GPIO_1 (1)
129 #define INT_EP_GPIO_0 (0)
131 static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {
133 "RX Alignment Errors",
134 "Rx Fragment Errors",
136 "RX Undersize Frame Errors",
137 "RX Oversize Frame Errors",
139 "RX Unicast Byte Count",
140 "RX Broadcast Byte Count",
141 "RX Multicast Byte Count",
143 "RX Broadcast Frames",
144 "RX Multicast Frames",
147 "RX 65 - 127 Byte Frames",
148 "RX 128 - 255 Byte Frames",
149 "RX 256 - 511 Bytes Frames",
150 "RX 512 - 1023 Byte Frames",
151 "RX 1024 - 1518 Byte Frames",
152 "RX Greater 1518 Byte Frames",
153 "EEE RX LPI Transitions",
156 "TX Excess Deferral Errors",
159 "TX Single Collisions",
160 "TX Multiple Collisions",
161 "TX Excessive Collision",
162 "TX Late Collisions",
163 "TX Unicast Byte Count",
164 "TX Broadcast Byte Count",
165 "TX Multicast Byte Count",
167 "TX Broadcast Frames",
168 "TX Multicast Frames",
171 "TX 65 - 127 Byte Frames",
172 "TX 128 - 255 Byte Frames",
173 "TX 256 - 511 Bytes Frames",
174 "TX 512 - 1023 Byte Frames",
175 "TX 1024 - 1518 Byte Frames",
176 "TX Greater 1518 Byte Frames",
177 "EEE TX LPI Transitions",
181 struct lan78xx_statstage {
183 u32 rx_alignment_errors;
184 u32 rx_fragment_errors;
185 u32 rx_jabber_errors;
186 u32 rx_undersize_frame_errors;
187 u32 rx_oversize_frame_errors;
188 u32 rx_dropped_frames;
189 u32 rx_unicast_byte_count;
190 u32 rx_broadcast_byte_count;
191 u32 rx_multicast_byte_count;
192 u32 rx_unicast_frames;
193 u32 rx_broadcast_frames;
194 u32 rx_multicast_frames;
196 u32 rx_64_byte_frames;
197 u32 rx_65_127_byte_frames;
198 u32 rx_128_255_byte_frames;
199 u32 rx_256_511_bytes_frames;
200 u32 rx_512_1023_byte_frames;
201 u32 rx_1024_1518_byte_frames;
202 u32 rx_greater_1518_byte_frames;
203 u32 eee_rx_lpi_transitions;
206 u32 tx_excess_deferral_errors;
207 u32 tx_carrier_errors;
208 u32 tx_bad_byte_count;
209 u32 tx_single_collisions;
210 u32 tx_multiple_collisions;
211 u32 tx_excessive_collision;
212 u32 tx_late_collisions;
213 u32 tx_unicast_byte_count;
214 u32 tx_broadcast_byte_count;
215 u32 tx_multicast_byte_count;
216 u32 tx_unicast_frames;
217 u32 tx_broadcast_frames;
218 u32 tx_multicast_frames;
220 u32 tx_64_byte_frames;
221 u32 tx_65_127_byte_frames;
222 u32 tx_128_255_byte_frames;
223 u32 tx_256_511_bytes_frames;
224 u32 tx_512_1023_byte_frames;
225 u32 tx_1024_1518_byte_frames;
226 u32 tx_greater_1518_byte_frames;
227 u32 eee_tx_lpi_transitions;
231 struct lan78xx_statstage64 {
233 u64 rx_alignment_errors;
234 u64 rx_fragment_errors;
235 u64 rx_jabber_errors;
236 u64 rx_undersize_frame_errors;
237 u64 rx_oversize_frame_errors;
238 u64 rx_dropped_frames;
239 u64 rx_unicast_byte_count;
240 u64 rx_broadcast_byte_count;
241 u64 rx_multicast_byte_count;
242 u64 rx_unicast_frames;
243 u64 rx_broadcast_frames;
244 u64 rx_multicast_frames;
246 u64 rx_64_byte_frames;
247 u64 rx_65_127_byte_frames;
248 u64 rx_128_255_byte_frames;
249 u64 rx_256_511_bytes_frames;
250 u64 rx_512_1023_byte_frames;
251 u64 rx_1024_1518_byte_frames;
252 u64 rx_greater_1518_byte_frames;
253 u64 eee_rx_lpi_transitions;
256 u64 tx_excess_deferral_errors;
257 u64 tx_carrier_errors;
258 u64 tx_bad_byte_count;
259 u64 tx_single_collisions;
260 u64 tx_multiple_collisions;
261 u64 tx_excessive_collision;
262 u64 tx_late_collisions;
263 u64 tx_unicast_byte_count;
264 u64 tx_broadcast_byte_count;
265 u64 tx_multicast_byte_count;
266 u64 tx_unicast_frames;
267 u64 tx_broadcast_frames;
268 u64 tx_multicast_frames;
270 u64 tx_64_byte_frames;
271 u64 tx_65_127_byte_frames;
272 u64 tx_128_255_byte_frames;
273 u64 tx_256_511_bytes_frames;
274 u64 tx_512_1023_byte_frames;
275 u64 tx_1024_1518_byte_frames;
276 u64 tx_greater_1518_byte_frames;
277 u64 eee_tx_lpi_transitions;
283 struct lan78xx_priv {
284 struct lan78xx_net *dev;
286 u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicat hash table */
287 u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */
288 u32 vlan_table[DP_SEL_VHF_VLAN_LEN];
289 struct mutex dataport_mutex; /* for dataport access */
290 spinlock_t rfe_ctl_lock; /* for rfe register access */
291 struct work_struct set_multicast;
292 struct work_struct set_vlan;
306 struct skb_data { /* skb->cb is one of these */
308 struct lan78xx_net *dev;
309 enum skb_state state;
315 struct usb_ctrlrequest req;
316 struct lan78xx_net *dev;
319 #define EVENT_TX_HALT 0
320 #define EVENT_RX_HALT 1
321 #define EVENT_RX_MEMORY 2
322 #define EVENT_STS_SPLIT 3
323 #define EVENT_LINK_RESET 4
324 #define EVENT_RX_PAUSED 5
325 #define EVENT_DEV_WAKING 6
326 #define EVENT_DEV_ASLEEP 7
327 #define EVENT_DEV_OPEN 8
328 #define EVENT_STAT_UPDATE 9
331 struct mutex access_lock; /* for stats access */
332 struct lan78xx_statstage saved;
333 struct lan78xx_statstage rollover_count;
334 struct lan78xx_statstage rollover_max;
335 struct lan78xx_statstage64 curr_stat;
338 struct irq_domain_data {
339 struct irq_domain *irqdomain;
341 struct irq_chip *irqchip;
342 irq_flow_handler_t irq_handler;
344 struct mutex irq_lock; /* for irq bus access */
348 struct net_device *net;
349 struct usb_device *udev;
350 struct usb_interface *intf;
355 struct sk_buff_head rxq;
356 struct sk_buff_head txq;
357 struct sk_buff_head done;
358 struct sk_buff_head rxq_pause;
359 struct sk_buff_head txq_pend;
361 struct tasklet_struct bh;
362 struct delayed_work wq;
364 struct usb_host_endpoint *ep_blkin;
365 struct usb_host_endpoint *ep_blkout;
366 struct usb_host_endpoint *ep_intr;
370 struct urb *urb_intr;
371 struct usb_anchor deferred;
373 struct mutex phy_mutex; /* for phy access */
374 unsigned pipe_in, pipe_out, pipe_intr;
376 u32 hard_mtu; /* count any extra framing */
377 size_t rx_urb_size; /* size for rx urbs */
381 wait_queue_head_t *wait;
382 unsigned char suspend_count;
385 struct timer_list delay;
386 struct timer_list stat_monitor;
388 unsigned long data[5];
395 struct mii_bus *mdiobus;
396 phy_interface_t interface;
399 u8 fc_request_control;
402 struct statstage stats;
404 struct irq_domain_data domain_data;
407 /* define external phy id */
408 #define PHY_LAN8835 (0x0007C130)
409 #define PHY_KSZ9031RNX (0x00221620)
411 /* use ethtool to change the level for any given device */
412 static int msg_level = -1;
413 module_param(msg_level, int, 0);
414 MODULE_PARM_DESC(msg_level, "Override default message level");
416 static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
418 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
424 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
425 USB_VENDOR_REQUEST_READ_REGISTER,
426 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
427 0, index, buf, 4, USB_CTRL_GET_TIMEOUT);
428 if (likely(ret >= 0)) {
432 netdev_warn(dev->net,
433 "Failed to read register index 0x%08x. ret = %d",
442 static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
444 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
453 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
454 USB_VENDOR_REQUEST_WRITE_REGISTER,
455 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
456 0, index, buf, 4, USB_CTRL_SET_TIMEOUT);
457 if (unlikely(ret < 0)) {
458 netdev_warn(dev->net,
459 "Failed to write register index 0x%08x. ret = %d",
468 static int lan78xx_read_stats(struct lan78xx_net *dev,
469 struct lan78xx_statstage *data)
473 struct lan78xx_statstage *stats;
477 stats = kmalloc(sizeof(*stats), GFP_KERNEL);
481 ret = usb_control_msg(dev->udev,
482 usb_rcvctrlpipe(dev->udev, 0),
483 USB_VENDOR_REQUEST_GET_STATS,
484 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
489 USB_CTRL_SET_TIMEOUT);
490 if (likely(ret >= 0)) {
493 for (i = 0; i < sizeof(*stats)/sizeof(u32); i++) {
494 le32_to_cpus(&src[i]);
498 netdev_warn(dev->net,
499 "Failed to read stat ret = 0x%x", ret);
507 #define check_counter_rollover(struct1, dev_stats, member) { \
508 if (struct1->member < dev_stats.saved.member) \
509 dev_stats.rollover_count.member++; \
512 static void lan78xx_check_stat_rollover(struct lan78xx_net *dev,
513 struct lan78xx_statstage *stats)
515 check_counter_rollover(stats, dev->stats, rx_fcs_errors);
516 check_counter_rollover(stats, dev->stats, rx_alignment_errors);
517 check_counter_rollover(stats, dev->stats, rx_fragment_errors);
518 check_counter_rollover(stats, dev->stats, rx_jabber_errors);
519 check_counter_rollover(stats, dev->stats, rx_undersize_frame_errors);
520 check_counter_rollover(stats, dev->stats, rx_oversize_frame_errors);
521 check_counter_rollover(stats, dev->stats, rx_dropped_frames);
522 check_counter_rollover(stats, dev->stats, rx_unicast_byte_count);
523 check_counter_rollover(stats, dev->stats, rx_broadcast_byte_count);
524 check_counter_rollover(stats, dev->stats, rx_multicast_byte_count);
525 check_counter_rollover(stats, dev->stats, rx_unicast_frames);
526 check_counter_rollover(stats, dev->stats, rx_broadcast_frames);
527 check_counter_rollover(stats, dev->stats, rx_multicast_frames);
528 check_counter_rollover(stats, dev->stats, rx_pause_frames);
529 check_counter_rollover(stats, dev->stats, rx_64_byte_frames);
530 check_counter_rollover(stats, dev->stats, rx_65_127_byte_frames);
531 check_counter_rollover(stats, dev->stats, rx_128_255_byte_frames);
532 check_counter_rollover(stats, dev->stats, rx_256_511_bytes_frames);
533 check_counter_rollover(stats, dev->stats, rx_512_1023_byte_frames);
534 check_counter_rollover(stats, dev->stats, rx_1024_1518_byte_frames);
535 check_counter_rollover(stats, dev->stats, rx_greater_1518_byte_frames);
536 check_counter_rollover(stats, dev->stats, eee_rx_lpi_transitions);
537 check_counter_rollover(stats, dev->stats, eee_rx_lpi_time);
538 check_counter_rollover(stats, dev->stats, tx_fcs_errors);
539 check_counter_rollover(stats, dev->stats, tx_excess_deferral_errors);
540 check_counter_rollover(stats, dev->stats, tx_carrier_errors);
541 check_counter_rollover(stats, dev->stats, tx_bad_byte_count);
542 check_counter_rollover(stats, dev->stats, tx_single_collisions);
543 check_counter_rollover(stats, dev->stats, tx_multiple_collisions);
544 check_counter_rollover(stats, dev->stats, tx_excessive_collision);
545 check_counter_rollover(stats, dev->stats, tx_late_collisions);
546 check_counter_rollover(stats, dev->stats, tx_unicast_byte_count);
547 check_counter_rollover(stats, dev->stats, tx_broadcast_byte_count);
548 check_counter_rollover(stats, dev->stats, tx_multicast_byte_count);
549 check_counter_rollover(stats, dev->stats, tx_unicast_frames);
550 check_counter_rollover(stats, dev->stats, tx_broadcast_frames);
551 check_counter_rollover(stats, dev->stats, tx_multicast_frames);
552 check_counter_rollover(stats, dev->stats, tx_pause_frames);
553 check_counter_rollover(stats, dev->stats, tx_64_byte_frames);
554 check_counter_rollover(stats, dev->stats, tx_65_127_byte_frames);
555 check_counter_rollover(stats, dev->stats, tx_128_255_byte_frames);
556 check_counter_rollover(stats, dev->stats, tx_256_511_bytes_frames);
557 check_counter_rollover(stats, dev->stats, tx_512_1023_byte_frames);
558 check_counter_rollover(stats, dev->stats, tx_1024_1518_byte_frames);
559 check_counter_rollover(stats, dev->stats, tx_greater_1518_byte_frames);
560 check_counter_rollover(stats, dev->stats, eee_tx_lpi_transitions);
561 check_counter_rollover(stats, dev->stats, eee_tx_lpi_time);
563 memcpy(&dev->stats.saved, stats, sizeof(struct lan78xx_statstage));
566 static void lan78xx_update_stats(struct lan78xx_net *dev)
568 u32 *p, *count, *max;
571 struct lan78xx_statstage lan78xx_stats;
573 if (usb_autopm_get_interface(dev->intf) < 0)
576 p = (u32 *)&lan78xx_stats;
577 count = (u32 *)&dev->stats.rollover_count;
578 max = (u32 *)&dev->stats.rollover_max;
579 data = (u64 *)&dev->stats.curr_stat;
581 mutex_lock(&dev->stats.access_lock);
583 if (lan78xx_read_stats(dev, &lan78xx_stats) > 0)
584 lan78xx_check_stat_rollover(dev, &lan78xx_stats);
586 for (i = 0; i < (sizeof(lan78xx_stats) / (sizeof(u32))); i++)
587 data[i] = (u64)p[i] + ((u64)count[i] * ((u64)max[i] + 1));
589 mutex_unlock(&dev->stats.access_lock);
591 usb_autopm_put_interface(dev->intf);
594 /* Loop until the read is completed with timeout called with phy_mutex held */
595 static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)
597 unsigned long start_time = jiffies;
602 ret = lan78xx_read_reg(dev, MII_ACC, &val);
603 if (unlikely(ret < 0))
606 if (!(val & MII_ACC_MII_BUSY_))
608 } while (!time_after(jiffies, start_time + HZ));
613 static inline u32 mii_access(int id, int index, int read)
617 ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;
618 ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;
620 ret |= MII_ACC_MII_READ_;
622 ret |= MII_ACC_MII_WRITE_;
623 ret |= MII_ACC_MII_BUSY_;
628 static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
630 unsigned long start_time = jiffies;
635 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
636 if (unlikely(ret < 0))
639 if (!(val & E2P_CMD_EPC_BUSY_) ||
640 (val & E2P_CMD_EPC_TIMEOUT_))
642 usleep_range(40, 100);
643 } while (!time_after(jiffies, start_time + HZ));
645 if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
646 netdev_warn(dev->net, "EEPROM read operation timeout");
653 static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
655 unsigned long start_time = jiffies;
660 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
661 if (unlikely(ret < 0))
664 if (!(val & E2P_CMD_EPC_BUSY_))
667 usleep_range(40, 100);
668 } while (!time_after(jiffies, start_time + HZ));
670 netdev_warn(dev->net, "EEPROM is busy");
674 static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
675 u32 length, u8 *data)
682 /* depends on chip, some EEPROM pins are muxed with LED function.
683 * disable & restore LED function to access EEPROM.
685 ret = lan78xx_read_reg(dev, HW_CFG, &val);
687 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
688 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
689 ret = lan78xx_write_reg(dev, HW_CFG, val);
692 retval = lan78xx_eeprom_confirm_not_busy(dev);
696 for (i = 0; i < length; i++) {
697 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
698 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
699 ret = lan78xx_write_reg(dev, E2P_CMD, val);
700 if (unlikely(ret < 0)) {
705 retval = lan78xx_wait_eeprom(dev);
709 ret = lan78xx_read_reg(dev, E2P_DATA, &val);
710 if (unlikely(ret < 0)) {
715 data[i] = val & 0xFF;
721 if (dev->chipid == ID_REV_CHIP_ID_7800_)
722 ret = lan78xx_write_reg(dev, HW_CFG, saved);
727 static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
728 u32 length, u8 *data)
733 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
734 if ((ret == 0) && (sig == EEPROM_INDICATOR))
735 ret = lan78xx_read_raw_eeprom(dev, offset, length, data);
742 static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
743 u32 length, u8 *data)
750 /* depends on chip, some EEPROM pins are muxed with LED function.
751 * disable & restore LED function to access EEPROM.
753 ret = lan78xx_read_reg(dev, HW_CFG, &val);
755 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
756 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
757 ret = lan78xx_write_reg(dev, HW_CFG, val);
760 retval = lan78xx_eeprom_confirm_not_busy(dev);
764 /* Issue write/erase enable command */
765 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
766 ret = lan78xx_write_reg(dev, E2P_CMD, val);
767 if (unlikely(ret < 0)) {
772 retval = lan78xx_wait_eeprom(dev);
776 for (i = 0; i < length; i++) {
777 /* Fill data register */
779 ret = lan78xx_write_reg(dev, E2P_DATA, val);
785 /* Send "write" command */
786 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
787 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
788 ret = lan78xx_write_reg(dev, E2P_CMD, val);
794 retval = lan78xx_wait_eeprom(dev);
803 if (dev->chipid == ID_REV_CHIP_ID_7800_)
804 ret = lan78xx_write_reg(dev, HW_CFG, saved);
809 static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
810 u32 length, u8 *data)
815 unsigned long timeout;
817 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
819 if (buf & OTP_PWR_DN_PWRDN_N_) {
820 /* clear it and wait to be cleared */
821 ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
823 timeout = jiffies + HZ;
826 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
827 if (time_after(jiffies, timeout)) {
828 netdev_warn(dev->net,
829 "timeout on OTP_PWR_DN");
832 } while (buf & OTP_PWR_DN_PWRDN_N_);
835 for (i = 0; i < length; i++) {
836 ret = lan78xx_write_reg(dev, OTP_ADDR1,
837 ((offset + i) >> 8) & OTP_ADDR1_15_11);
838 ret = lan78xx_write_reg(dev, OTP_ADDR2,
839 ((offset + i) & OTP_ADDR2_10_3));
841 ret = lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
842 ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
844 timeout = jiffies + HZ;
847 ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
848 if (time_after(jiffies, timeout)) {
849 netdev_warn(dev->net,
850 "timeout on OTP_STATUS");
853 } while (buf & OTP_STATUS_BUSY_);
855 ret = lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
857 data[i] = (u8)(buf & 0xFF);
863 static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
864 u32 length, u8 *data)
869 unsigned long timeout;
871 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
873 if (buf & OTP_PWR_DN_PWRDN_N_) {
874 /* clear it and wait to be cleared */
875 ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
877 timeout = jiffies + HZ;
880 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
881 if (time_after(jiffies, timeout)) {
882 netdev_warn(dev->net,
883 "timeout on OTP_PWR_DN completion");
886 } while (buf & OTP_PWR_DN_PWRDN_N_);
889 /* set to BYTE program mode */
890 ret = lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
892 for (i = 0; i < length; i++) {
893 ret = lan78xx_write_reg(dev, OTP_ADDR1,
894 ((offset + i) >> 8) & OTP_ADDR1_15_11);
895 ret = lan78xx_write_reg(dev, OTP_ADDR2,
896 ((offset + i) & OTP_ADDR2_10_3));
897 ret = lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
898 ret = lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
899 ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
901 timeout = jiffies + HZ;
904 ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
905 if (time_after(jiffies, timeout)) {
906 netdev_warn(dev->net,
907 "Timeout on OTP_STATUS completion");
910 } while (buf & OTP_STATUS_BUSY_);
916 static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
917 u32 length, u8 *data)
922 ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
925 if (sig == OTP_INDICATOR_1)
927 else if (sig == OTP_INDICATOR_2)
931 ret = lan78xx_read_raw_otp(dev, offset, length, data);
937 static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
941 for (i = 0; i < 100; i++) {
944 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
945 if (unlikely(ret < 0))
948 if (dp_sel & DP_SEL_DPRDY_)
951 usleep_range(40, 100);
954 netdev_warn(dev->net, "lan78xx_dataport_wait_not_busy timed out");
959 static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
960 u32 addr, u32 length, u32 *buf)
962 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
966 if (usb_autopm_get_interface(dev->intf) < 0)
969 mutex_lock(&pdata->dataport_mutex);
971 ret = lan78xx_dataport_wait_not_busy(dev);
975 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
977 dp_sel &= ~DP_SEL_RSEL_MASK_;
978 dp_sel |= ram_select;
979 ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);
981 for (i = 0; i < length; i++) {
982 ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
984 ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
986 ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
988 ret = lan78xx_dataport_wait_not_busy(dev);
994 mutex_unlock(&pdata->dataport_mutex);
995 usb_autopm_put_interface(dev->intf);
1000 static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,
1001 int index, u8 addr[ETH_ALEN])
1005 if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {
1007 temp = addr[2] | (temp << 8);
1008 temp = addr[1] | (temp << 8);
1009 temp = addr[0] | (temp << 8);
1010 pdata->pfilter_table[index][1] = temp;
1012 temp = addr[4] | (temp << 8);
1013 temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;
1014 pdata->pfilter_table[index][0] = temp;
1018 /* returns hash bit number for given MAC address */
1019 static inline u32 lan78xx_hash(char addr[ETH_ALEN])
1021 return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
1024 static void lan78xx_deferred_multicast_write(struct work_struct *param)
1026 struct lan78xx_priv *pdata =
1027 container_of(param, struct lan78xx_priv, set_multicast);
1028 struct lan78xx_net *dev = pdata->dev;
1032 netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
1035 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,
1036 DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
1038 for (i = 1; i < NUM_OF_MAF; i++) {
1039 ret = lan78xx_write_reg(dev, MAF_HI(i), 0);
1040 ret = lan78xx_write_reg(dev, MAF_LO(i),
1041 pdata->pfilter_table[i][1]);
1042 ret = lan78xx_write_reg(dev, MAF_HI(i),
1043 pdata->pfilter_table[i][0]);
1046 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1049 static void lan78xx_set_multicast(struct net_device *netdev)
1051 struct lan78xx_net *dev = netdev_priv(netdev);
1052 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1053 unsigned long flags;
1056 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1058 pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |
1059 RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
1061 for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
1062 pdata->mchash_table[i] = 0;
1063 /* pfilter_table[0] has own HW address */
1064 for (i = 1; i < NUM_OF_MAF; i++) {
1065 pdata->pfilter_table[i][0] =
1066 pdata->pfilter_table[i][1] = 0;
1069 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;
1071 if (dev->net->flags & IFF_PROMISC) {
1072 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
1073 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;
1075 if (dev->net->flags & IFF_ALLMULTI) {
1076 netif_dbg(dev, drv, dev->net,
1077 "receive all multicast enabled");
1078 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;
1082 if (netdev_mc_count(dev->net)) {
1083 struct netdev_hw_addr *ha;
1086 netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
1088 pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;
1091 netdev_for_each_mc_addr(ha, netdev) {
1092 /* set first 32 into Perfect Filter */
1094 lan78xx_set_addr_filter(pdata, i, ha->addr);
1096 u32 bitnum = lan78xx_hash(ha->addr);
1098 pdata->mchash_table[bitnum / 32] |=
1099 (1 << (bitnum % 32));
1100 pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;
1106 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1108 /* defer register writes to a sleepable context */
1109 schedule_work(&pdata->set_multicast);
1112 static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1113 u16 lcladv, u16 rmtadv)
1115 u32 flow = 0, fct_flow = 0;
1119 if (dev->fc_autoneg)
1120 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1122 cap = dev->fc_request_control;
1124 if (cap & FLOW_CTRL_TX)
1125 flow |= (FLOW_CR_TX_FCEN_ | 0xFFFF);
1127 if (cap & FLOW_CTRL_RX)
1128 flow |= FLOW_CR_RX_FCEN_;
1130 if (dev->udev->speed == USB_SPEED_SUPER)
1132 else if (dev->udev->speed == USB_SPEED_HIGH)
1135 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1136 (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
1137 (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
1139 ret = lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1141 /* threshold value should be set before enabling flow */
1142 ret = lan78xx_write_reg(dev, FLOW, flow);
1147 static int lan78xx_link_reset(struct lan78xx_net *dev)
1149 struct phy_device *phydev = dev->net->phydev;
1150 struct ethtool_link_ksettings ecmd;
1151 int ladv, radv, ret;
1154 /* clear LAN78xx interrupt status */
1155 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1156 if (unlikely(ret < 0))
1159 phy_read_status(phydev);
1161 if (!phydev->link && dev->link_on) {
1162 dev->link_on = false;
1165 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1166 if (unlikely(ret < 0))
1169 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1170 if (unlikely(ret < 0))
1173 del_timer(&dev->stat_monitor);
1174 } else if (phydev->link && !dev->link_on) {
1175 dev->link_on = true;
1177 phy_ethtool_ksettings_get(phydev, &ecmd);
1179 if (dev->udev->speed == USB_SPEED_SUPER) {
1180 if (ecmd.base.speed == 1000) {
1182 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1183 buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1184 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1186 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1187 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1188 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1190 /* enable U1 & U2 */
1191 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1192 buf |= USB_CFG1_DEV_U2_INIT_EN_;
1193 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1194 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1198 ladv = phy_read(phydev, MII_ADVERTISE);
1202 radv = phy_read(phydev, MII_LPA);
1206 netif_dbg(dev, link, dev->net,
1207 "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1208 ecmd.base.speed, ecmd.base.duplex, ladv, radv);
1210 ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,
1213 if (!timer_pending(&dev->stat_monitor)) {
1215 mod_timer(&dev->stat_monitor,
1216 jiffies + STAT_UPDATE_TIMER);
1223 /* some work can't be done in tasklets, so we use keventd
1225 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
1226 * but tasklet_schedule() doesn't. hope the failure is rare.
1228 static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1230 set_bit(work, &dev->flags);
1231 if (!schedule_delayed_work(&dev->wq, 0))
1232 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1235 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1239 if (urb->actual_length != 4) {
1240 netdev_warn(dev->net,
1241 "unexpected urb length %d", urb->actual_length);
1245 memcpy(&intdata, urb->transfer_buffer, 4);
1246 le32_to_cpus(&intdata);
1248 if (intdata & INT_ENP_PHY_INT) {
1249 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1250 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1252 if (dev->domain_data.phyirq > 0)
1253 generic_handle_irq(dev->domain_data.phyirq);
1255 netdev_warn(dev->net,
1256 "unexpected interrupt: 0x%08x\n", intdata);
1259 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1261 return MAX_EEPROM_SIZE;
1264 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1265 struct ethtool_eeprom *ee, u8 *data)
1267 struct lan78xx_net *dev = netdev_priv(netdev);
1270 ret = usb_autopm_get_interface(dev->intf);
1274 ee->magic = LAN78XX_EEPROM_MAGIC;
1276 ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1278 usb_autopm_put_interface(dev->intf);
1283 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1284 struct ethtool_eeprom *ee, u8 *data)
1286 struct lan78xx_net *dev = netdev_priv(netdev);
1289 ret = usb_autopm_get_interface(dev->intf);
1293 /* Invalid EEPROM_INDICATOR at offset zero will result in a failure
1294 * to load data from EEPROM
1296 if (ee->magic == LAN78XX_EEPROM_MAGIC)
1297 ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1298 else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1299 (ee->offset == 0) &&
1301 (data[0] == OTP_INDICATOR_1))
1302 ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1304 usb_autopm_put_interface(dev->intf);
1309 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1312 if (stringset == ETH_SS_STATS)
1313 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1316 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1318 if (sset == ETH_SS_STATS)
1319 return ARRAY_SIZE(lan78xx_gstrings);
1324 static void lan78xx_get_stats(struct net_device *netdev,
1325 struct ethtool_stats *stats, u64 *data)
1327 struct lan78xx_net *dev = netdev_priv(netdev);
1329 lan78xx_update_stats(dev);
1331 mutex_lock(&dev->stats.access_lock);
1332 memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1333 mutex_unlock(&dev->stats.access_lock);
1336 static void lan78xx_get_wol(struct net_device *netdev,
1337 struct ethtool_wolinfo *wol)
1339 struct lan78xx_net *dev = netdev_priv(netdev);
1342 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1344 if (usb_autopm_get_interface(dev->intf) < 0)
1347 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1348 if (unlikely(ret < 0)) {
1352 if (buf & USB_CFG_RMT_WKP_) {
1353 wol->supported = WAKE_ALL;
1354 wol->wolopts = pdata->wol;
1361 usb_autopm_put_interface(dev->intf);
1364 static int lan78xx_set_wol(struct net_device *netdev,
1365 struct ethtool_wolinfo *wol)
1367 struct lan78xx_net *dev = netdev_priv(netdev);
1368 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1371 ret = usb_autopm_get_interface(dev->intf);
1376 if (wol->wolopts & WAKE_UCAST)
1377 pdata->wol |= WAKE_UCAST;
1378 if (wol->wolopts & WAKE_MCAST)
1379 pdata->wol |= WAKE_MCAST;
1380 if (wol->wolopts & WAKE_BCAST)
1381 pdata->wol |= WAKE_BCAST;
1382 if (wol->wolopts & WAKE_MAGIC)
1383 pdata->wol |= WAKE_MAGIC;
1384 if (wol->wolopts & WAKE_PHY)
1385 pdata->wol |= WAKE_PHY;
1386 if (wol->wolopts & WAKE_ARP)
1387 pdata->wol |= WAKE_ARP;
1389 device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1391 phy_ethtool_set_wol(netdev->phydev, wol);
1393 usb_autopm_put_interface(dev->intf);
1398 static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1400 struct lan78xx_net *dev = netdev_priv(net);
1401 struct phy_device *phydev = net->phydev;
1405 ret = usb_autopm_get_interface(dev->intf);
1409 ret = phy_ethtool_get_eee(phydev, edata);
1413 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1414 if (buf & MAC_CR_EEE_EN_) {
1415 edata->eee_enabled = true;
1416 edata->eee_active = !!(edata->advertised &
1417 edata->lp_advertised);
1418 edata->tx_lpi_enabled = true;
1419 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1420 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1421 edata->tx_lpi_timer = buf;
1423 edata->eee_enabled = false;
1424 edata->eee_active = false;
1425 edata->tx_lpi_enabled = false;
1426 edata->tx_lpi_timer = 0;
1431 usb_autopm_put_interface(dev->intf);
1436 static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1438 struct lan78xx_net *dev = netdev_priv(net);
1442 ret = usb_autopm_get_interface(dev->intf);
1446 if (edata->eee_enabled) {
1447 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1448 buf |= MAC_CR_EEE_EN_;
1449 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1451 phy_ethtool_set_eee(net->phydev, edata);
1453 buf = (u32)edata->tx_lpi_timer;
1454 ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1456 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1457 buf &= ~MAC_CR_EEE_EN_;
1458 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1461 usb_autopm_put_interface(dev->intf);
1466 static u32 lan78xx_get_link(struct net_device *net)
1468 phy_read_status(net->phydev);
1470 return net->phydev->link;
1473 static void lan78xx_get_drvinfo(struct net_device *net,
1474 struct ethtool_drvinfo *info)
1476 struct lan78xx_net *dev = netdev_priv(net);
1478 strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1479 strncpy(info->version, DRIVER_VERSION, sizeof(info->version));
1480 usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1483 static u32 lan78xx_get_msglevel(struct net_device *net)
1485 struct lan78xx_net *dev = netdev_priv(net);
1487 return dev->msg_enable;
1490 static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1492 struct lan78xx_net *dev = netdev_priv(net);
1494 dev->msg_enable = level;
1497 static int lan78xx_get_link_ksettings(struct net_device *net,
1498 struct ethtool_link_ksettings *cmd)
1500 struct lan78xx_net *dev = netdev_priv(net);
1501 struct phy_device *phydev = net->phydev;
1504 ret = usb_autopm_get_interface(dev->intf);
1508 phy_ethtool_ksettings_get(phydev, cmd);
1510 usb_autopm_put_interface(dev->intf);
1515 static int lan78xx_set_link_ksettings(struct net_device *net,
1516 const struct ethtool_link_ksettings *cmd)
1518 struct lan78xx_net *dev = netdev_priv(net);
1519 struct phy_device *phydev = net->phydev;
1523 ret = usb_autopm_get_interface(dev->intf);
1527 /* change speed & duplex */
1528 ret = phy_ethtool_ksettings_set(phydev, cmd);
1530 if (!cmd->base.autoneg) {
1531 /* force link down */
1532 temp = phy_read(phydev, MII_BMCR);
1533 phy_write(phydev, MII_BMCR, temp | BMCR_LOOPBACK);
1535 phy_write(phydev, MII_BMCR, temp);
1538 usb_autopm_put_interface(dev->intf);
1543 static void lan78xx_get_pause(struct net_device *net,
1544 struct ethtool_pauseparam *pause)
1546 struct lan78xx_net *dev = netdev_priv(net);
1547 struct phy_device *phydev = net->phydev;
1548 struct ethtool_link_ksettings ecmd;
1550 phy_ethtool_ksettings_get(phydev, &ecmd);
1552 pause->autoneg = dev->fc_autoneg;
1554 if (dev->fc_request_control & FLOW_CTRL_TX)
1555 pause->tx_pause = 1;
1557 if (dev->fc_request_control & FLOW_CTRL_RX)
1558 pause->rx_pause = 1;
1561 static int lan78xx_set_pause(struct net_device *net,
1562 struct ethtool_pauseparam *pause)
1564 struct lan78xx_net *dev = netdev_priv(net);
1565 struct phy_device *phydev = net->phydev;
1566 struct ethtool_link_ksettings ecmd;
1569 phy_ethtool_ksettings_get(phydev, &ecmd);
1571 if (pause->autoneg && !ecmd.base.autoneg) {
1576 dev->fc_request_control = 0;
1577 if (pause->rx_pause)
1578 dev->fc_request_control |= FLOW_CTRL_RX;
1580 if (pause->tx_pause)
1581 dev->fc_request_control |= FLOW_CTRL_TX;
1583 if (ecmd.base.autoneg) {
1587 ethtool_convert_link_mode_to_legacy_u32(
1588 &advertising, ecmd.link_modes.advertising);
1590 advertising &= ~(ADVERTISED_Pause | ADVERTISED_Asym_Pause);
1591 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
1592 advertising |= mii_adv_to_ethtool_adv_t(mii_adv);
1594 ethtool_convert_legacy_u32_to_link_mode(
1595 ecmd.link_modes.advertising, advertising);
1597 phy_ethtool_ksettings_set(phydev, &ecmd);
1600 dev->fc_autoneg = pause->autoneg;
1607 static const struct ethtool_ops lan78xx_ethtool_ops = {
1608 .get_link = lan78xx_get_link,
1609 .nway_reset = phy_ethtool_nway_reset,
1610 .get_drvinfo = lan78xx_get_drvinfo,
1611 .get_msglevel = lan78xx_get_msglevel,
1612 .set_msglevel = lan78xx_set_msglevel,
1613 .get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1614 .get_eeprom = lan78xx_ethtool_get_eeprom,
1615 .set_eeprom = lan78xx_ethtool_set_eeprom,
1616 .get_ethtool_stats = lan78xx_get_stats,
1617 .get_sset_count = lan78xx_get_sset_count,
1618 .get_strings = lan78xx_get_strings,
1619 .get_wol = lan78xx_get_wol,
1620 .set_wol = lan78xx_set_wol,
1621 .get_eee = lan78xx_get_eee,
1622 .set_eee = lan78xx_set_eee,
1623 .get_pauseparam = lan78xx_get_pause,
1624 .set_pauseparam = lan78xx_set_pause,
1625 .get_link_ksettings = lan78xx_get_link_ksettings,
1626 .set_link_ksettings = lan78xx_set_link_ksettings,
1629 static int lan78xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
1631 if (!netif_running(netdev))
1634 return phy_mii_ioctl(netdev->phydev, rq, cmd);
1637 static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1639 u32 addr_lo, addr_hi;
1643 ret = lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1644 ret = lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1646 addr[0] = addr_lo & 0xFF;
1647 addr[1] = (addr_lo >> 8) & 0xFF;
1648 addr[2] = (addr_lo >> 16) & 0xFF;
1649 addr[3] = (addr_lo >> 24) & 0xFF;
1650 addr[4] = addr_hi & 0xFF;
1651 addr[5] = (addr_hi >> 8) & 0xFF;
1653 if (!is_valid_ether_addr(addr)) {
1654 /* reading mac address from EEPROM or OTP */
1655 if ((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
1657 (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
1659 if (is_valid_ether_addr(addr)) {
1660 /* eeprom values are valid so use them */
1661 netif_dbg(dev, ifup, dev->net,
1662 "MAC address read from EEPROM");
1664 /* generate random MAC */
1665 random_ether_addr(addr);
1666 netif_dbg(dev, ifup, dev->net,
1667 "MAC address set to random addr");
1670 addr_lo = addr[0] | (addr[1] << 8) |
1671 (addr[2] << 16) | (addr[3] << 24);
1672 addr_hi = addr[4] | (addr[5] << 8);
1674 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1675 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1677 /* generate random MAC */
1678 random_ether_addr(addr);
1679 netif_dbg(dev, ifup, dev->net,
1680 "MAC address set to random addr");
1684 ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1685 ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1687 ether_addr_copy(dev->net->dev_addr, addr);
1690 /* MDIO read and write wrappers for phylib */
1691 static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
1693 struct lan78xx_net *dev = bus->priv;
1697 ret = usb_autopm_get_interface(dev->intf);
1701 mutex_lock(&dev->phy_mutex);
1703 /* confirm MII not busy */
1704 ret = lan78xx_phy_wait_not_busy(dev);
1708 /* set the address, index & direction (read from PHY) */
1709 addr = mii_access(phy_id, idx, MII_READ);
1710 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1712 ret = lan78xx_phy_wait_not_busy(dev);
1716 ret = lan78xx_read_reg(dev, MII_DATA, &val);
1718 ret = (int)(val & 0xFFFF);
1721 mutex_unlock(&dev->phy_mutex);
1722 usb_autopm_put_interface(dev->intf);
1727 static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
1730 struct lan78xx_net *dev = bus->priv;
1734 ret = usb_autopm_get_interface(dev->intf);
1738 mutex_lock(&dev->phy_mutex);
1740 /* confirm MII not busy */
1741 ret = lan78xx_phy_wait_not_busy(dev);
1746 ret = lan78xx_write_reg(dev, MII_DATA, val);
1748 /* set the address, index & direction (write to PHY) */
1749 addr = mii_access(phy_id, idx, MII_WRITE);
1750 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1752 ret = lan78xx_phy_wait_not_busy(dev);
1757 mutex_unlock(&dev->phy_mutex);
1758 usb_autopm_put_interface(dev->intf);
1762 static int lan78xx_mdio_init(struct lan78xx_net *dev)
1766 dev->mdiobus = mdiobus_alloc();
1767 if (!dev->mdiobus) {
1768 netdev_err(dev->net, "can't allocate MDIO bus\n");
1772 dev->mdiobus->priv = (void *)dev;
1773 dev->mdiobus->read = lan78xx_mdiobus_read;
1774 dev->mdiobus->write = lan78xx_mdiobus_write;
1775 dev->mdiobus->name = "lan78xx-mdiobus";
1777 snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
1778 dev->udev->bus->busnum, dev->udev->devnum);
1780 switch (dev->chipid) {
1781 case ID_REV_CHIP_ID_7800_:
1782 case ID_REV_CHIP_ID_7850_:
1783 /* set to internal PHY id */
1784 dev->mdiobus->phy_mask = ~(1 << 1);
1786 case ID_REV_CHIP_ID_7801_:
1787 /* scan thru PHYAD[2..0] */
1788 dev->mdiobus->phy_mask = ~(0xFF);
1792 ret = mdiobus_register(dev->mdiobus);
1794 netdev_err(dev->net, "can't register MDIO bus\n");
1798 netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
1801 mdiobus_free(dev->mdiobus);
1805 static void lan78xx_remove_mdio(struct lan78xx_net *dev)
1807 mdiobus_unregister(dev->mdiobus);
1808 mdiobus_free(dev->mdiobus);
1811 static void lan78xx_link_status_change(struct net_device *net)
1813 struct phy_device *phydev = net->phydev;
1816 /* At forced 100 F/H mode, chip may fail to set mode correctly
1817 * when cable is switched between long(~50+m) and short one.
1818 * As workaround, set to 10 before setting to 100
1819 * at forced 100 F/H mode.
1821 if (!phydev->autoneg && (phydev->speed == 100)) {
1822 /* disable phy interrupt */
1823 temp = phy_read(phydev, LAN88XX_INT_MASK);
1824 temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_;
1825 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1827 temp = phy_read(phydev, MII_BMCR);
1828 temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000);
1829 phy_write(phydev, MII_BMCR, temp); /* set to 10 first */
1830 temp |= BMCR_SPEED100;
1831 phy_write(phydev, MII_BMCR, temp); /* set to 100 later */
1833 /* clear pending interrupt generated while workaround */
1834 temp = phy_read(phydev, LAN88XX_INT_STS);
1836 /* enable phy interrupt back */
1837 temp = phy_read(phydev, LAN88XX_INT_MASK);
1838 temp |= LAN88XX_INT_MASK_MDINTPIN_EN_;
1839 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1843 static int irq_map(struct irq_domain *d, unsigned int irq,
1844 irq_hw_number_t hwirq)
1846 struct irq_domain_data *data = d->host_data;
1848 irq_set_chip_data(irq, data);
1849 irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);
1850 irq_set_noprobe(irq);
1855 static void irq_unmap(struct irq_domain *d, unsigned int irq)
1857 irq_set_chip_and_handler(irq, NULL, NULL);
1858 irq_set_chip_data(irq, NULL);
1861 static const struct irq_domain_ops chip_domain_ops = {
1866 static void lan78xx_irq_mask(struct irq_data *irqd)
1868 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1870 data->irqenable &= ~BIT(irqd_to_hwirq(irqd));
1873 static void lan78xx_irq_unmask(struct irq_data *irqd)
1875 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1877 data->irqenable |= BIT(irqd_to_hwirq(irqd));
1880 static void lan78xx_irq_bus_lock(struct irq_data *irqd)
1882 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1884 mutex_lock(&data->irq_lock);
1887 static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
1889 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1890 struct lan78xx_net *dev =
1891 container_of(data, struct lan78xx_net, domain_data);
1895 /* call register access here because irq_bus_lock & irq_bus_sync_unlock
1896 * are only two callbacks executed in non-atomic contex.
1898 ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1899 if (buf != data->irqenable)
1900 ret = lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
1902 mutex_unlock(&data->irq_lock);
1905 static struct irq_chip lan78xx_irqchip = {
1906 .name = "lan78xx-irqs",
1907 .irq_mask = lan78xx_irq_mask,
1908 .irq_unmask = lan78xx_irq_unmask,
1909 .irq_bus_lock = lan78xx_irq_bus_lock,
1910 .irq_bus_sync_unlock = lan78xx_irq_bus_sync_unlock,
1913 static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
1915 struct device_node *of_node;
1916 struct irq_domain *irqdomain;
1917 unsigned int irqmap = 0;
1921 of_node = dev->udev->dev.parent->of_node;
1923 mutex_init(&dev->domain_data.irq_lock);
1925 lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1926 dev->domain_data.irqenable = buf;
1928 dev->domain_data.irqchip = &lan78xx_irqchip;
1929 dev->domain_data.irq_handler = handle_simple_irq;
1931 irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,
1932 &chip_domain_ops, &dev->domain_data);
1934 /* create mapping for PHY interrupt */
1935 irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);
1937 irq_domain_remove(irqdomain);
1946 dev->domain_data.irqdomain = irqdomain;
1947 dev->domain_data.phyirq = irqmap;
1952 static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
1954 if (dev->domain_data.phyirq > 0) {
1955 irq_dispose_mapping(dev->domain_data.phyirq);
1957 if (dev->domain_data.irqdomain)
1958 irq_domain_remove(dev->domain_data.irqdomain);
1960 dev->domain_data.phyirq = 0;
1961 dev->domain_data.irqdomain = NULL;
1964 static int lan8835_fixup(struct phy_device *phydev)
1968 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
1970 /* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */
1971 buf = phy_read_mmd(phydev, MDIO_MMD_PCS, 0x8010);
1974 phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf);
1976 /* RGMII MAC TXC Delay Enable */
1977 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
1978 MAC_RGMII_ID_TXC_DELAY_EN_);
1980 /* RGMII TX DLL Tune Adjust */
1981 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
1983 dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
1988 static int ksz9031rnx_fixup(struct phy_device *phydev)
1990 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
1992 /* Micrel9301RNX PHY configuration */
1993 /* RGMII Control Signal Pad Skew */
1994 phy_write_mmd(phydev, MDIO_MMD_WIS, 4, 0x0077);
1995 /* RGMII RX Data Pad Skew */
1996 phy_write_mmd(phydev, MDIO_MMD_WIS, 5, 0x7777);
1997 /* RGMII RX Clock Pad Skew */
1998 phy_write_mmd(phydev, MDIO_MMD_WIS, 8, 0x1FF);
2000 dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;
2005 static int lan78xx_phy_init(struct lan78xx_net *dev)
2009 struct phy_device *phydev;
2011 phydev = phy_find_first(dev->mdiobus);
2013 netdev_err(dev->net, "no PHY found\n");
2017 if ((dev->chipid == ID_REV_CHIP_ID_7800_) ||
2018 (dev->chipid == ID_REV_CHIP_ID_7850_)) {
2019 phydev->is_internal = true;
2020 dev->interface = PHY_INTERFACE_MODE_GMII;
2022 } else if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2024 netdev_err(dev->net, "no PHY driver found\n");
2028 dev->interface = PHY_INTERFACE_MODE_RGMII;
2030 /* external PHY fixup for KSZ9031RNX */
2031 ret = phy_register_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0,
2034 netdev_err(dev->net, "fail to register fixup\n");
2037 /* external PHY fixup for LAN8835 */
2038 ret = phy_register_fixup_for_uid(PHY_LAN8835, 0xfffffff0,
2041 netdev_err(dev->net, "fail to register fixup\n");
2044 /* add more external PHY fixup here if needed */
2046 phydev->is_internal = false;
2048 netdev_err(dev->net, "unknown ID found\n");
2053 /* if phyirq is not set, use polling mode in phylib */
2054 if (dev->domain_data.phyirq > 0)
2055 phydev->irq = dev->domain_data.phyirq;
2058 netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2060 /* set to AUTOMDIX */
2061 phydev->mdix = ETH_TP_MDI_AUTO;
2063 ret = phy_connect_direct(dev->net, phydev,
2064 lan78xx_link_status_change,
2067 netdev_err(dev->net, "can't attach PHY to %s\n",
2072 /* MAC doesn't support 1000T Half */
2073 phydev->supported &= ~SUPPORTED_1000baseT_Half;
2075 /* support both flow controls */
2076 dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2077 phydev->advertising &= ~(ADVERTISED_Pause | ADVERTISED_Asym_Pause);
2078 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2079 phydev->advertising |= mii_adv_to_ethtool_adv_t(mii_adv);
2081 genphy_config_aneg(phydev);
2083 dev->fc_autoneg = phydev->autoneg;
2087 netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
2092 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
2093 phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
2098 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2104 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2106 rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2109 buf &= ~MAC_RX_RXEN_;
2110 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2113 /* add 4 to size for FCS */
2114 buf &= ~MAC_RX_MAX_SIZE_MASK_;
2115 buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2117 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2120 buf |= MAC_RX_RXEN_;
2121 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2127 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2129 struct sk_buff *skb;
2130 unsigned long flags;
2133 spin_lock_irqsave(&q->lock, flags);
2134 while (!skb_queue_empty(q)) {
2135 struct skb_data *entry;
2139 skb_queue_walk(q, skb) {
2140 entry = (struct skb_data *)skb->cb;
2141 if (entry->state != unlink_start)
2146 entry->state = unlink_start;
2149 /* Get reference count of the URB to avoid it to be
2150 * freed during usb_unlink_urb, which may trigger
2151 * use-after-free problem inside usb_unlink_urb since
2152 * usb_unlink_urb is always racing with .complete
2153 * handler(include defer_bh).
2156 spin_unlock_irqrestore(&q->lock, flags);
2157 /* during some PM-driven resume scenarios,
2158 * these (async) unlinks complete immediately
2160 ret = usb_unlink_urb(urb);
2161 if (ret != -EINPROGRESS && ret != 0)
2162 netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2166 spin_lock_irqsave(&q->lock, flags);
2168 spin_unlock_irqrestore(&q->lock, flags);
2172 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2174 struct lan78xx_net *dev = netdev_priv(netdev);
2175 int ll_mtu = new_mtu + netdev->hard_header_len;
2176 int old_hard_mtu = dev->hard_mtu;
2177 int old_rx_urb_size = dev->rx_urb_size;
2180 /* no second zero-length packet read wanted after mtu-sized packets */
2181 if ((ll_mtu % dev->maxpacket) == 0)
2184 ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + ETH_HLEN);
2186 netdev->mtu = new_mtu;
2188 dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
2189 if (dev->rx_urb_size == old_hard_mtu) {
2190 dev->rx_urb_size = dev->hard_mtu;
2191 if (dev->rx_urb_size > old_rx_urb_size) {
2192 if (netif_running(dev->net)) {
2193 unlink_urbs(dev, &dev->rxq);
2194 tasklet_schedule(&dev->bh);
2202 static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2204 struct lan78xx_net *dev = netdev_priv(netdev);
2205 struct sockaddr *addr = p;
2206 u32 addr_lo, addr_hi;
2209 if (netif_running(netdev))
2212 if (!is_valid_ether_addr(addr->sa_data))
2213 return -EADDRNOTAVAIL;
2215 ether_addr_copy(netdev->dev_addr, addr->sa_data);
2217 addr_lo = netdev->dev_addr[0] |
2218 netdev->dev_addr[1] << 8 |
2219 netdev->dev_addr[2] << 16 |
2220 netdev->dev_addr[3] << 24;
2221 addr_hi = netdev->dev_addr[4] |
2222 netdev->dev_addr[5] << 8;
2224 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2225 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2230 /* Enable or disable Rx checksum offload engine */
2231 static int lan78xx_set_features(struct net_device *netdev,
2232 netdev_features_t features)
2234 struct lan78xx_net *dev = netdev_priv(netdev);
2235 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2236 unsigned long flags;
2239 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2241 if (features & NETIF_F_RXCSUM) {
2242 pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
2243 pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
2245 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2246 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2249 if (features & NETIF_F_HW_VLAN_CTAG_RX)
2250 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2252 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2254 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2256 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2261 static void lan78xx_deferred_vlan_write(struct work_struct *param)
2263 struct lan78xx_priv *pdata =
2264 container_of(param, struct lan78xx_priv, set_vlan);
2265 struct lan78xx_net *dev = pdata->dev;
2267 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2268 DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2271 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2272 __be16 proto, u16 vid)
2274 struct lan78xx_net *dev = netdev_priv(netdev);
2275 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2277 u16 vid_dword_index;
2279 vid_dword_index = (vid >> 5) & 0x7F;
2280 vid_bit_index = vid & 0x1F;
2282 pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2284 /* defer register writes to a sleepable context */
2285 schedule_work(&pdata->set_vlan);
2290 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2291 __be16 proto, u16 vid)
2293 struct lan78xx_net *dev = netdev_priv(netdev);
2294 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2296 u16 vid_dword_index;
2298 vid_dword_index = (vid >> 5) & 0x7F;
2299 vid_bit_index = vid & 0x1F;
2301 pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2303 /* defer register writes to a sleepable context */
2304 schedule_work(&pdata->set_vlan);
2309 static void lan78xx_init_ltm(struct lan78xx_net *dev)
2313 u32 regs[6] = { 0 };
2315 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2316 if (buf & USB_CFG1_LTM_ENABLE_) {
2318 /* Get values from EEPROM first */
2319 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2320 if (temp[0] == 24) {
2321 ret = lan78xx_read_raw_eeprom(dev,
2328 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2329 if (temp[0] == 24) {
2330 ret = lan78xx_read_raw_otp(dev,
2340 lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2341 lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2342 lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2343 lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2344 lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2345 lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2348 static int lan78xx_reset(struct lan78xx_net *dev)
2350 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2353 unsigned long timeout;
2356 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2357 buf |= HW_CFG_LRST_;
2358 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2360 timeout = jiffies + HZ;
2363 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2364 if (time_after(jiffies, timeout)) {
2365 netdev_warn(dev->net,
2366 "timeout on completion of LiteReset");
2369 } while (buf & HW_CFG_LRST_);
2371 lan78xx_init_mac_address(dev);
2373 /* save DEVID for later usage */
2374 ret = lan78xx_read_reg(dev, ID_REV, &buf);
2375 dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2376 dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2378 /* Respond to the IN token with a NAK */
2379 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2380 buf |= USB_CFG_BIR_;
2381 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2384 lan78xx_init_ltm(dev);
2386 if (dev->udev->speed == USB_SPEED_SUPER) {
2387 buf = DEFAULT_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2388 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2391 } else if (dev->udev->speed == USB_SPEED_HIGH) {
2392 buf = DEFAULT_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2393 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2394 dev->rx_qlen = RX_MAX_QUEUE_MEMORY / dev->rx_urb_size;
2395 dev->tx_qlen = RX_MAX_QUEUE_MEMORY / dev->hard_mtu;
2397 buf = DEFAULT_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2398 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2403 ret = lan78xx_write_reg(dev, BURST_CAP, buf);
2404 ret = lan78xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
2406 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2408 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2410 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2411 buf |= USB_CFG_BCE_;
2412 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2414 /* set FIFO sizes */
2415 buf = (MAX_RX_FIFO_SIZE - 512) / 512;
2416 ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2418 buf = (MAX_TX_FIFO_SIZE - 512) / 512;
2419 ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2421 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2422 ret = lan78xx_write_reg(dev, FLOW, 0);
2423 ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2425 /* Don't need rfe_ctl_lock during initialisation */
2426 ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2427 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
2428 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2430 /* Enable or disable checksum offload engines */
2431 lan78xx_set_features(dev->net, dev->net->features);
2433 lan78xx_set_multicast(dev->net);
2436 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2437 buf |= PMT_CTL_PHY_RST_;
2438 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
2440 timeout = jiffies + HZ;
2443 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2444 if (time_after(jiffies, timeout)) {
2445 netdev_warn(dev->net, "timeout waiting for PHY Reset");
2448 } while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
2450 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
2451 /* LAN7801 only has RGMII mode */
2452 if (dev->chipid == ID_REV_CHIP_ID_7801_)
2453 buf &= ~MAC_CR_GMII_EN_;
2455 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
2456 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
2457 if (!ret && sig != EEPROM_INDICATOR) {
2458 /* Implies there is no external eeprom. Set mac speed */
2459 netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");
2460 buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
2463 ret = lan78xx_write_reg(dev, MAC_CR, buf);
2465 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
2466 buf |= MAC_TX_TXEN_;
2467 ret = lan78xx_write_reg(dev, MAC_TX, buf);
2469 ret = lan78xx_read_reg(dev, FCT_TX_CTL, &buf);
2470 buf |= FCT_TX_CTL_EN_;
2471 ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
2473 ret = lan78xx_set_rx_max_frame_length(dev, dev->net->mtu + ETH_HLEN);
2475 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2476 buf |= MAC_RX_RXEN_;
2477 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2479 ret = lan78xx_read_reg(dev, FCT_RX_CTL, &buf);
2480 buf |= FCT_RX_CTL_EN_;
2481 ret = lan78xx_write_reg(dev, FCT_RX_CTL, buf);
2486 static void lan78xx_init_stats(struct lan78xx_net *dev)
2491 /* initialize for stats update
2492 * some counters are 20bits and some are 32bits
2494 p = (u32 *)&dev->stats.rollover_max;
2495 for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
2498 dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
2499 dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
2500 dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
2501 dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
2502 dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
2503 dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
2504 dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
2505 dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
2506 dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
2507 dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
2509 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
2512 static int lan78xx_open(struct net_device *net)
2514 struct lan78xx_net *dev = netdev_priv(net);
2517 ret = usb_autopm_get_interface(dev->intf);
2521 ret = lan78xx_reset(dev);
2525 ret = lan78xx_phy_init(dev);
2529 /* for Link Check */
2530 if (dev->urb_intr) {
2531 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
2533 netif_err(dev, ifup, dev->net,
2534 "intr submit %d\n", ret);
2539 lan78xx_init_stats(dev);
2541 set_bit(EVENT_DEV_OPEN, &dev->flags);
2543 netif_start_queue(net);
2545 dev->link_on = false;
2547 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
2549 usb_autopm_put_interface(dev->intf);
2555 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
2557 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
2558 DECLARE_WAITQUEUE(wait, current);
2561 /* ensure there are no more active urbs */
2562 add_wait_queue(&unlink_wakeup, &wait);
2563 set_current_state(TASK_UNINTERRUPTIBLE);
2564 dev->wait = &unlink_wakeup;
2565 temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
2567 /* maybe wait for deletions to finish. */
2568 while (!skb_queue_empty(&dev->rxq) &&
2569 !skb_queue_empty(&dev->txq) &&
2570 !skb_queue_empty(&dev->done)) {
2571 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
2572 set_current_state(TASK_UNINTERRUPTIBLE);
2573 netif_dbg(dev, ifdown, dev->net,
2574 "waited for %d urb completions\n", temp);
2576 set_current_state(TASK_RUNNING);
2578 remove_wait_queue(&unlink_wakeup, &wait);
2581 static int lan78xx_stop(struct net_device *net)
2583 struct lan78xx_net *dev = netdev_priv(net);
2585 if (timer_pending(&dev->stat_monitor))
2586 del_timer_sync(&dev->stat_monitor);
2588 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
2589 phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
2591 phy_stop(net->phydev);
2592 phy_disconnect(net->phydev);
2596 clear_bit(EVENT_DEV_OPEN, &dev->flags);
2597 netif_stop_queue(net);
2599 netif_info(dev, ifdown, dev->net,
2600 "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
2601 net->stats.rx_packets, net->stats.tx_packets,
2602 net->stats.rx_errors, net->stats.tx_errors);
2604 lan78xx_terminate_urbs(dev);
2606 usb_kill_urb(dev->urb_intr);
2608 skb_queue_purge(&dev->rxq_pause);
2610 /* deferred work (task, timer, softirq) must also stop.
2611 * can't flush_scheduled_work() until we drop rtnl (later),
2612 * else workers could deadlock; so make workers a NOP.
2615 cancel_delayed_work_sync(&dev->wq);
2616 tasklet_kill(&dev->bh);
2618 usb_autopm_put_interface(dev->intf);
2623 static int lan78xx_linearize(struct sk_buff *skb)
2625 return skb_linearize(skb);
2628 static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
2629 struct sk_buff *skb, gfp_t flags)
2631 u32 tx_cmd_a, tx_cmd_b;
2633 if (skb_cow_head(skb, TX_OVERHEAD)) {
2634 dev_kfree_skb_any(skb);
2638 if (lan78xx_linearize(skb) < 0)
2641 tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
2643 if (skb->ip_summed == CHECKSUM_PARTIAL)
2644 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
2647 if (skb_is_gso(skb)) {
2648 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
2650 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
2652 tx_cmd_a |= TX_CMD_A_LSO_;
2655 if (skb_vlan_tag_present(skb)) {
2656 tx_cmd_a |= TX_CMD_A_IVTG_;
2657 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
2661 cpu_to_le32s(&tx_cmd_b);
2662 memcpy(skb->data, &tx_cmd_b, 4);
2665 cpu_to_le32s(&tx_cmd_a);
2666 memcpy(skb->data, &tx_cmd_a, 4);
2671 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
2672 struct sk_buff_head *list, enum skb_state state)
2674 unsigned long flags;
2675 enum skb_state old_state;
2676 struct skb_data *entry = (struct skb_data *)skb->cb;
2678 spin_lock_irqsave(&list->lock, flags);
2679 old_state = entry->state;
2680 entry->state = state;
2682 __skb_unlink(skb, list);
2683 spin_unlock(&list->lock);
2684 spin_lock(&dev->done.lock);
2686 __skb_queue_tail(&dev->done, skb);
2687 if (skb_queue_len(&dev->done) == 1)
2688 tasklet_schedule(&dev->bh);
2689 spin_unlock_irqrestore(&dev->done.lock, flags);
2694 static void tx_complete(struct urb *urb)
2696 struct sk_buff *skb = (struct sk_buff *)urb->context;
2697 struct skb_data *entry = (struct skb_data *)skb->cb;
2698 struct lan78xx_net *dev = entry->dev;
2700 if (urb->status == 0) {
2701 dev->net->stats.tx_packets += entry->num_of_packet;
2702 dev->net->stats.tx_bytes += entry->length;
2704 dev->net->stats.tx_errors++;
2706 switch (urb->status) {
2708 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2711 /* software-driven interface shutdown */
2719 netif_stop_queue(dev->net);
2722 netif_dbg(dev, tx_err, dev->net,
2723 "tx err %d\n", entry->urb->status);
2728 usb_autopm_put_interface_async(dev->intf);
2730 defer_bh(dev, skb, &dev->txq, tx_done);
2733 static void lan78xx_queue_skb(struct sk_buff_head *list,
2734 struct sk_buff *newsk, enum skb_state state)
2736 struct skb_data *entry = (struct skb_data *)newsk->cb;
2738 __skb_queue_tail(list, newsk);
2739 entry->state = state;
2743 lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
2745 struct lan78xx_net *dev = netdev_priv(net);
2746 struct sk_buff *skb2 = NULL;
2749 skb_tx_timestamp(skb);
2750 skb2 = lan78xx_tx_prep(dev, skb, GFP_ATOMIC);
2754 skb_queue_tail(&dev->txq_pend, skb2);
2756 /* throttle TX patch at slower than SUPER SPEED USB */
2757 if ((dev->udev->speed < USB_SPEED_SUPER) &&
2758 (skb_queue_len(&dev->txq_pend) > 10))
2759 netif_stop_queue(net);
2761 netif_dbg(dev, tx_err, dev->net,
2762 "lan78xx_tx_prep return NULL\n");
2763 dev->net->stats.tx_errors++;
2764 dev->net->stats.tx_dropped++;
2767 tasklet_schedule(&dev->bh);
2769 return NETDEV_TX_OK;
2773 lan78xx_get_endpoints(struct lan78xx_net *dev, struct usb_interface *intf)
2776 struct usb_host_interface *alt = NULL;
2777 struct usb_host_endpoint *in = NULL, *out = NULL;
2778 struct usb_host_endpoint *status = NULL;
2780 for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
2786 alt = intf->altsetting + tmp;
2788 for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
2789 struct usb_host_endpoint *e;
2792 e = alt->endpoint + ep;
2793 switch (e->desc.bmAttributes) {
2794 case USB_ENDPOINT_XFER_INT:
2795 if (!usb_endpoint_dir_in(&e->desc))
2799 case USB_ENDPOINT_XFER_BULK:
2804 if (usb_endpoint_dir_in(&e->desc)) {
2807 else if (intr && !status)
2817 if (!alt || !in || !out)
2820 dev->pipe_in = usb_rcvbulkpipe(dev->udev,
2821 in->desc.bEndpointAddress &
2822 USB_ENDPOINT_NUMBER_MASK);
2823 dev->pipe_out = usb_sndbulkpipe(dev->udev,
2824 out->desc.bEndpointAddress &
2825 USB_ENDPOINT_NUMBER_MASK);
2826 dev->ep_intr = status;
2831 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
2833 struct lan78xx_priv *pdata = NULL;
2837 ret = lan78xx_get_endpoints(dev, intf);
2839 dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
2841 pdata = (struct lan78xx_priv *)(dev->data[0]);
2843 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
2849 spin_lock_init(&pdata->rfe_ctl_lock);
2850 mutex_init(&pdata->dataport_mutex);
2852 INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
2854 for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
2855 pdata->vlan_table[i] = 0;
2857 INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
2859 dev->net->features = 0;
2861 if (DEFAULT_TX_CSUM_ENABLE)
2862 dev->net->features |= NETIF_F_HW_CSUM;
2864 if (DEFAULT_RX_CSUM_ENABLE)
2865 dev->net->features |= NETIF_F_RXCSUM;
2867 if (DEFAULT_TSO_CSUM_ENABLE)
2868 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
2870 dev->net->hw_features = dev->net->features;
2872 ret = lan78xx_setup_irq_domain(dev);
2874 netdev_warn(dev->net,
2875 "lan78xx_setup_irq_domain() failed : %d", ret);
2879 dev->net->hard_header_len += TX_OVERHEAD;
2880 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
2882 /* Init all registers */
2883 ret = lan78xx_reset(dev);
2885 netdev_warn(dev->net, "Registers INIT FAILED....");
2889 ret = lan78xx_mdio_init(dev);
2891 netdev_warn(dev->net, "MDIO INIT FAILED.....");
2895 dev->net->flags |= IFF_MULTICAST;
2897 pdata->wol = WAKE_MAGIC;
2902 lan78xx_remove_irq_domain(dev);
2905 netdev_warn(dev->net, "Bind routine FAILED");
2906 cancel_work_sync(&pdata->set_multicast);
2907 cancel_work_sync(&pdata->set_vlan);
2912 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
2914 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2916 lan78xx_remove_irq_domain(dev);
2918 lan78xx_remove_mdio(dev);
2921 cancel_work_sync(&pdata->set_multicast);
2922 cancel_work_sync(&pdata->set_vlan);
2923 netif_dbg(dev, ifdown, dev->net, "free pdata");
2930 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
2931 struct sk_buff *skb,
2932 u32 rx_cmd_a, u32 rx_cmd_b)
2934 if (!(dev->net->features & NETIF_F_RXCSUM) ||
2935 unlikely(rx_cmd_a & RX_CMD_A_ICSM_)) {
2936 skb->ip_summed = CHECKSUM_NONE;
2938 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
2939 skb->ip_summed = CHECKSUM_COMPLETE;
2943 static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
2947 if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
2948 skb_queue_tail(&dev->rxq_pause, skb);
2952 dev->net->stats.rx_packets++;
2953 dev->net->stats.rx_bytes += skb->len;
2955 skb->protocol = eth_type_trans(skb, dev->net);
2957 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
2958 skb->len + sizeof(struct ethhdr), skb->protocol);
2959 memset(skb->cb, 0, sizeof(struct skb_data));
2961 if (skb_defer_rx_timestamp(skb))
2964 status = netif_rx(skb);
2965 if (status != NET_RX_SUCCESS)
2966 netif_dbg(dev, rx_err, dev->net,
2967 "netif_rx status %d\n", status);
2970 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb)
2972 if (skb->len < dev->net->hard_header_len)
2975 while (skb->len > 0) {
2976 u32 rx_cmd_a, rx_cmd_b, align_count, size;
2978 struct sk_buff *skb2;
2979 unsigned char *packet;
2981 memcpy(&rx_cmd_a, skb->data, sizeof(rx_cmd_a));
2982 le32_to_cpus(&rx_cmd_a);
2983 skb_pull(skb, sizeof(rx_cmd_a));
2985 memcpy(&rx_cmd_b, skb->data, sizeof(rx_cmd_b));
2986 le32_to_cpus(&rx_cmd_b);
2987 skb_pull(skb, sizeof(rx_cmd_b));
2989 memcpy(&rx_cmd_c, skb->data, sizeof(rx_cmd_c));
2990 le16_to_cpus(&rx_cmd_c);
2991 skb_pull(skb, sizeof(rx_cmd_c));
2995 /* get the packet length */
2996 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
2997 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
2999 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
3000 netif_dbg(dev, rx_err, dev->net,
3001 "Error rx_cmd_a=0x%08x", rx_cmd_a);
3003 /* last frame in this batch */
3004 if (skb->len == size) {
3005 lan78xx_rx_csum_offload(dev, skb,
3006 rx_cmd_a, rx_cmd_b);
3008 skb_trim(skb, skb->len - 4); /* remove fcs */
3009 skb->truesize = size + sizeof(struct sk_buff);
3014 skb2 = skb_clone(skb, GFP_ATOMIC);
3015 if (unlikely(!skb2)) {
3016 netdev_warn(dev->net, "Error allocating skb");
3021 skb2->data = packet;
3022 skb_set_tail_pointer(skb2, size);
3024 lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3026 skb_trim(skb2, skb2->len - 4); /* remove fcs */
3027 skb2->truesize = size + sizeof(struct sk_buff);
3029 lan78xx_skb_return(dev, skb2);
3032 skb_pull(skb, size);
3034 /* padding bytes before the next frame starts */
3036 skb_pull(skb, align_count);
3042 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb)
3044 if (!lan78xx_rx(dev, skb)) {
3045 dev->net->stats.rx_errors++;
3050 lan78xx_skb_return(dev, skb);
3054 netif_dbg(dev, rx_err, dev->net, "drop\n");
3055 dev->net->stats.rx_errors++;
3057 skb_queue_tail(&dev->done, skb);
3060 static void rx_complete(struct urb *urb);
3062 static int rx_submit(struct lan78xx_net *dev, struct urb *urb, gfp_t flags)
3064 struct sk_buff *skb;
3065 struct skb_data *entry;
3066 unsigned long lockflags;
3067 size_t size = dev->rx_urb_size;
3070 skb = netdev_alloc_skb_ip_align(dev->net, size);
3076 entry = (struct skb_data *)skb->cb;
3081 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3082 skb->data, size, rx_complete, skb);
3084 spin_lock_irqsave(&dev->rxq.lock, lockflags);
3086 if (netif_device_present(dev->net) &&
3087 netif_running(dev->net) &&
3088 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3089 !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3090 ret = usb_submit_urb(urb, GFP_ATOMIC);
3093 lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3096 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3099 netif_dbg(dev, ifdown, dev->net, "device gone\n");
3100 netif_device_detach(dev->net);
3106 netif_dbg(dev, rx_err, dev->net,
3107 "rx submit, %d\n", ret);
3108 tasklet_schedule(&dev->bh);
3111 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3114 spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3116 dev_kfree_skb_any(skb);
3122 static void rx_complete(struct urb *urb)
3124 struct sk_buff *skb = (struct sk_buff *)urb->context;
3125 struct skb_data *entry = (struct skb_data *)skb->cb;
3126 struct lan78xx_net *dev = entry->dev;
3127 int urb_status = urb->status;
3128 enum skb_state state;
3130 skb_put(skb, urb->actual_length);
3134 switch (urb_status) {
3136 if (skb->len < dev->net->hard_header_len) {
3138 dev->net->stats.rx_errors++;
3139 dev->net->stats.rx_length_errors++;
3140 netif_dbg(dev, rx_err, dev->net,
3141 "rx length %d\n", skb->len);
3143 usb_mark_last_busy(dev->udev);
3146 dev->net->stats.rx_errors++;
3147 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3149 case -ECONNRESET: /* async unlink */
3150 case -ESHUTDOWN: /* hardware gone */
3151 netif_dbg(dev, ifdown, dev->net,
3152 "rx shutdown, code %d\n", urb_status);
3160 dev->net->stats.rx_errors++;
3166 /* data overrun ... flush fifo? */
3168 dev->net->stats.rx_over_errors++;
3173 dev->net->stats.rx_errors++;
3174 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3178 state = defer_bh(dev, skb, &dev->rxq, state);
3181 if (netif_running(dev->net) &&
3182 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3183 state != unlink_start) {
3184 rx_submit(dev, urb, GFP_ATOMIC);
3189 netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
3192 static void lan78xx_tx_bh(struct lan78xx_net *dev)
3195 struct urb *urb = NULL;
3196 struct skb_data *entry;
3197 unsigned long flags;
3198 struct sk_buff_head *tqp = &dev->txq_pend;
3199 struct sk_buff *skb, *skb2;
3202 int skb_totallen, pkt_cnt;
3208 for (skb = tqp->next; pkt_cnt < tqp->qlen; skb = skb->next) {
3209 if (skb_is_gso(skb)) {
3211 /* handle previous packets first */
3215 length = skb->len - TX_OVERHEAD;
3216 skb2 = skb_dequeue(tqp);
3220 if ((skb_totallen + skb->len) > MAX_SINGLE_PACKET_SIZE)
3222 skb_totallen = skb->len + roundup(skb_totallen, sizeof(u32));
3226 /* copy to a single skb */
3227 skb = alloc_skb(skb_totallen, GFP_ATOMIC);
3231 skb_put(skb, skb_totallen);
3233 for (count = pos = 0; count < pkt_cnt; count++) {
3234 skb2 = skb_dequeue(tqp);
3236 length += (skb2->len - TX_OVERHEAD);
3237 memcpy(skb->data + pos, skb2->data, skb2->len);
3238 pos += roundup(skb2->len, sizeof(u32));
3239 dev_kfree_skb(skb2);
3244 urb = usb_alloc_urb(0, GFP_ATOMIC);
3248 entry = (struct skb_data *)skb->cb;
3251 entry->length = length;
3252 entry->num_of_packet = count;
3254 spin_lock_irqsave(&dev->txq.lock, flags);
3255 ret = usb_autopm_get_interface_async(dev->intf);
3257 spin_unlock_irqrestore(&dev->txq.lock, flags);
3261 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_out,
3262 skb->data, skb->len, tx_complete, skb);
3264 if (length % dev->maxpacket == 0) {
3265 /* send USB_ZERO_PACKET */
3266 urb->transfer_flags |= URB_ZERO_PACKET;
3270 /* if this triggers the device is still a sleep */
3271 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3272 /* transmission will be done in resume */
3273 usb_anchor_urb(urb, &dev->deferred);
3274 /* no use to process more packets */
3275 netif_stop_queue(dev->net);
3277 spin_unlock_irqrestore(&dev->txq.lock, flags);
3278 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
3283 ret = usb_submit_urb(urb, GFP_ATOMIC);
3286 netif_trans_update(dev->net);
3287 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3288 if (skb_queue_len(&dev->txq) >= dev->tx_qlen)
3289 netif_stop_queue(dev->net);
3292 netif_stop_queue(dev->net);
3293 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3294 usb_autopm_put_interface_async(dev->intf);
3297 usb_autopm_put_interface_async(dev->intf);
3298 netif_dbg(dev, tx_err, dev->net,
3299 "tx: submit urb err %d\n", ret);
3303 spin_unlock_irqrestore(&dev->txq.lock, flags);
3306 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", ret);
3308 dev->net->stats.tx_dropped++;
3310 dev_kfree_skb_any(skb);
3313 netif_dbg(dev, tx_queued, dev->net,
3314 "> tx, len %d, type 0x%x\n", length, skb->protocol);
3317 static void lan78xx_rx_bh(struct lan78xx_net *dev)
3322 if (skb_queue_len(&dev->rxq) < dev->rx_qlen) {
3323 for (i = 0; i < 10; i++) {
3324 if (skb_queue_len(&dev->rxq) >= dev->rx_qlen)
3326 urb = usb_alloc_urb(0, GFP_ATOMIC);
3328 if (rx_submit(dev, urb, GFP_ATOMIC) == -ENOLINK)
3332 if (skb_queue_len(&dev->rxq) < dev->rx_qlen)
3333 tasklet_schedule(&dev->bh);
3335 if (skb_queue_len(&dev->txq) < dev->tx_qlen)
3336 netif_wake_queue(dev->net);
3339 static void lan78xx_bh(unsigned long param)
3341 struct lan78xx_net *dev = (struct lan78xx_net *)param;
3342 struct sk_buff *skb;
3343 struct skb_data *entry;
3345 while ((skb = skb_dequeue(&dev->done))) {
3346 entry = (struct skb_data *)(skb->cb);
3347 switch (entry->state) {
3349 entry->state = rx_cleanup;
3350 rx_process(dev, skb);
3353 usb_free_urb(entry->urb);
3357 usb_free_urb(entry->urb);
3361 netdev_dbg(dev->net, "skb state %d\n", entry->state);
3366 if (netif_device_present(dev->net) && netif_running(dev->net)) {
3367 /* reset update timer delta */
3368 if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
3370 mod_timer(&dev->stat_monitor,
3371 jiffies + STAT_UPDATE_TIMER);
3374 if (!skb_queue_empty(&dev->txq_pend))
3377 if (!timer_pending(&dev->delay) &&
3378 !test_bit(EVENT_RX_HALT, &dev->flags))
3383 static void lan78xx_delayedwork(struct work_struct *work)
3386 struct lan78xx_net *dev;
3388 dev = container_of(work, struct lan78xx_net, wq.work);
3390 if (test_bit(EVENT_TX_HALT, &dev->flags)) {
3391 unlink_urbs(dev, &dev->txq);
3392 status = usb_autopm_get_interface(dev->intf);
3395 status = usb_clear_halt(dev->udev, dev->pipe_out);
3396 usb_autopm_put_interface(dev->intf);
3399 status != -ESHUTDOWN) {
3400 if (netif_msg_tx_err(dev))
3402 netdev_err(dev->net,
3403 "can't clear tx halt, status %d\n",
3406 clear_bit(EVENT_TX_HALT, &dev->flags);
3407 if (status != -ESHUTDOWN)
3408 netif_wake_queue(dev->net);
3411 if (test_bit(EVENT_RX_HALT, &dev->flags)) {
3412 unlink_urbs(dev, &dev->rxq);
3413 status = usb_autopm_get_interface(dev->intf);
3416 status = usb_clear_halt(dev->udev, dev->pipe_in);
3417 usb_autopm_put_interface(dev->intf);
3420 status != -ESHUTDOWN) {
3421 if (netif_msg_rx_err(dev))
3423 netdev_err(dev->net,
3424 "can't clear rx halt, status %d\n",
3427 clear_bit(EVENT_RX_HALT, &dev->flags);
3428 tasklet_schedule(&dev->bh);
3432 if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
3435 clear_bit(EVENT_LINK_RESET, &dev->flags);
3436 status = usb_autopm_get_interface(dev->intf);
3439 if (lan78xx_link_reset(dev) < 0) {
3440 usb_autopm_put_interface(dev->intf);
3442 netdev_info(dev->net, "link reset failed (%d)\n",
3445 usb_autopm_put_interface(dev->intf);
3449 if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
3450 lan78xx_update_stats(dev);
3452 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3454 mod_timer(&dev->stat_monitor,
3455 jiffies + (STAT_UPDATE_TIMER * dev->delta));
3457 dev->delta = min((dev->delta * 2), 50);
3461 static void intr_complete(struct urb *urb)
3463 struct lan78xx_net *dev = urb->context;
3464 int status = urb->status;
3469 lan78xx_status(dev, urb);
3472 /* software-driven interface shutdown */
3473 case -ENOENT: /* urb killed */
3474 case -ESHUTDOWN: /* hardware gone */
3475 netif_dbg(dev, ifdown, dev->net,
3476 "intr shutdown, code %d\n", status);
3479 /* NOTE: not throttling like RX/TX, since this endpoint
3480 * already polls infrequently
3483 netdev_dbg(dev->net, "intr status %d\n", status);
3487 if (!netif_running(dev->net))
3490 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
3491 status = usb_submit_urb(urb, GFP_ATOMIC);
3493 netif_err(dev, timer, dev->net,
3494 "intr resubmit --> %d\n", status);
3497 static void lan78xx_disconnect(struct usb_interface *intf)
3499 struct lan78xx_net *dev;
3500 struct usb_device *udev;
3501 struct net_device *net;
3503 dev = usb_get_intfdata(intf);
3504 usb_set_intfdata(intf, NULL);
3508 udev = interface_to_usbdev(intf);
3511 unregister_netdev(net);
3513 cancel_delayed_work_sync(&dev->wq);
3515 usb_scuttle_anchored_urbs(&dev->deferred);
3517 lan78xx_unbind(dev, intf);
3519 usb_kill_urb(dev->urb_intr);
3520 usb_free_urb(dev->urb_intr);
3526 static void lan78xx_tx_timeout(struct net_device *net)
3528 struct lan78xx_net *dev = netdev_priv(net);
3530 unlink_urbs(dev, &dev->txq);
3531 tasklet_schedule(&dev->bh);
3534 static const struct net_device_ops lan78xx_netdev_ops = {
3535 .ndo_open = lan78xx_open,
3536 .ndo_stop = lan78xx_stop,
3537 .ndo_start_xmit = lan78xx_start_xmit,
3538 .ndo_tx_timeout = lan78xx_tx_timeout,
3539 .ndo_change_mtu = lan78xx_change_mtu,
3540 .ndo_set_mac_address = lan78xx_set_mac_addr,
3541 .ndo_validate_addr = eth_validate_addr,
3542 .ndo_do_ioctl = lan78xx_ioctl,
3543 .ndo_set_rx_mode = lan78xx_set_multicast,
3544 .ndo_set_features = lan78xx_set_features,
3545 .ndo_vlan_rx_add_vid = lan78xx_vlan_rx_add_vid,
3546 .ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid,
3549 static void lan78xx_stat_monitor(struct timer_list *t)
3551 struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
3553 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
3556 static int lan78xx_probe(struct usb_interface *intf,
3557 const struct usb_device_id *id)
3559 struct lan78xx_net *dev;
3560 struct net_device *netdev;
3561 struct usb_device *udev;
3567 udev = interface_to_usbdev(intf);
3568 udev = usb_get_dev(udev);
3570 netdev = alloc_etherdev(sizeof(struct lan78xx_net));
3572 dev_err(&intf->dev, "Error: OOM\n");
3577 /* netdev_printk() needs this */
3578 SET_NETDEV_DEV(netdev, &intf->dev);
3580 dev = netdev_priv(netdev);
3584 dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
3585 | NETIF_MSG_PROBE | NETIF_MSG_LINK);
3587 skb_queue_head_init(&dev->rxq);
3588 skb_queue_head_init(&dev->txq);
3589 skb_queue_head_init(&dev->done);
3590 skb_queue_head_init(&dev->rxq_pause);
3591 skb_queue_head_init(&dev->txq_pend);
3592 mutex_init(&dev->phy_mutex);
3594 tasklet_init(&dev->bh, lan78xx_bh, (unsigned long)dev);
3595 INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
3596 init_usb_anchor(&dev->deferred);
3598 netdev->netdev_ops = &lan78xx_netdev_ops;
3599 netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
3600 netdev->ethtool_ops = &lan78xx_ethtool_ops;
3603 timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
3605 mutex_init(&dev->stats.access_lock);
3607 ret = lan78xx_bind(dev, intf);
3610 strcpy(netdev->name, "eth%d");
3612 if (netdev->mtu > (dev->hard_mtu - netdev->hard_header_len))
3613 netdev->mtu = dev->hard_mtu - netdev->hard_header_len;
3615 /* MTU range: 68 - 9000 */
3616 netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
3618 dev->ep_blkin = (intf->cur_altsetting)->endpoint + 0;
3619 dev->ep_blkout = (intf->cur_altsetting)->endpoint + 1;
3620 dev->ep_intr = (intf->cur_altsetting)->endpoint + 2;
3622 dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
3623 dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
3625 dev->pipe_intr = usb_rcvintpipe(dev->udev,
3626 dev->ep_intr->desc.bEndpointAddress &
3627 USB_ENDPOINT_NUMBER_MASK);
3628 period = dev->ep_intr->desc.bInterval;
3630 maxp = usb_maxpacket(dev->udev, dev->pipe_intr, 0);
3631 buf = kmalloc(maxp, GFP_KERNEL);
3633 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
3634 if (!dev->urb_intr) {
3639 usb_fill_int_urb(dev->urb_intr, dev->udev,
3640 dev->pipe_intr, buf, maxp,
3641 intr_complete, dev, period);
3645 dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out, 1);
3647 /* driver requires remote-wakeup capability during autosuspend. */
3648 intf->needs_remote_wakeup = 1;
3650 ret = register_netdev(netdev);
3652 netif_err(dev, probe, netdev, "couldn't register the device\n");
3656 usb_set_intfdata(intf, dev);
3658 ret = device_set_wakeup_enable(&udev->dev, true);
3660 /* Default delay of 2sec has more overhead than advantage.
3661 * Set to 10sec as default.
3663 pm_runtime_set_autosuspend_delay(&udev->dev,
3664 DEFAULT_AUTOSUSPEND_DELAY);
3669 lan78xx_unbind(dev, intf);
3671 free_netdev(netdev);
3678 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
3680 const u16 crc16poly = 0x8005;
3686 for (i = 0; i < len; i++) {
3688 for (bit = 0; bit < 8; bit++) {
3692 if (msb ^ (u16)(data & 1)) {
3694 crc |= (u16)0x0001U;
3703 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
3711 const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
3712 const u8 ipv6_multicast[3] = { 0x33, 0x33 };
3713 const u8 arp_type[2] = { 0x08, 0x06 };
3715 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3716 buf &= ~MAC_TX_TXEN_;
3717 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3718 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3719 buf &= ~MAC_RX_RXEN_;
3720 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3722 ret = lan78xx_write_reg(dev, WUCSR, 0);
3723 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3724 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3729 ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
3730 temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
3731 temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
3733 for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
3734 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
3737 if (wol & WAKE_PHY) {
3738 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
3740 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3741 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3742 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3744 if (wol & WAKE_MAGIC) {
3745 temp_wucsr |= WUCSR_MPEN_;
3747 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3748 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3749 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
3751 if (wol & WAKE_BCAST) {
3752 temp_wucsr |= WUCSR_BCST_EN_;
3754 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3755 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3756 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3758 if (wol & WAKE_MCAST) {
3759 temp_wucsr |= WUCSR_WAKE_EN_;
3761 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
3762 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
3763 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3765 WUF_CFGX_TYPE_MCAST_ |
3766 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3767 (crc & WUF_CFGX_CRC16_MASK_));
3769 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
3770 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3771 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3772 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3775 /* for IPv6 Multicast */
3776 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
3777 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3779 WUF_CFGX_TYPE_MCAST_ |
3780 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3781 (crc & WUF_CFGX_CRC16_MASK_));
3783 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
3784 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3785 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3786 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3789 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3790 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3791 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3793 if (wol & WAKE_UCAST) {
3794 temp_wucsr |= WUCSR_PFDA_EN_;
3796 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3797 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3798 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3800 if (wol & WAKE_ARP) {
3801 temp_wucsr |= WUCSR_WAKE_EN_;
3803 /* set WUF_CFG & WUF_MASK
3804 * for packettype (offset 12,13) = ARP (0x0806)
3806 crc = lan78xx_wakeframe_crc16(arp_type, 2);
3807 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3809 WUF_CFGX_TYPE_ALL_ |
3810 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3811 (crc & WUF_CFGX_CRC16_MASK_));
3813 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
3814 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3815 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3816 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3819 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3820 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3821 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3824 ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
3826 /* when multiple WOL bits are set */
3827 if (hweight_long((unsigned long)wol) > 1) {
3828 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3829 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3830 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3832 ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
3835 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3836 buf |= PMT_CTL_WUPS_MASK_;
3837 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3839 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3840 buf |= MAC_RX_RXEN_;
3841 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3846 static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
3848 struct lan78xx_net *dev = usb_get_intfdata(intf);
3849 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3854 event = message.event;
3856 if (!dev->suspend_count++) {
3857 spin_lock_irq(&dev->txq.lock);
3858 /* don't autosuspend while transmitting */
3859 if ((skb_queue_len(&dev->txq) ||
3860 skb_queue_len(&dev->txq_pend)) &&
3861 PMSG_IS_AUTO(message)) {
3862 spin_unlock_irq(&dev->txq.lock);
3866 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
3867 spin_unlock_irq(&dev->txq.lock);
3871 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3872 buf &= ~MAC_TX_TXEN_;
3873 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3874 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3875 buf &= ~MAC_RX_RXEN_;
3876 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3878 /* empty out the rx and queues */
3879 netif_device_detach(dev->net);
3880 lan78xx_terminate_urbs(dev);
3881 usb_kill_urb(dev->urb_intr);
3884 netif_device_attach(dev->net);
3887 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3888 del_timer(&dev->stat_monitor);
3890 if (PMSG_IS_AUTO(message)) {
3891 /* auto suspend (selective suspend) */
3892 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3893 buf &= ~MAC_TX_TXEN_;
3894 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3895 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3896 buf &= ~MAC_RX_RXEN_;
3897 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3899 ret = lan78xx_write_reg(dev, WUCSR, 0);
3900 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3901 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3903 /* set goodframe wakeup */
3904 ret = lan78xx_read_reg(dev, WUCSR, &buf);
3906 buf |= WUCSR_RFE_WAKE_EN_;
3907 buf |= WUCSR_STORE_WAKE_;
3909 ret = lan78xx_write_reg(dev, WUCSR, buf);
3911 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3913 buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
3914 buf |= PMT_CTL_RES_CLR_WKP_STS_;
3916 buf |= PMT_CTL_PHY_WAKE_EN_;
3917 buf |= PMT_CTL_WOL_EN_;
3918 buf &= ~PMT_CTL_SUS_MODE_MASK_;
3919 buf |= PMT_CTL_SUS_MODE_3_;
3921 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3923 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3925 buf |= PMT_CTL_WUPS_MASK_;
3927 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3929 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3930 buf |= MAC_RX_RXEN_;
3931 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3933 lan78xx_set_suspend(dev, pdata->wol);
3942 static int lan78xx_resume(struct usb_interface *intf)
3944 struct lan78xx_net *dev = usb_get_intfdata(intf);
3945 struct sk_buff *skb;
3950 if (!timer_pending(&dev->stat_monitor)) {
3952 mod_timer(&dev->stat_monitor,
3953 jiffies + STAT_UPDATE_TIMER);
3956 if (!--dev->suspend_count) {
3957 /* resume interrupt URBs */
3958 if (dev->urb_intr && test_bit(EVENT_DEV_OPEN, &dev->flags))
3959 usb_submit_urb(dev->urb_intr, GFP_NOIO);
3961 spin_lock_irq(&dev->txq.lock);
3962 while ((res = usb_get_from_anchor(&dev->deferred))) {
3963 skb = (struct sk_buff *)res->context;
3964 ret = usb_submit_urb(res, GFP_ATOMIC);
3966 dev_kfree_skb_any(skb);
3968 usb_autopm_put_interface_async(dev->intf);
3970 netif_trans_update(dev->net);
3971 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3975 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
3976 spin_unlock_irq(&dev->txq.lock);
3978 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
3979 if (!(skb_queue_len(&dev->txq) >= dev->tx_qlen))
3980 netif_start_queue(dev->net);
3981 tasklet_schedule(&dev->bh);
3985 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3986 ret = lan78xx_write_reg(dev, WUCSR, 0);
3987 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3989 ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
3991 WUCSR2_IPV6_TCPSYN_RCD_ |
3992 WUCSR2_IPV4_TCPSYN_RCD_);
3994 ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
3995 WUCSR_EEE_RX_WAKE_ |
3997 WUCSR_RFE_WAKE_FR_ |
4002 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
4003 buf |= MAC_TX_TXEN_;
4004 ret = lan78xx_write_reg(dev, MAC_TX, buf);
4009 static int lan78xx_reset_resume(struct usb_interface *intf)
4011 struct lan78xx_net *dev = usb_get_intfdata(intf);
4015 lan78xx_phy_init(dev);
4017 return lan78xx_resume(intf);
4020 static const struct usb_device_id products[] = {
4022 /* LAN7800 USB Gigabit Ethernet Device */
4023 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
4026 /* LAN7850 USB Gigabit Ethernet Device */
4027 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
4030 /* LAN7801 USB Gigabit Ethernet Device */
4031 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
4035 MODULE_DEVICE_TABLE(usb, products);
4037 static struct usb_driver lan78xx_driver = {
4038 .name = DRIVER_NAME,
4039 .id_table = products,
4040 .probe = lan78xx_probe,
4041 .disconnect = lan78xx_disconnect,
4042 .suspend = lan78xx_suspend,
4043 .resume = lan78xx_resume,
4044 .reset_resume = lan78xx_reset_resume,
4045 .supports_autosuspend = 1,
4046 .disable_hub_initiated_lpm = 1,
4049 module_usb_driver(lan78xx_driver);
4051 MODULE_AUTHOR(DRIVER_AUTHOR);
4052 MODULE_DESCRIPTION(DRIVER_DESC);
4053 MODULE_LICENSE("GPL");