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 <net/vxlan.h>
35 #include <linux/interrupt.h>
36 #include <linux/irqdomain.h>
37 #include <linux/irq.h>
38 #include <linux/irqchip/chained_irq.h>
39 #include <linux/microchipphy.h>
40 #include <linux/phy.h>
41 #include <linux/of_net.h>
44 #define DRIVER_AUTHOR "WOOJUNG HUH <woojung.huh@microchip.com>"
45 #define DRIVER_DESC "LAN78XX USB 3.0 Gigabit Ethernet Devices"
46 #define DRIVER_NAME "lan78xx"
47 #define DRIVER_VERSION "1.0.6"
49 #define TX_TIMEOUT_JIFFIES (5 * HZ)
50 #define THROTTLE_JIFFIES (HZ / 8)
51 #define UNLINK_TIMEOUT_MS 3
53 #define RX_MAX_QUEUE_MEMORY (60 * 1518)
55 #define SS_USB_PKT_SIZE (1024)
56 #define HS_USB_PKT_SIZE (512)
57 #define FS_USB_PKT_SIZE (64)
59 #define MAX_RX_FIFO_SIZE (12 * 1024)
60 #define MAX_TX_FIFO_SIZE (12 * 1024)
61 #define DEFAULT_BURST_CAP_SIZE (MAX_TX_FIFO_SIZE)
62 #define DEFAULT_BULK_IN_DELAY (0x0800)
63 #define MAX_SINGLE_PACKET_SIZE (9000)
64 #define DEFAULT_TX_CSUM_ENABLE (true)
65 #define DEFAULT_RX_CSUM_ENABLE (true)
66 #define DEFAULT_TSO_CSUM_ENABLE (true)
67 #define DEFAULT_VLAN_FILTER_ENABLE (true)
68 #define TX_OVERHEAD (8)
71 #define LAN78XX_USB_VENDOR_ID (0x0424)
72 #define LAN7800_USB_PRODUCT_ID (0x7800)
73 #define LAN7850_USB_PRODUCT_ID (0x7850)
74 #define LAN7801_USB_PRODUCT_ID (0x7801)
75 #define LAN78XX_EEPROM_MAGIC (0x78A5)
76 #define LAN78XX_OTP_MAGIC (0x78F3)
81 #define EEPROM_INDICATOR (0xA5)
82 #define EEPROM_MAC_OFFSET (0x01)
83 #define MAX_EEPROM_SIZE 512
84 #define OTP_INDICATOR_1 (0xF3)
85 #define OTP_INDICATOR_2 (0xF7)
87 #define WAKE_ALL (WAKE_PHY | WAKE_UCAST | \
88 WAKE_MCAST | WAKE_BCAST | \
89 WAKE_ARP | WAKE_MAGIC)
91 /* USB related defines */
92 #define BULK_IN_PIPE 1
93 #define BULK_OUT_PIPE 2
95 /* default autosuspend delay (mSec)*/
96 #define DEFAULT_AUTOSUSPEND_DELAY (10 * 1000)
98 /* statistic update interval (mSec) */
99 #define STAT_UPDATE_TIMER (1 * 1000)
101 /* defines interrupts from interrupt EP */
102 #define MAX_INT_EP (32)
103 #define INT_EP_INTEP (31)
104 #define INT_EP_OTP_WR_DONE (28)
105 #define INT_EP_EEE_TX_LPI_START (26)
106 #define INT_EP_EEE_TX_LPI_STOP (25)
107 #define INT_EP_EEE_RX_LPI (24)
108 #define INT_EP_MAC_RESET_TIMEOUT (23)
109 #define INT_EP_RDFO (22)
110 #define INT_EP_TXE (21)
111 #define INT_EP_USB_STATUS (20)
112 #define INT_EP_TX_DIS (19)
113 #define INT_EP_RX_DIS (18)
114 #define INT_EP_PHY (17)
115 #define INT_EP_DP (16)
116 #define INT_EP_MAC_ERR (15)
117 #define INT_EP_TDFU (14)
118 #define INT_EP_TDFO (13)
119 #define INT_EP_UTX (12)
120 #define INT_EP_GPIO_11 (11)
121 #define INT_EP_GPIO_10 (10)
122 #define INT_EP_GPIO_9 (9)
123 #define INT_EP_GPIO_8 (8)
124 #define INT_EP_GPIO_7 (7)
125 #define INT_EP_GPIO_6 (6)
126 #define INT_EP_GPIO_5 (5)
127 #define INT_EP_GPIO_4 (4)
128 #define INT_EP_GPIO_3 (3)
129 #define INT_EP_GPIO_2 (2)
130 #define INT_EP_GPIO_1 (1)
131 #define INT_EP_GPIO_0 (0)
133 static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {
135 "RX Alignment Errors",
136 "Rx Fragment Errors",
138 "RX Undersize Frame Errors",
139 "RX Oversize Frame Errors",
141 "RX Unicast Byte Count",
142 "RX Broadcast Byte Count",
143 "RX Multicast Byte Count",
145 "RX Broadcast Frames",
146 "RX Multicast Frames",
149 "RX 65 - 127 Byte Frames",
150 "RX 128 - 255 Byte Frames",
151 "RX 256 - 511 Bytes Frames",
152 "RX 512 - 1023 Byte Frames",
153 "RX 1024 - 1518 Byte Frames",
154 "RX Greater 1518 Byte Frames",
155 "EEE RX LPI Transitions",
158 "TX Excess Deferral Errors",
161 "TX Single Collisions",
162 "TX Multiple Collisions",
163 "TX Excessive Collision",
164 "TX Late Collisions",
165 "TX Unicast Byte Count",
166 "TX Broadcast Byte Count",
167 "TX Multicast Byte Count",
169 "TX Broadcast Frames",
170 "TX Multicast Frames",
173 "TX 65 - 127 Byte Frames",
174 "TX 128 - 255 Byte Frames",
175 "TX 256 - 511 Bytes Frames",
176 "TX 512 - 1023 Byte Frames",
177 "TX 1024 - 1518 Byte Frames",
178 "TX Greater 1518 Byte Frames",
179 "EEE TX LPI Transitions",
183 struct lan78xx_statstage {
185 u32 rx_alignment_errors;
186 u32 rx_fragment_errors;
187 u32 rx_jabber_errors;
188 u32 rx_undersize_frame_errors;
189 u32 rx_oversize_frame_errors;
190 u32 rx_dropped_frames;
191 u32 rx_unicast_byte_count;
192 u32 rx_broadcast_byte_count;
193 u32 rx_multicast_byte_count;
194 u32 rx_unicast_frames;
195 u32 rx_broadcast_frames;
196 u32 rx_multicast_frames;
198 u32 rx_64_byte_frames;
199 u32 rx_65_127_byte_frames;
200 u32 rx_128_255_byte_frames;
201 u32 rx_256_511_bytes_frames;
202 u32 rx_512_1023_byte_frames;
203 u32 rx_1024_1518_byte_frames;
204 u32 rx_greater_1518_byte_frames;
205 u32 eee_rx_lpi_transitions;
208 u32 tx_excess_deferral_errors;
209 u32 tx_carrier_errors;
210 u32 tx_bad_byte_count;
211 u32 tx_single_collisions;
212 u32 tx_multiple_collisions;
213 u32 tx_excessive_collision;
214 u32 tx_late_collisions;
215 u32 tx_unicast_byte_count;
216 u32 tx_broadcast_byte_count;
217 u32 tx_multicast_byte_count;
218 u32 tx_unicast_frames;
219 u32 tx_broadcast_frames;
220 u32 tx_multicast_frames;
222 u32 tx_64_byte_frames;
223 u32 tx_65_127_byte_frames;
224 u32 tx_128_255_byte_frames;
225 u32 tx_256_511_bytes_frames;
226 u32 tx_512_1023_byte_frames;
227 u32 tx_1024_1518_byte_frames;
228 u32 tx_greater_1518_byte_frames;
229 u32 eee_tx_lpi_transitions;
233 struct lan78xx_statstage64 {
235 u64 rx_alignment_errors;
236 u64 rx_fragment_errors;
237 u64 rx_jabber_errors;
238 u64 rx_undersize_frame_errors;
239 u64 rx_oversize_frame_errors;
240 u64 rx_dropped_frames;
241 u64 rx_unicast_byte_count;
242 u64 rx_broadcast_byte_count;
243 u64 rx_multicast_byte_count;
244 u64 rx_unicast_frames;
245 u64 rx_broadcast_frames;
246 u64 rx_multicast_frames;
248 u64 rx_64_byte_frames;
249 u64 rx_65_127_byte_frames;
250 u64 rx_128_255_byte_frames;
251 u64 rx_256_511_bytes_frames;
252 u64 rx_512_1023_byte_frames;
253 u64 rx_1024_1518_byte_frames;
254 u64 rx_greater_1518_byte_frames;
255 u64 eee_rx_lpi_transitions;
258 u64 tx_excess_deferral_errors;
259 u64 tx_carrier_errors;
260 u64 tx_bad_byte_count;
261 u64 tx_single_collisions;
262 u64 tx_multiple_collisions;
263 u64 tx_excessive_collision;
264 u64 tx_late_collisions;
265 u64 tx_unicast_byte_count;
266 u64 tx_broadcast_byte_count;
267 u64 tx_multicast_byte_count;
268 u64 tx_unicast_frames;
269 u64 tx_broadcast_frames;
270 u64 tx_multicast_frames;
272 u64 tx_64_byte_frames;
273 u64 tx_65_127_byte_frames;
274 u64 tx_128_255_byte_frames;
275 u64 tx_256_511_bytes_frames;
276 u64 tx_512_1023_byte_frames;
277 u64 tx_1024_1518_byte_frames;
278 u64 tx_greater_1518_byte_frames;
279 u64 eee_tx_lpi_transitions;
285 struct lan78xx_priv {
286 struct lan78xx_net *dev;
288 u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicat hash table */
289 u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */
290 u32 vlan_table[DP_SEL_VHF_VLAN_LEN];
291 struct mutex dataport_mutex; /* for dataport access */
292 spinlock_t rfe_ctl_lock; /* for rfe register access */
293 struct work_struct set_multicast;
294 struct work_struct set_vlan;
308 struct skb_data { /* skb->cb is one of these */
310 struct lan78xx_net *dev;
311 enum skb_state state;
317 struct usb_ctrlrequest req;
318 struct lan78xx_net *dev;
321 #define EVENT_TX_HALT 0
322 #define EVENT_RX_HALT 1
323 #define EVENT_RX_MEMORY 2
324 #define EVENT_STS_SPLIT 3
325 #define EVENT_LINK_RESET 4
326 #define EVENT_RX_PAUSED 5
327 #define EVENT_DEV_WAKING 6
328 #define EVENT_DEV_ASLEEP 7
329 #define EVENT_DEV_OPEN 8
330 #define EVENT_STAT_UPDATE 9
333 struct mutex access_lock; /* for stats access */
334 struct lan78xx_statstage saved;
335 struct lan78xx_statstage rollover_count;
336 struct lan78xx_statstage rollover_max;
337 struct lan78xx_statstage64 curr_stat;
340 struct irq_domain_data {
341 struct irq_domain *irqdomain;
343 struct irq_chip *irqchip;
344 irq_flow_handler_t irq_handler;
346 struct mutex irq_lock; /* for irq bus access */
350 struct net_device *net;
351 struct usb_device *udev;
352 struct usb_interface *intf;
357 struct sk_buff_head rxq;
358 struct sk_buff_head txq;
359 struct sk_buff_head done;
360 struct sk_buff_head rxq_pause;
361 struct sk_buff_head txq_pend;
363 struct tasklet_struct bh;
364 struct delayed_work wq;
368 struct urb *urb_intr;
369 struct usb_anchor deferred;
371 struct mutex phy_mutex; /* for phy access */
372 unsigned pipe_in, pipe_out, pipe_intr;
374 u32 hard_mtu; /* count any extra framing */
375 size_t rx_urb_size; /* size for rx urbs */
379 wait_queue_head_t *wait;
380 unsigned char suspend_count;
383 struct timer_list delay;
384 struct timer_list stat_monitor;
386 unsigned long data[5];
393 struct mii_bus *mdiobus;
394 phy_interface_t interface;
397 u8 fc_request_control;
400 struct statstage stats;
402 struct irq_domain_data domain_data;
405 /* define external phy id */
406 #define PHY_LAN8835 (0x0007C130)
407 #define PHY_KSZ9031RNX (0x00221620)
409 /* use ethtool to change the level for any given device */
410 static int msg_level = -1;
411 module_param(msg_level, int, 0);
412 MODULE_PARM_DESC(msg_level, "Override default message level");
414 static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
416 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
422 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
423 USB_VENDOR_REQUEST_READ_REGISTER,
424 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
425 0, index, buf, 4, USB_CTRL_GET_TIMEOUT);
426 if (likely(ret >= 0)) {
430 netdev_warn(dev->net,
431 "Failed to read register index 0x%08x. ret = %d",
440 static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
442 u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
451 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
452 USB_VENDOR_REQUEST_WRITE_REGISTER,
453 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
454 0, index, buf, 4, USB_CTRL_SET_TIMEOUT);
455 if (unlikely(ret < 0)) {
456 netdev_warn(dev->net,
457 "Failed to write register index 0x%08x. ret = %d",
466 static int lan78xx_read_stats(struct lan78xx_net *dev,
467 struct lan78xx_statstage *data)
471 struct lan78xx_statstage *stats;
475 stats = kmalloc(sizeof(*stats), GFP_KERNEL);
479 ret = usb_control_msg(dev->udev,
480 usb_rcvctrlpipe(dev->udev, 0),
481 USB_VENDOR_REQUEST_GET_STATS,
482 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
487 USB_CTRL_SET_TIMEOUT);
488 if (likely(ret >= 0)) {
491 for (i = 0; i < sizeof(*stats)/sizeof(u32); i++) {
492 le32_to_cpus(&src[i]);
496 netdev_warn(dev->net,
497 "Failed to read stat ret = %d", ret);
505 #define check_counter_rollover(struct1, dev_stats, member) { \
506 if (struct1->member < dev_stats.saved.member) \
507 dev_stats.rollover_count.member++; \
510 static void lan78xx_check_stat_rollover(struct lan78xx_net *dev,
511 struct lan78xx_statstage *stats)
513 check_counter_rollover(stats, dev->stats, rx_fcs_errors);
514 check_counter_rollover(stats, dev->stats, rx_alignment_errors);
515 check_counter_rollover(stats, dev->stats, rx_fragment_errors);
516 check_counter_rollover(stats, dev->stats, rx_jabber_errors);
517 check_counter_rollover(stats, dev->stats, rx_undersize_frame_errors);
518 check_counter_rollover(stats, dev->stats, rx_oversize_frame_errors);
519 check_counter_rollover(stats, dev->stats, rx_dropped_frames);
520 check_counter_rollover(stats, dev->stats, rx_unicast_byte_count);
521 check_counter_rollover(stats, dev->stats, rx_broadcast_byte_count);
522 check_counter_rollover(stats, dev->stats, rx_multicast_byte_count);
523 check_counter_rollover(stats, dev->stats, rx_unicast_frames);
524 check_counter_rollover(stats, dev->stats, rx_broadcast_frames);
525 check_counter_rollover(stats, dev->stats, rx_multicast_frames);
526 check_counter_rollover(stats, dev->stats, rx_pause_frames);
527 check_counter_rollover(stats, dev->stats, rx_64_byte_frames);
528 check_counter_rollover(stats, dev->stats, rx_65_127_byte_frames);
529 check_counter_rollover(stats, dev->stats, rx_128_255_byte_frames);
530 check_counter_rollover(stats, dev->stats, rx_256_511_bytes_frames);
531 check_counter_rollover(stats, dev->stats, rx_512_1023_byte_frames);
532 check_counter_rollover(stats, dev->stats, rx_1024_1518_byte_frames);
533 check_counter_rollover(stats, dev->stats, rx_greater_1518_byte_frames);
534 check_counter_rollover(stats, dev->stats, eee_rx_lpi_transitions);
535 check_counter_rollover(stats, dev->stats, eee_rx_lpi_time);
536 check_counter_rollover(stats, dev->stats, tx_fcs_errors);
537 check_counter_rollover(stats, dev->stats, tx_excess_deferral_errors);
538 check_counter_rollover(stats, dev->stats, tx_carrier_errors);
539 check_counter_rollover(stats, dev->stats, tx_bad_byte_count);
540 check_counter_rollover(stats, dev->stats, tx_single_collisions);
541 check_counter_rollover(stats, dev->stats, tx_multiple_collisions);
542 check_counter_rollover(stats, dev->stats, tx_excessive_collision);
543 check_counter_rollover(stats, dev->stats, tx_late_collisions);
544 check_counter_rollover(stats, dev->stats, tx_unicast_byte_count);
545 check_counter_rollover(stats, dev->stats, tx_broadcast_byte_count);
546 check_counter_rollover(stats, dev->stats, tx_multicast_byte_count);
547 check_counter_rollover(stats, dev->stats, tx_unicast_frames);
548 check_counter_rollover(stats, dev->stats, tx_broadcast_frames);
549 check_counter_rollover(stats, dev->stats, tx_multicast_frames);
550 check_counter_rollover(stats, dev->stats, tx_pause_frames);
551 check_counter_rollover(stats, dev->stats, tx_64_byte_frames);
552 check_counter_rollover(stats, dev->stats, tx_65_127_byte_frames);
553 check_counter_rollover(stats, dev->stats, tx_128_255_byte_frames);
554 check_counter_rollover(stats, dev->stats, tx_256_511_bytes_frames);
555 check_counter_rollover(stats, dev->stats, tx_512_1023_byte_frames);
556 check_counter_rollover(stats, dev->stats, tx_1024_1518_byte_frames);
557 check_counter_rollover(stats, dev->stats, tx_greater_1518_byte_frames);
558 check_counter_rollover(stats, dev->stats, eee_tx_lpi_transitions);
559 check_counter_rollover(stats, dev->stats, eee_tx_lpi_time);
561 memcpy(&dev->stats.saved, stats, sizeof(struct lan78xx_statstage));
564 static void lan78xx_update_stats(struct lan78xx_net *dev)
566 u32 *p, *count, *max;
569 struct lan78xx_statstage lan78xx_stats;
571 if (usb_autopm_get_interface(dev->intf) < 0)
574 p = (u32 *)&lan78xx_stats;
575 count = (u32 *)&dev->stats.rollover_count;
576 max = (u32 *)&dev->stats.rollover_max;
577 data = (u64 *)&dev->stats.curr_stat;
579 mutex_lock(&dev->stats.access_lock);
581 if (lan78xx_read_stats(dev, &lan78xx_stats) > 0)
582 lan78xx_check_stat_rollover(dev, &lan78xx_stats);
584 for (i = 0; i < (sizeof(lan78xx_stats) / (sizeof(u32))); i++)
585 data[i] = (u64)p[i] + ((u64)count[i] * ((u64)max[i] + 1));
587 mutex_unlock(&dev->stats.access_lock);
589 usb_autopm_put_interface(dev->intf);
592 /* Loop until the read is completed with timeout called with phy_mutex held */
593 static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)
595 unsigned long start_time = jiffies;
600 ret = lan78xx_read_reg(dev, MII_ACC, &val);
601 if (unlikely(ret < 0))
604 if (!(val & MII_ACC_MII_BUSY_))
606 } while (!time_after(jiffies, start_time + HZ));
611 static inline u32 mii_access(int id, int index, int read)
615 ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;
616 ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;
618 ret |= MII_ACC_MII_READ_;
620 ret |= MII_ACC_MII_WRITE_;
621 ret |= MII_ACC_MII_BUSY_;
626 static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
628 unsigned long start_time = jiffies;
633 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
634 if (unlikely(ret < 0))
637 if (!(val & E2P_CMD_EPC_BUSY_) ||
638 (val & E2P_CMD_EPC_TIMEOUT_))
640 usleep_range(40, 100);
641 } while (!time_after(jiffies, start_time + HZ));
643 if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
644 netdev_warn(dev->net, "EEPROM read operation timeout");
651 static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
653 unsigned long start_time = jiffies;
658 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
659 if (unlikely(ret < 0))
662 if (!(val & E2P_CMD_EPC_BUSY_))
665 usleep_range(40, 100);
666 } while (!time_after(jiffies, start_time + HZ));
668 netdev_warn(dev->net, "EEPROM is busy");
672 static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
673 u32 length, u8 *data)
680 /* depends on chip, some EEPROM pins are muxed with LED function.
681 * disable & restore LED function to access EEPROM.
683 ret = lan78xx_read_reg(dev, HW_CFG, &val);
685 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
686 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
687 ret = lan78xx_write_reg(dev, HW_CFG, val);
690 retval = lan78xx_eeprom_confirm_not_busy(dev);
694 for (i = 0; i < length; i++) {
695 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
696 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
697 ret = lan78xx_write_reg(dev, E2P_CMD, val);
698 if (unlikely(ret < 0)) {
703 retval = lan78xx_wait_eeprom(dev);
707 ret = lan78xx_read_reg(dev, E2P_DATA, &val);
708 if (unlikely(ret < 0)) {
713 data[i] = val & 0xFF;
719 if (dev->chipid == ID_REV_CHIP_ID_7800_)
720 ret = lan78xx_write_reg(dev, HW_CFG, saved);
725 static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
726 u32 length, u8 *data)
731 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
732 if ((ret == 0) && (sig == EEPROM_INDICATOR))
733 ret = lan78xx_read_raw_eeprom(dev, offset, length, data);
740 static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
741 u32 length, u8 *data)
748 /* depends on chip, some EEPROM pins are muxed with LED function.
749 * disable & restore LED function to access EEPROM.
751 ret = lan78xx_read_reg(dev, HW_CFG, &val);
753 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
754 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
755 ret = lan78xx_write_reg(dev, HW_CFG, val);
758 retval = lan78xx_eeprom_confirm_not_busy(dev);
762 /* Issue write/erase enable command */
763 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
764 ret = lan78xx_write_reg(dev, E2P_CMD, val);
765 if (unlikely(ret < 0)) {
770 retval = lan78xx_wait_eeprom(dev);
774 for (i = 0; i < length; i++) {
775 /* Fill data register */
777 ret = lan78xx_write_reg(dev, E2P_DATA, val);
783 /* Send "write" command */
784 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
785 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
786 ret = lan78xx_write_reg(dev, E2P_CMD, val);
792 retval = lan78xx_wait_eeprom(dev);
801 if (dev->chipid == ID_REV_CHIP_ID_7800_)
802 ret = lan78xx_write_reg(dev, HW_CFG, saved);
807 static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
808 u32 length, u8 *data)
813 unsigned long timeout;
815 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
817 if (buf & OTP_PWR_DN_PWRDN_N_) {
818 /* clear it and wait to be cleared */
819 ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
821 timeout = jiffies + HZ;
824 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
825 if (time_after(jiffies, timeout)) {
826 netdev_warn(dev->net,
827 "timeout on OTP_PWR_DN");
830 } while (buf & OTP_PWR_DN_PWRDN_N_);
833 for (i = 0; i < length; i++) {
834 ret = lan78xx_write_reg(dev, OTP_ADDR1,
835 ((offset + i) >> 8) & OTP_ADDR1_15_11);
836 ret = lan78xx_write_reg(dev, OTP_ADDR2,
837 ((offset + i) & OTP_ADDR2_10_3));
839 ret = lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
840 ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
842 timeout = jiffies + HZ;
845 ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
846 if (time_after(jiffies, timeout)) {
847 netdev_warn(dev->net,
848 "timeout on OTP_STATUS");
851 } while (buf & OTP_STATUS_BUSY_);
853 ret = lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
855 data[i] = (u8)(buf & 0xFF);
861 static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
862 u32 length, u8 *data)
867 unsigned long timeout;
869 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
871 if (buf & OTP_PWR_DN_PWRDN_N_) {
872 /* clear it and wait to be cleared */
873 ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
875 timeout = jiffies + HZ;
878 ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
879 if (time_after(jiffies, timeout)) {
880 netdev_warn(dev->net,
881 "timeout on OTP_PWR_DN completion");
884 } while (buf & OTP_PWR_DN_PWRDN_N_);
887 /* set to BYTE program mode */
888 ret = lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
890 for (i = 0; i < length; i++) {
891 ret = lan78xx_write_reg(dev, OTP_ADDR1,
892 ((offset + i) >> 8) & OTP_ADDR1_15_11);
893 ret = lan78xx_write_reg(dev, OTP_ADDR2,
894 ((offset + i) & OTP_ADDR2_10_3));
895 ret = lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
896 ret = lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
897 ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
899 timeout = jiffies + HZ;
902 ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
903 if (time_after(jiffies, timeout)) {
904 netdev_warn(dev->net,
905 "Timeout on OTP_STATUS completion");
908 } while (buf & OTP_STATUS_BUSY_);
914 static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
915 u32 length, u8 *data)
920 ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
923 if (sig == OTP_INDICATOR_1)
925 else if (sig == OTP_INDICATOR_2)
930 ret = lan78xx_read_raw_otp(dev, offset, length, data);
936 static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
940 for (i = 0; i < 100; i++) {
943 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
944 if (unlikely(ret < 0))
947 if (dp_sel & DP_SEL_DPRDY_)
950 usleep_range(40, 100);
953 netdev_warn(dev->net, "lan78xx_dataport_wait_not_busy timed out");
958 static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
959 u32 addr, u32 length, u32 *buf)
961 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
965 if (usb_autopm_get_interface(dev->intf) < 0)
968 mutex_lock(&pdata->dataport_mutex);
970 ret = lan78xx_dataport_wait_not_busy(dev);
974 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
976 dp_sel &= ~DP_SEL_RSEL_MASK_;
977 dp_sel |= ram_select;
978 ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);
980 for (i = 0; i < length; i++) {
981 ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
983 ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
985 ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
987 ret = lan78xx_dataport_wait_not_busy(dev);
993 mutex_unlock(&pdata->dataport_mutex);
994 usb_autopm_put_interface(dev->intf);
999 static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,
1000 int index, u8 addr[ETH_ALEN])
1004 if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {
1006 temp = addr[2] | (temp << 8);
1007 temp = addr[1] | (temp << 8);
1008 temp = addr[0] | (temp << 8);
1009 pdata->pfilter_table[index][1] = temp;
1011 temp = addr[4] | (temp << 8);
1012 temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;
1013 pdata->pfilter_table[index][0] = temp;
1017 /* returns hash bit number for given MAC address */
1018 static inline u32 lan78xx_hash(char addr[ETH_ALEN])
1020 return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
1023 static void lan78xx_deferred_multicast_write(struct work_struct *param)
1025 struct lan78xx_priv *pdata =
1026 container_of(param, struct lan78xx_priv, set_multicast);
1027 struct lan78xx_net *dev = pdata->dev;
1031 netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
1034 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,
1035 DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
1037 for (i = 1; i < NUM_OF_MAF; i++) {
1038 ret = lan78xx_write_reg(dev, MAF_HI(i), 0);
1039 ret = lan78xx_write_reg(dev, MAF_LO(i),
1040 pdata->pfilter_table[i][1]);
1041 ret = lan78xx_write_reg(dev, MAF_HI(i),
1042 pdata->pfilter_table[i][0]);
1045 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1048 static void lan78xx_set_multicast(struct net_device *netdev)
1050 struct lan78xx_net *dev = netdev_priv(netdev);
1051 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1052 unsigned long flags;
1055 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1057 pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |
1058 RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
1060 for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
1061 pdata->mchash_table[i] = 0;
1062 /* pfilter_table[0] has own HW address */
1063 for (i = 1; i < NUM_OF_MAF; i++) {
1064 pdata->pfilter_table[i][0] =
1065 pdata->pfilter_table[i][1] = 0;
1068 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;
1070 if (dev->net->flags & IFF_PROMISC) {
1071 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
1072 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;
1074 if (dev->net->flags & IFF_ALLMULTI) {
1075 netif_dbg(dev, drv, dev->net,
1076 "receive all multicast enabled");
1077 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;
1081 if (netdev_mc_count(dev->net)) {
1082 struct netdev_hw_addr *ha;
1085 netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
1087 pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;
1090 netdev_for_each_mc_addr(ha, netdev) {
1091 /* set first 32 into Perfect Filter */
1093 lan78xx_set_addr_filter(pdata, i, ha->addr);
1095 u32 bitnum = lan78xx_hash(ha->addr);
1097 pdata->mchash_table[bitnum / 32] |=
1098 (1 << (bitnum % 32));
1099 pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;
1105 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1107 /* defer register writes to a sleepable context */
1108 schedule_work(&pdata->set_multicast);
1111 static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1112 u16 lcladv, u16 rmtadv)
1114 u32 flow = 0, fct_flow = 0;
1118 if (dev->fc_autoneg)
1119 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1121 cap = dev->fc_request_control;
1123 if (cap & FLOW_CTRL_TX)
1124 flow |= (FLOW_CR_TX_FCEN_ | 0xFFFF);
1126 if (cap & FLOW_CTRL_RX)
1127 flow |= FLOW_CR_RX_FCEN_;
1129 if (dev->udev->speed == USB_SPEED_SUPER)
1131 else if (dev->udev->speed == USB_SPEED_HIGH)
1134 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1135 (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
1136 (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
1138 ret = lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1140 /* threshold value should be set before enabling flow */
1141 ret = lan78xx_write_reg(dev, FLOW, flow);
1146 static int lan78xx_link_reset(struct lan78xx_net *dev)
1148 struct phy_device *phydev = dev->net->phydev;
1149 struct ethtool_link_ksettings ecmd;
1150 int ladv, radv, ret, link;
1153 /* clear LAN78xx interrupt status */
1154 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1155 if (unlikely(ret < 0))
1158 mutex_lock(&phydev->lock);
1159 phy_read_status(phydev);
1160 link = phydev->link;
1161 mutex_unlock(&phydev->lock);
1163 if (!link && dev->link_on) {
1164 dev->link_on = false;
1167 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1168 if (unlikely(ret < 0))
1171 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1172 if (unlikely(ret < 0))
1175 del_timer(&dev->stat_monitor);
1176 } else if (link && !dev->link_on) {
1177 dev->link_on = true;
1179 phy_ethtool_ksettings_get(phydev, &ecmd);
1181 if (dev->udev->speed == USB_SPEED_SUPER) {
1182 if (ecmd.base.speed == 1000) {
1184 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1185 buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1186 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1188 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1189 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1190 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1192 /* enable U1 & U2 */
1193 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1194 buf |= USB_CFG1_DEV_U2_INIT_EN_;
1195 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1196 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1200 ladv = phy_read(phydev, MII_ADVERTISE);
1204 radv = phy_read(phydev, MII_LPA);
1208 netif_dbg(dev, link, dev->net,
1209 "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1210 ecmd.base.speed, ecmd.base.duplex, ladv, radv);
1212 ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,
1215 if (!timer_pending(&dev->stat_monitor)) {
1217 mod_timer(&dev->stat_monitor,
1218 jiffies + STAT_UPDATE_TIMER);
1221 tasklet_schedule(&dev->bh);
1227 /* some work can't be done in tasklets, so we use keventd
1229 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
1230 * but tasklet_schedule() doesn't. hope the failure is rare.
1232 static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1234 set_bit(work, &dev->flags);
1235 if (!schedule_delayed_work(&dev->wq, 0))
1236 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1239 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1243 if (urb->actual_length != 4) {
1244 netdev_warn(dev->net,
1245 "unexpected urb length %d", urb->actual_length);
1249 memcpy(&intdata, urb->transfer_buffer, 4);
1250 le32_to_cpus(&intdata);
1252 if (intdata & INT_ENP_PHY_INT) {
1253 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1254 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1256 if (dev->domain_data.phyirq > 0)
1257 generic_handle_irq(dev->domain_data.phyirq);
1259 netdev_warn(dev->net,
1260 "unexpected interrupt: 0x%08x\n", intdata);
1263 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1265 return MAX_EEPROM_SIZE;
1268 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1269 struct ethtool_eeprom *ee, u8 *data)
1271 struct lan78xx_net *dev = netdev_priv(netdev);
1274 ret = usb_autopm_get_interface(dev->intf);
1278 ee->magic = LAN78XX_EEPROM_MAGIC;
1280 ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1282 usb_autopm_put_interface(dev->intf);
1287 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1288 struct ethtool_eeprom *ee, u8 *data)
1290 struct lan78xx_net *dev = netdev_priv(netdev);
1293 ret = usb_autopm_get_interface(dev->intf);
1297 /* Invalid EEPROM_INDICATOR at offset zero will result in a failure
1298 * to load data from EEPROM
1300 if (ee->magic == LAN78XX_EEPROM_MAGIC)
1301 ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1302 else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1303 (ee->offset == 0) &&
1305 (data[0] == OTP_INDICATOR_1))
1306 ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1308 usb_autopm_put_interface(dev->intf);
1313 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1316 if (stringset == ETH_SS_STATS)
1317 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1320 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1322 if (sset == ETH_SS_STATS)
1323 return ARRAY_SIZE(lan78xx_gstrings);
1328 static void lan78xx_get_stats(struct net_device *netdev,
1329 struct ethtool_stats *stats, u64 *data)
1331 struct lan78xx_net *dev = netdev_priv(netdev);
1333 lan78xx_update_stats(dev);
1335 mutex_lock(&dev->stats.access_lock);
1336 memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1337 mutex_unlock(&dev->stats.access_lock);
1340 static void lan78xx_get_wol(struct net_device *netdev,
1341 struct ethtool_wolinfo *wol)
1343 struct lan78xx_net *dev = netdev_priv(netdev);
1346 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1348 if (usb_autopm_get_interface(dev->intf) < 0)
1351 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1352 if (unlikely(ret < 0)) {
1356 if (buf & USB_CFG_RMT_WKP_) {
1357 wol->supported = WAKE_ALL;
1358 wol->wolopts = pdata->wol;
1365 usb_autopm_put_interface(dev->intf);
1368 static int lan78xx_set_wol(struct net_device *netdev,
1369 struct ethtool_wolinfo *wol)
1371 struct lan78xx_net *dev = netdev_priv(netdev);
1372 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1375 ret = usb_autopm_get_interface(dev->intf);
1379 if (wol->wolopts & ~WAKE_ALL)
1382 pdata->wol = wol->wolopts;
1384 device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1386 phy_ethtool_set_wol(netdev->phydev, wol);
1388 usb_autopm_put_interface(dev->intf);
1393 static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1395 struct lan78xx_net *dev = netdev_priv(net);
1396 struct phy_device *phydev = net->phydev;
1400 ret = usb_autopm_get_interface(dev->intf);
1404 ret = phy_ethtool_get_eee(phydev, edata);
1408 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1409 if (buf & MAC_CR_EEE_EN_) {
1410 edata->eee_enabled = true;
1411 edata->eee_active = !!(edata->advertised &
1412 edata->lp_advertised);
1413 edata->tx_lpi_enabled = true;
1414 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1415 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1416 edata->tx_lpi_timer = buf;
1418 edata->eee_enabled = false;
1419 edata->eee_active = false;
1420 edata->tx_lpi_enabled = false;
1421 edata->tx_lpi_timer = 0;
1426 usb_autopm_put_interface(dev->intf);
1431 static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1433 struct lan78xx_net *dev = netdev_priv(net);
1437 ret = usb_autopm_get_interface(dev->intf);
1441 if (edata->eee_enabled) {
1442 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1443 buf |= MAC_CR_EEE_EN_;
1444 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1446 phy_ethtool_set_eee(net->phydev, edata);
1448 buf = (u32)edata->tx_lpi_timer;
1449 ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1451 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1452 buf &= ~MAC_CR_EEE_EN_;
1453 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1456 usb_autopm_put_interface(dev->intf);
1461 static u32 lan78xx_get_link(struct net_device *net)
1465 mutex_lock(&net->phydev->lock);
1466 phy_read_status(net->phydev);
1467 link = net->phydev->link;
1468 mutex_unlock(&net->phydev->lock);
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 if (!eth_platform_get_mac_address(&dev->udev->dev, addr)) {
1655 /* valid address present in Device Tree */
1656 netif_dbg(dev, ifup, dev->net,
1657 "MAC address read from Device Tree");
1658 } else if (((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET,
1659 ETH_ALEN, addr) == 0) ||
1660 (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET,
1661 ETH_ALEN, addr) == 0)) &&
1662 is_valid_ether_addr(addr)) {
1663 /* eeprom values are valid so use them */
1664 netif_dbg(dev, ifup, dev->net,
1665 "MAC address read from EEPROM");
1667 /* generate random MAC */
1668 random_ether_addr(addr);
1669 netif_dbg(dev, ifup, dev->net,
1670 "MAC address set to random addr");
1673 addr_lo = addr[0] | (addr[1] << 8) |
1674 (addr[2] << 16) | (addr[3] << 24);
1675 addr_hi = addr[4] | (addr[5] << 8);
1677 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1678 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1681 ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1682 ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1684 ether_addr_copy(dev->net->dev_addr, addr);
1687 /* MDIO read and write wrappers for phylib */
1688 static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
1690 struct lan78xx_net *dev = bus->priv;
1694 ret = usb_autopm_get_interface(dev->intf);
1698 mutex_lock(&dev->phy_mutex);
1700 /* confirm MII not busy */
1701 ret = lan78xx_phy_wait_not_busy(dev);
1705 /* set the address, index & direction (read from PHY) */
1706 addr = mii_access(phy_id, idx, MII_READ);
1707 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1709 ret = lan78xx_phy_wait_not_busy(dev);
1713 ret = lan78xx_read_reg(dev, MII_DATA, &val);
1715 ret = (int)(val & 0xFFFF);
1718 mutex_unlock(&dev->phy_mutex);
1719 usb_autopm_put_interface(dev->intf);
1724 static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
1727 struct lan78xx_net *dev = bus->priv;
1731 ret = usb_autopm_get_interface(dev->intf);
1735 mutex_lock(&dev->phy_mutex);
1737 /* confirm MII not busy */
1738 ret = lan78xx_phy_wait_not_busy(dev);
1743 ret = lan78xx_write_reg(dev, MII_DATA, val);
1745 /* set the address, index & direction (write to PHY) */
1746 addr = mii_access(phy_id, idx, MII_WRITE);
1747 ret = lan78xx_write_reg(dev, MII_ACC, addr);
1749 ret = lan78xx_phy_wait_not_busy(dev);
1754 mutex_unlock(&dev->phy_mutex);
1755 usb_autopm_put_interface(dev->intf);
1759 static int lan78xx_mdio_init(struct lan78xx_net *dev)
1763 dev->mdiobus = mdiobus_alloc();
1764 if (!dev->mdiobus) {
1765 netdev_err(dev->net, "can't allocate MDIO bus\n");
1769 dev->mdiobus->priv = (void *)dev;
1770 dev->mdiobus->read = lan78xx_mdiobus_read;
1771 dev->mdiobus->write = lan78xx_mdiobus_write;
1772 dev->mdiobus->name = "lan78xx-mdiobus";
1773 dev->mdiobus->parent = &dev->udev->dev;
1775 snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
1776 dev->udev->bus->busnum, dev->udev->devnum);
1778 switch (dev->chipid) {
1779 case ID_REV_CHIP_ID_7800_:
1780 case ID_REV_CHIP_ID_7850_:
1781 /* set to internal PHY id */
1782 dev->mdiobus->phy_mask = ~(1 << 1);
1784 case ID_REV_CHIP_ID_7801_:
1785 /* scan thru PHYAD[2..0] */
1786 dev->mdiobus->phy_mask = ~(0xFF);
1790 ret = mdiobus_register(dev->mdiobus);
1792 netdev_err(dev->net, "can't register MDIO bus\n");
1796 netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
1799 mdiobus_free(dev->mdiobus);
1803 static void lan78xx_remove_mdio(struct lan78xx_net *dev)
1805 mdiobus_unregister(dev->mdiobus);
1806 mdiobus_free(dev->mdiobus);
1809 static void lan78xx_link_status_change(struct net_device *net)
1811 struct phy_device *phydev = net->phydev;
1814 /* At forced 100 F/H mode, chip may fail to set mode correctly
1815 * when cable is switched between long(~50+m) and short one.
1816 * As workaround, set to 10 before setting to 100
1817 * at forced 100 F/H mode.
1819 if (!phydev->autoneg && (phydev->speed == 100)) {
1820 /* disable phy interrupt */
1821 temp = phy_read(phydev, LAN88XX_INT_MASK);
1822 temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_;
1823 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1825 temp = phy_read(phydev, MII_BMCR);
1826 temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000);
1827 phy_write(phydev, MII_BMCR, temp); /* set to 10 first */
1828 temp |= BMCR_SPEED100;
1829 phy_write(phydev, MII_BMCR, temp); /* set to 100 later */
1831 /* clear pending interrupt generated while workaround */
1832 temp = phy_read(phydev, LAN88XX_INT_STS);
1834 /* enable phy interrupt back */
1835 temp = phy_read(phydev, LAN88XX_INT_MASK);
1836 temp |= LAN88XX_INT_MASK_MDINTPIN_EN_;
1837 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1841 static int irq_map(struct irq_domain *d, unsigned int irq,
1842 irq_hw_number_t hwirq)
1844 struct irq_domain_data *data = d->host_data;
1846 irq_set_chip_data(irq, data);
1847 irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);
1848 irq_set_noprobe(irq);
1853 static void irq_unmap(struct irq_domain *d, unsigned int irq)
1855 irq_set_chip_and_handler(irq, NULL, NULL);
1856 irq_set_chip_data(irq, NULL);
1859 static const struct irq_domain_ops chip_domain_ops = {
1864 static void lan78xx_irq_mask(struct irq_data *irqd)
1866 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1868 data->irqenable &= ~BIT(irqd_to_hwirq(irqd));
1871 static void lan78xx_irq_unmask(struct irq_data *irqd)
1873 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1875 data->irqenable |= BIT(irqd_to_hwirq(irqd));
1878 static void lan78xx_irq_bus_lock(struct irq_data *irqd)
1880 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1882 mutex_lock(&data->irq_lock);
1885 static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
1887 struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1888 struct lan78xx_net *dev =
1889 container_of(data, struct lan78xx_net, domain_data);
1893 /* call register access here because irq_bus_lock & irq_bus_sync_unlock
1894 * are only two callbacks executed in non-atomic contex.
1896 ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1897 if (buf != data->irqenable)
1898 ret = lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
1900 mutex_unlock(&data->irq_lock);
1903 static struct irq_chip lan78xx_irqchip = {
1904 .name = "lan78xx-irqs",
1905 .irq_mask = lan78xx_irq_mask,
1906 .irq_unmask = lan78xx_irq_unmask,
1907 .irq_bus_lock = lan78xx_irq_bus_lock,
1908 .irq_bus_sync_unlock = lan78xx_irq_bus_sync_unlock,
1911 static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
1913 struct device_node *of_node;
1914 struct irq_domain *irqdomain;
1915 unsigned int irqmap = 0;
1919 of_node = dev->udev->dev.parent->of_node;
1921 mutex_init(&dev->domain_data.irq_lock);
1923 lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1924 dev->domain_data.irqenable = buf;
1926 dev->domain_data.irqchip = &lan78xx_irqchip;
1927 dev->domain_data.irq_handler = handle_simple_irq;
1929 irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,
1930 &chip_domain_ops, &dev->domain_data);
1932 /* create mapping for PHY interrupt */
1933 irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);
1935 irq_domain_remove(irqdomain);
1944 dev->domain_data.irqdomain = irqdomain;
1945 dev->domain_data.phyirq = irqmap;
1950 static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
1952 if (dev->domain_data.phyirq > 0) {
1953 irq_dispose_mapping(dev->domain_data.phyirq);
1955 if (dev->domain_data.irqdomain)
1956 irq_domain_remove(dev->domain_data.irqdomain);
1958 dev->domain_data.phyirq = 0;
1959 dev->domain_data.irqdomain = NULL;
1962 static int lan8835_fixup(struct phy_device *phydev)
1966 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
1968 /* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */
1969 buf = phy_read_mmd(phydev, MDIO_MMD_PCS, 0x8010);
1972 phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf);
1974 /* RGMII MAC TXC Delay Enable */
1975 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
1976 MAC_RGMII_ID_TXC_DELAY_EN_);
1978 /* RGMII TX DLL Tune Adjust */
1979 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
1981 dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
1986 static int ksz9031rnx_fixup(struct phy_device *phydev)
1988 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
1990 /* Micrel9301RNX PHY configuration */
1991 /* RGMII Control Signal Pad Skew */
1992 phy_write_mmd(phydev, MDIO_MMD_WIS, 4, 0x0077);
1993 /* RGMII RX Data Pad Skew */
1994 phy_write_mmd(phydev, MDIO_MMD_WIS, 5, 0x7777);
1995 /* RGMII RX Clock Pad Skew */
1996 phy_write_mmd(phydev, MDIO_MMD_WIS, 8, 0x1FF);
1998 dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;
2003 static int lan78xx_phy_init(struct lan78xx_net *dev)
2007 struct phy_device *phydev = dev->net->phydev;
2009 phydev = phy_find_first(dev->mdiobus);
2011 netdev_err(dev->net, "no PHY found\n");
2015 if ((dev->chipid == ID_REV_CHIP_ID_7800_) ||
2016 (dev->chipid == ID_REV_CHIP_ID_7850_)) {
2017 phydev->is_internal = true;
2018 dev->interface = PHY_INTERFACE_MODE_GMII;
2020 } else if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2022 netdev_err(dev->net, "no PHY driver found\n");
2026 dev->interface = PHY_INTERFACE_MODE_RGMII;
2028 /* external PHY fixup for KSZ9031RNX */
2029 ret = phy_register_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0,
2032 netdev_err(dev->net, "fail to register fixup\n");
2035 /* external PHY fixup for LAN8835 */
2036 ret = phy_register_fixup_for_uid(PHY_LAN8835, 0xfffffff0,
2039 netdev_err(dev->net, "fail to register fixup\n");
2042 /* add more external PHY fixup here if needed */
2044 phydev->is_internal = false;
2046 netdev_err(dev->net, "unknown ID found\n");
2051 /* if phyirq is not set, use polling mode in phylib */
2052 if (dev->domain_data.phyirq > 0)
2053 phydev->irq = dev->domain_data.phyirq;
2056 netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2058 /* set to AUTOMDIX */
2059 phydev->mdix = ETH_TP_MDI_AUTO;
2061 ret = phy_connect_direct(dev->net, phydev,
2062 lan78xx_link_status_change,
2065 netdev_err(dev->net, "can't attach PHY to %s\n",
2070 /* MAC doesn't support 1000T Half */
2071 phydev->supported &= ~SUPPORTED_1000baseT_Half;
2073 /* support both flow controls */
2074 dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2075 phydev->advertising &= ~(ADVERTISED_Pause | ADVERTISED_Asym_Pause);
2076 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2077 phydev->advertising |= mii_adv_to_ethtool_adv_t(mii_adv);
2079 genphy_config_aneg(phydev);
2081 dev->fc_autoneg = phydev->autoneg;
2086 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
2087 phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
2092 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2098 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2100 rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2103 buf &= ~MAC_RX_RXEN_;
2104 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2107 /* add 4 to size for FCS */
2108 buf &= ~MAC_RX_MAX_SIZE_MASK_;
2109 buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2111 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2114 buf |= MAC_RX_RXEN_;
2115 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2121 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2123 struct sk_buff *skb;
2124 unsigned long flags;
2127 spin_lock_irqsave(&q->lock, flags);
2128 while (!skb_queue_empty(q)) {
2129 struct skb_data *entry;
2133 skb_queue_walk(q, skb) {
2134 entry = (struct skb_data *)skb->cb;
2135 if (entry->state != unlink_start)
2140 entry->state = unlink_start;
2143 /* Get reference count of the URB to avoid it to be
2144 * freed during usb_unlink_urb, which may trigger
2145 * use-after-free problem inside usb_unlink_urb since
2146 * usb_unlink_urb is always racing with .complete
2147 * handler(include defer_bh).
2150 spin_unlock_irqrestore(&q->lock, flags);
2151 /* during some PM-driven resume scenarios,
2152 * these (async) unlinks complete immediately
2154 ret = usb_unlink_urb(urb);
2155 if (ret != -EINPROGRESS && ret != 0)
2156 netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2160 spin_lock_irqsave(&q->lock, flags);
2162 spin_unlock_irqrestore(&q->lock, flags);
2166 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2168 struct lan78xx_net *dev = netdev_priv(netdev);
2169 int ll_mtu = new_mtu + netdev->hard_header_len;
2170 int old_hard_mtu = dev->hard_mtu;
2171 int old_rx_urb_size = dev->rx_urb_size;
2174 /* no second zero-length packet read wanted after mtu-sized packets */
2175 if ((ll_mtu % dev->maxpacket) == 0)
2178 ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + ETH_HLEN);
2180 netdev->mtu = new_mtu;
2182 dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
2183 if (dev->rx_urb_size == old_hard_mtu) {
2184 dev->rx_urb_size = dev->hard_mtu;
2185 if (dev->rx_urb_size > old_rx_urb_size) {
2186 if (netif_running(dev->net)) {
2187 unlink_urbs(dev, &dev->rxq);
2188 tasklet_schedule(&dev->bh);
2196 static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2198 struct lan78xx_net *dev = netdev_priv(netdev);
2199 struct sockaddr *addr = p;
2200 u32 addr_lo, addr_hi;
2203 if (netif_running(netdev))
2206 if (!is_valid_ether_addr(addr->sa_data))
2207 return -EADDRNOTAVAIL;
2209 ether_addr_copy(netdev->dev_addr, addr->sa_data);
2211 addr_lo = netdev->dev_addr[0] |
2212 netdev->dev_addr[1] << 8 |
2213 netdev->dev_addr[2] << 16 |
2214 netdev->dev_addr[3] << 24;
2215 addr_hi = netdev->dev_addr[4] |
2216 netdev->dev_addr[5] << 8;
2218 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2219 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2221 /* Added to support MAC address changes */
2222 ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2223 ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2228 /* Enable or disable Rx checksum offload engine */
2229 static int lan78xx_set_features(struct net_device *netdev,
2230 netdev_features_t features)
2232 struct lan78xx_net *dev = netdev_priv(netdev);
2233 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2234 unsigned long flags;
2237 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2239 if (features & NETIF_F_RXCSUM) {
2240 pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
2241 pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
2243 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2244 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2247 if (features & NETIF_F_HW_VLAN_CTAG_RX)
2248 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2250 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2252 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2254 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2259 static void lan78xx_deferred_vlan_write(struct work_struct *param)
2261 struct lan78xx_priv *pdata =
2262 container_of(param, struct lan78xx_priv, set_vlan);
2263 struct lan78xx_net *dev = pdata->dev;
2265 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2266 DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2269 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2270 __be16 proto, u16 vid)
2272 struct lan78xx_net *dev = netdev_priv(netdev);
2273 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2275 u16 vid_dword_index;
2277 vid_dword_index = (vid >> 5) & 0x7F;
2278 vid_bit_index = vid & 0x1F;
2280 pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2282 /* defer register writes to a sleepable context */
2283 schedule_work(&pdata->set_vlan);
2288 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2289 __be16 proto, u16 vid)
2291 struct lan78xx_net *dev = netdev_priv(netdev);
2292 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2294 u16 vid_dword_index;
2296 vid_dword_index = (vid >> 5) & 0x7F;
2297 vid_bit_index = vid & 0x1F;
2299 pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2301 /* defer register writes to a sleepable context */
2302 schedule_work(&pdata->set_vlan);
2307 static void lan78xx_init_ltm(struct lan78xx_net *dev)
2311 u32 regs[6] = { 0 };
2313 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2314 if (buf & USB_CFG1_LTM_ENABLE_) {
2316 /* Get values from EEPROM first */
2317 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2318 if (temp[0] == 24) {
2319 ret = lan78xx_read_raw_eeprom(dev,
2326 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2327 if (temp[0] == 24) {
2328 ret = lan78xx_read_raw_otp(dev,
2338 lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2339 lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2340 lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2341 lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2342 lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2343 lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2346 static int lan78xx_reset(struct lan78xx_net *dev)
2348 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2351 unsigned long timeout;
2354 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2355 buf |= HW_CFG_LRST_;
2356 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2358 timeout = jiffies + HZ;
2361 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2362 if (time_after(jiffies, timeout)) {
2363 netdev_warn(dev->net,
2364 "timeout on completion of LiteReset");
2367 } while (buf & HW_CFG_LRST_);
2369 lan78xx_init_mac_address(dev);
2371 /* save DEVID for later usage */
2372 ret = lan78xx_read_reg(dev, ID_REV, &buf);
2373 dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2374 dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2376 /* Respond to the IN token with a NAK */
2377 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2378 buf |= USB_CFG_BIR_;
2379 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2382 lan78xx_init_ltm(dev);
2384 if (dev->udev->speed == USB_SPEED_SUPER) {
2385 buf = DEFAULT_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2386 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2389 } else if (dev->udev->speed == USB_SPEED_HIGH) {
2390 buf = DEFAULT_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2391 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2392 dev->rx_qlen = RX_MAX_QUEUE_MEMORY / dev->rx_urb_size;
2393 dev->tx_qlen = RX_MAX_QUEUE_MEMORY / dev->hard_mtu;
2395 buf = DEFAULT_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2396 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2401 ret = lan78xx_write_reg(dev, BURST_CAP, buf);
2402 ret = lan78xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
2404 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2406 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2408 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2409 buf |= USB_CFG_BCE_;
2410 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2412 /* set FIFO sizes */
2413 buf = (MAX_RX_FIFO_SIZE - 512) / 512;
2414 ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2416 buf = (MAX_TX_FIFO_SIZE - 512) / 512;
2417 ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2419 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2420 ret = lan78xx_write_reg(dev, FLOW, 0);
2421 ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2423 /* Don't need rfe_ctl_lock during initialisation */
2424 ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2425 pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
2426 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2428 /* Enable or disable checksum offload engines */
2429 lan78xx_set_features(dev->net, dev->net->features);
2431 lan78xx_set_multicast(dev->net);
2434 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2435 buf |= PMT_CTL_PHY_RST_;
2436 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
2438 timeout = jiffies + HZ;
2441 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2442 if (time_after(jiffies, timeout)) {
2443 netdev_warn(dev->net, "timeout waiting for PHY Reset");
2446 } while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
2448 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
2449 /* LAN7801 only has RGMII mode */
2450 if (dev->chipid == ID_REV_CHIP_ID_7801_)
2451 buf &= ~MAC_CR_GMII_EN_;
2453 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
2454 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
2455 if (!ret && sig != EEPROM_INDICATOR) {
2456 /* Implies there is no external eeprom. Set mac speed */
2457 netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");
2458 buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
2461 ret = lan78xx_write_reg(dev, MAC_CR, buf);
2463 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
2464 buf |= MAC_TX_TXEN_;
2465 ret = lan78xx_write_reg(dev, MAC_TX, buf);
2467 ret = lan78xx_read_reg(dev, FCT_TX_CTL, &buf);
2468 buf |= FCT_TX_CTL_EN_;
2469 ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
2471 ret = lan78xx_set_rx_max_frame_length(dev, dev->net->mtu + ETH_HLEN);
2473 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2474 buf |= MAC_RX_RXEN_;
2475 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2477 ret = lan78xx_read_reg(dev, FCT_RX_CTL, &buf);
2478 buf |= FCT_RX_CTL_EN_;
2479 ret = lan78xx_write_reg(dev, FCT_RX_CTL, buf);
2484 static void lan78xx_init_stats(struct lan78xx_net *dev)
2489 /* initialize for stats update
2490 * some counters are 20bits and some are 32bits
2492 p = (u32 *)&dev->stats.rollover_max;
2493 for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
2496 dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
2497 dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
2498 dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
2499 dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
2500 dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
2501 dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
2502 dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
2503 dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
2504 dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
2505 dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
2507 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
2510 static int lan78xx_open(struct net_device *net)
2512 struct lan78xx_net *dev = netdev_priv(net);
2515 ret = usb_autopm_get_interface(dev->intf);
2519 phy_start(net->phydev);
2521 netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
2523 /* for Link Check */
2524 if (dev->urb_intr) {
2525 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
2527 netif_err(dev, ifup, dev->net,
2528 "intr submit %d\n", ret);
2533 lan78xx_init_stats(dev);
2535 set_bit(EVENT_DEV_OPEN, &dev->flags);
2537 netif_start_queue(net);
2539 dev->link_on = false;
2541 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
2543 usb_autopm_put_interface(dev->intf);
2549 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
2551 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
2552 DECLARE_WAITQUEUE(wait, current);
2555 /* ensure there are no more active urbs */
2556 add_wait_queue(&unlink_wakeup, &wait);
2557 set_current_state(TASK_UNINTERRUPTIBLE);
2558 dev->wait = &unlink_wakeup;
2559 temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
2561 /* maybe wait for deletions to finish. */
2562 while (!skb_queue_empty(&dev->rxq) &&
2563 !skb_queue_empty(&dev->txq) &&
2564 !skb_queue_empty(&dev->done)) {
2565 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
2566 set_current_state(TASK_UNINTERRUPTIBLE);
2567 netif_dbg(dev, ifdown, dev->net,
2568 "waited for %d urb completions\n", temp);
2570 set_current_state(TASK_RUNNING);
2572 remove_wait_queue(&unlink_wakeup, &wait);
2575 static int lan78xx_stop(struct net_device *net)
2577 struct lan78xx_net *dev = netdev_priv(net);
2579 if (timer_pending(&dev->stat_monitor))
2580 del_timer_sync(&dev->stat_monitor);
2583 phy_stop(net->phydev);
2585 clear_bit(EVENT_DEV_OPEN, &dev->flags);
2586 netif_stop_queue(net);
2588 netif_info(dev, ifdown, dev->net,
2589 "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
2590 net->stats.rx_packets, net->stats.tx_packets,
2591 net->stats.rx_errors, net->stats.tx_errors);
2593 lan78xx_terminate_urbs(dev);
2595 usb_kill_urb(dev->urb_intr);
2597 skb_queue_purge(&dev->rxq_pause);
2599 /* deferred work (task, timer, softirq) must also stop.
2600 * can't flush_scheduled_work() until we drop rtnl (later),
2601 * else workers could deadlock; so make workers a NOP.
2604 cancel_delayed_work_sync(&dev->wq);
2605 tasklet_kill(&dev->bh);
2607 usb_autopm_put_interface(dev->intf);
2612 static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
2613 struct sk_buff *skb, gfp_t flags)
2615 u32 tx_cmd_a, tx_cmd_b;
2617 if (skb_cow_head(skb, TX_OVERHEAD)) {
2618 dev_kfree_skb_any(skb);
2622 if (skb_linearize(skb)) {
2623 dev_kfree_skb_any(skb);
2627 tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
2629 if (skb->ip_summed == CHECKSUM_PARTIAL)
2630 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
2633 if (skb_is_gso(skb)) {
2634 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
2636 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
2638 tx_cmd_a |= TX_CMD_A_LSO_;
2641 if (skb_vlan_tag_present(skb)) {
2642 tx_cmd_a |= TX_CMD_A_IVTG_;
2643 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
2647 cpu_to_le32s(&tx_cmd_b);
2648 memcpy(skb->data, &tx_cmd_b, 4);
2651 cpu_to_le32s(&tx_cmd_a);
2652 memcpy(skb->data, &tx_cmd_a, 4);
2657 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
2658 struct sk_buff_head *list, enum skb_state state)
2660 unsigned long flags;
2661 enum skb_state old_state;
2662 struct skb_data *entry = (struct skb_data *)skb->cb;
2664 spin_lock_irqsave(&list->lock, flags);
2665 old_state = entry->state;
2666 entry->state = state;
2668 __skb_unlink(skb, list);
2669 spin_unlock(&list->lock);
2670 spin_lock(&dev->done.lock);
2672 __skb_queue_tail(&dev->done, skb);
2673 if (skb_queue_len(&dev->done) == 1)
2674 tasklet_schedule(&dev->bh);
2675 spin_unlock_irqrestore(&dev->done.lock, flags);
2680 static void tx_complete(struct urb *urb)
2682 struct sk_buff *skb = (struct sk_buff *)urb->context;
2683 struct skb_data *entry = (struct skb_data *)skb->cb;
2684 struct lan78xx_net *dev = entry->dev;
2686 if (urb->status == 0) {
2687 dev->net->stats.tx_packets += entry->num_of_packet;
2688 dev->net->stats.tx_bytes += entry->length;
2690 dev->net->stats.tx_errors++;
2692 switch (urb->status) {
2694 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2697 /* software-driven interface shutdown */
2705 netif_stop_queue(dev->net);
2708 netif_dbg(dev, tx_err, dev->net,
2709 "tx err %d\n", entry->urb->status);
2714 usb_autopm_put_interface_async(dev->intf);
2716 defer_bh(dev, skb, &dev->txq, tx_done);
2719 static void lan78xx_queue_skb(struct sk_buff_head *list,
2720 struct sk_buff *newsk, enum skb_state state)
2722 struct skb_data *entry = (struct skb_data *)newsk->cb;
2724 __skb_queue_tail(list, newsk);
2725 entry->state = state;
2729 lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
2731 struct lan78xx_net *dev = netdev_priv(net);
2732 struct sk_buff *skb2 = NULL;
2735 skb_tx_timestamp(skb);
2736 skb2 = lan78xx_tx_prep(dev, skb, GFP_ATOMIC);
2740 skb_queue_tail(&dev->txq_pend, skb2);
2742 /* throttle TX patch at slower than SUPER SPEED USB */
2743 if ((dev->udev->speed < USB_SPEED_SUPER) &&
2744 (skb_queue_len(&dev->txq_pend) > 10))
2745 netif_stop_queue(net);
2747 netif_dbg(dev, tx_err, dev->net,
2748 "lan78xx_tx_prep return NULL\n");
2749 dev->net->stats.tx_errors++;
2750 dev->net->stats.tx_dropped++;
2753 tasklet_schedule(&dev->bh);
2755 return NETDEV_TX_OK;
2758 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
2760 struct lan78xx_priv *pdata = NULL;
2764 dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
2766 pdata = (struct lan78xx_priv *)(dev->data[0]);
2768 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
2774 spin_lock_init(&pdata->rfe_ctl_lock);
2775 mutex_init(&pdata->dataport_mutex);
2777 INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
2779 for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
2780 pdata->vlan_table[i] = 0;
2782 INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
2784 dev->net->features = 0;
2786 if (DEFAULT_TX_CSUM_ENABLE)
2787 dev->net->features |= NETIF_F_HW_CSUM;
2789 if (DEFAULT_RX_CSUM_ENABLE)
2790 dev->net->features |= NETIF_F_RXCSUM;
2792 if (DEFAULT_TSO_CSUM_ENABLE)
2793 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
2795 dev->net->hw_features = dev->net->features;
2797 ret = lan78xx_setup_irq_domain(dev);
2799 netdev_warn(dev->net,
2800 "lan78xx_setup_irq_domain() failed : %d", ret);
2804 dev->net->hard_header_len += TX_OVERHEAD;
2805 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
2807 /* Init all registers */
2808 ret = lan78xx_reset(dev);
2810 netdev_warn(dev->net, "Registers INIT FAILED....");
2814 ret = lan78xx_mdio_init(dev);
2816 netdev_warn(dev->net, "MDIO INIT FAILED.....");
2820 dev->net->flags |= IFF_MULTICAST;
2822 pdata->wol = WAKE_MAGIC;
2827 lan78xx_remove_irq_domain(dev);
2830 netdev_warn(dev->net, "Bind routine FAILED");
2831 cancel_work_sync(&pdata->set_multicast);
2832 cancel_work_sync(&pdata->set_vlan);
2837 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
2839 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2841 lan78xx_remove_irq_domain(dev);
2843 lan78xx_remove_mdio(dev);
2846 cancel_work_sync(&pdata->set_multicast);
2847 cancel_work_sync(&pdata->set_vlan);
2848 netif_dbg(dev, ifdown, dev->net, "free pdata");
2855 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
2856 struct sk_buff *skb,
2857 u32 rx_cmd_a, u32 rx_cmd_b)
2859 if (!(dev->net->features & NETIF_F_RXCSUM) ||
2860 unlikely(rx_cmd_a & RX_CMD_A_ICSM_)) {
2861 skb->ip_summed = CHECKSUM_NONE;
2863 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
2864 skb->ip_summed = CHECKSUM_COMPLETE;
2868 static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
2872 if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
2873 skb_queue_tail(&dev->rxq_pause, skb);
2877 dev->net->stats.rx_packets++;
2878 dev->net->stats.rx_bytes += skb->len;
2880 skb->protocol = eth_type_trans(skb, dev->net);
2882 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
2883 skb->len + sizeof(struct ethhdr), skb->protocol);
2884 memset(skb->cb, 0, sizeof(struct skb_data));
2886 if (skb_defer_rx_timestamp(skb))
2889 status = netif_rx(skb);
2890 if (status != NET_RX_SUCCESS)
2891 netif_dbg(dev, rx_err, dev->net,
2892 "netif_rx status %d\n", status);
2895 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb)
2897 if (skb->len < dev->net->hard_header_len)
2900 while (skb->len > 0) {
2901 u32 rx_cmd_a, rx_cmd_b, align_count, size;
2903 struct sk_buff *skb2;
2904 unsigned char *packet;
2906 memcpy(&rx_cmd_a, skb->data, sizeof(rx_cmd_a));
2907 le32_to_cpus(&rx_cmd_a);
2908 skb_pull(skb, sizeof(rx_cmd_a));
2910 memcpy(&rx_cmd_b, skb->data, sizeof(rx_cmd_b));
2911 le32_to_cpus(&rx_cmd_b);
2912 skb_pull(skb, sizeof(rx_cmd_b));
2914 memcpy(&rx_cmd_c, skb->data, sizeof(rx_cmd_c));
2915 le16_to_cpus(&rx_cmd_c);
2916 skb_pull(skb, sizeof(rx_cmd_c));
2920 /* get the packet length */
2921 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
2922 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
2924 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
2925 netif_dbg(dev, rx_err, dev->net,
2926 "Error rx_cmd_a=0x%08x", rx_cmd_a);
2928 /* last frame in this batch */
2929 if (skb->len == size) {
2930 lan78xx_rx_csum_offload(dev, skb,
2931 rx_cmd_a, rx_cmd_b);
2933 skb_trim(skb, skb->len - 4); /* remove fcs */
2934 skb->truesize = size + sizeof(struct sk_buff);
2939 skb2 = skb_clone(skb, GFP_ATOMIC);
2940 if (unlikely(!skb2)) {
2941 netdev_warn(dev->net, "Error allocating skb");
2946 skb2->data = packet;
2947 skb_set_tail_pointer(skb2, size);
2949 lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
2951 skb_trim(skb2, skb2->len - 4); /* remove fcs */
2952 skb2->truesize = size + sizeof(struct sk_buff);
2954 lan78xx_skb_return(dev, skb2);
2957 skb_pull(skb, size);
2959 /* padding bytes before the next frame starts */
2961 skb_pull(skb, align_count);
2967 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb)
2969 if (!lan78xx_rx(dev, skb)) {
2970 dev->net->stats.rx_errors++;
2975 lan78xx_skb_return(dev, skb);
2979 netif_dbg(dev, rx_err, dev->net, "drop\n");
2980 dev->net->stats.rx_errors++;
2982 skb_queue_tail(&dev->done, skb);
2985 static void rx_complete(struct urb *urb);
2987 static int rx_submit(struct lan78xx_net *dev, struct urb *urb, gfp_t flags)
2989 struct sk_buff *skb;
2990 struct skb_data *entry;
2991 unsigned long lockflags;
2992 size_t size = dev->rx_urb_size;
2995 skb = netdev_alloc_skb_ip_align(dev->net, size);
3001 entry = (struct skb_data *)skb->cb;
3006 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3007 skb->data, size, rx_complete, skb);
3009 spin_lock_irqsave(&dev->rxq.lock, lockflags);
3011 if (netif_device_present(dev->net) &&
3012 netif_running(dev->net) &&
3013 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3014 !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3015 ret = usb_submit_urb(urb, GFP_ATOMIC);
3018 lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3021 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3024 netif_dbg(dev, ifdown, dev->net, "device gone\n");
3025 netif_device_detach(dev->net);
3031 netif_dbg(dev, rx_err, dev->net,
3032 "rx submit, %d\n", ret);
3033 tasklet_schedule(&dev->bh);
3036 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3039 spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3041 dev_kfree_skb_any(skb);
3047 static void rx_complete(struct urb *urb)
3049 struct sk_buff *skb = (struct sk_buff *)urb->context;
3050 struct skb_data *entry = (struct skb_data *)skb->cb;
3051 struct lan78xx_net *dev = entry->dev;
3052 int urb_status = urb->status;
3053 enum skb_state state;
3055 skb_put(skb, urb->actual_length);
3059 switch (urb_status) {
3061 if (skb->len < dev->net->hard_header_len) {
3063 dev->net->stats.rx_errors++;
3064 dev->net->stats.rx_length_errors++;
3065 netif_dbg(dev, rx_err, dev->net,
3066 "rx length %d\n", skb->len);
3068 usb_mark_last_busy(dev->udev);
3071 dev->net->stats.rx_errors++;
3072 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3074 case -ECONNRESET: /* async unlink */
3075 case -ESHUTDOWN: /* hardware gone */
3076 netif_dbg(dev, ifdown, dev->net,
3077 "rx shutdown, code %d\n", urb_status);
3085 dev->net->stats.rx_errors++;
3091 /* data overrun ... flush fifo? */
3093 dev->net->stats.rx_over_errors++;
3098 dev->net->stats.rx_errors++;
3099 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3103 state = defer_bh(dev, skb, &dev->rxq, state);
3106 if (netif_running(dev->net) &&
3107 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3108 state != unlink_start) {
3109 rx_submit(dev, urb, GFP_ATOMIC);
3114 netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
3117 static void lan78xx_tx_bh(struct lan78xx_net *dev)
3120 struct urb *urb = NULL;
3121 struct skb_data *entry;
3122 unsigned long flags;
3123 struct sk_buff_head *tqp = &dev->txq_pend;
3124 struct sk_buff *skb, *skb2;
3127 int skb_totallen, pkt_cnt;
3133 spin_lock_irqsave(&tqp->lock, flags);
3134 for (skb = tqp->next; pkt_cnt < tqp->qlen; skb = skb->next) {
3135 if (skb_is_gso(skb)) {
3137 /* handle previous packets first */
3141 length = skb->len - TX_OVERHEAD;
3142 __skb_unlink(skb, tqp);
3143 spin_unlock_irqrestore(&tqp->lock, flags);
3147 if ((skb_totallen + skb->len) > MAX_SINGLE_PACKET_SIZE)
3149 skb_totallen = skb->len + roundup(skb_totallen, sizeof(u32));
3152 spin_unlock_irqrestore(&tqp->lock, flags);
3154 /* copy to a single skb */
3155 skb = alloc_skb(skb_totallen, GFP_ATOMIC);
3159 skb_put(skb, skb_totallen);
3161 for (count = pos = 0; count < pkt_cnt; count++) {
3162 skb2 = skb_dequeue(tqp);
3164 length += (skb2->len - TX_OVERHEAD);
3165 memcpy(skb->data + pos, skb2->data, skb2->len);
3166 pos += roundup(skb2->len, sizeof(u32));
3167 dev_kfree_skb(skb2);
3172 urb = usb_alloc_urb(0, GFP_ATOMIC);
3176 entry = (struct skb_data *)skb->cb;
3179 entry->length = length;
3180 entry->num_of_packet = count;
3182 spin_lock_irqsave(&dev->txq.lock, flags);
3183 ret = usb_autopm_get_interface_async(dev->intf);
3185 spin_unlock_irqrestore(&dev->txq.lock, flags);
3189 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_out,
3190 skb->data, skb->len, tx_complete, skb);
3192 if (length % dev->maxpacket == 0) {
3193 /* send USB_ZERO_PACKET */
3194 urb->transfer_flags |= URB_ZERO_PACKET;
3198 /* if this triggers the device is still a sleep */
3199 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3200 /* transmission will be done in resume */
3201 usb_anchor_urb(urb, &dev->deferred);
3202 /* no use to process more packets */
3203 netif_stop_queue(dev->net);
3205 spin_unlock_irqrestore(&dev->txq.lock, flags);
3206 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
3211 ret = usb_submit_urb(urb, GFP_ATOMIC);
3214 netif_trans_update(dev->net);
3215 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3216 if (skb_queue_len(&dev->txq) >= dev->tx_qlen)
3217 netif_stop_queue(dev->net);
3220 netif_stop_queue(dev->net);
3221 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3222 usb_autopm_put_interface_async(dev->intf);
3225 usb_autopm_put_interface_async(dev->intf);
3226 netif_dbg(dev, tx_err, dev->net,
3227 "tx: submit urb err %d\n", ret);
3231 spin_unlock_irqrestore(&dev->txq.lock, flags);
3234 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", ret);
3236 dev->net->stats.tx_dropped++;
3238 dev_kfree_skb_any(skb);
3241 netif_dbg(dev, tx_queued, dev->net,
3242 "> tx, len %d, type 0x%x\n", length, skb->protocol);
3245 static void lan78xx_rx_bh(struct lan78xx_net *dev)
3250 if (skb_queue_len(&dev->rxq) < dev->rx_qlen) {
3251 for (i = 0; i < 10; i++) {
3252 if (skb_queue_len(&dev->rxq) >= dev->rx_qlen)
3254 urb = usb_alloc_urb(0, GFP_ATOMIC);
3256 if (rx_submit(dev, urb, GFP_ATOMIC) == -ENOLINK)
3260 if (skb_queue_len(&dev->rxq) < dev->rx_qlen)
3261 tasklet_schedule(&dev->bh);
3263 if (skb_queue_len(&dev->txq) < dev->tx_qlen)
3264 netif_wake_queue(dev->net);
3267 static void lan78xx_bh(unsigned long param)
3269 struct lan78xx_net *dev = (struct lan78xx_net *)param;
3270 struct sk_buff *skb;
3271 struct skb_data *entry;
3273 while ((skb = skb_dequeue(&dev->done))) {
3274 entry = (struct skb_data *)(skb->cb);
3275 switch (entry->state) {
3277 entry->state = rx_cleanup;
3278 rx_process(dev, skb);
3281 usb_free_urb(entry->urb);
3285 usb_free_urb(entry->urb);
3289 netdev_dbg(dev->net, "skb state %d\n", entry->state);
3294 if (netif_device_present(dev->net) && netif_running(dev->net)) {
3295 /* reset update timer delta */
3296 if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
3298 mod_timer(&dev->stat_monitor,
3299 jiffies + STAT_UPDATE_TIMER);
3302 if (!skb_queue_empty(&dev->txq_pend))
3305 if (!timer_pending(&dev->delay) &&
3306 !test_bit(EVENT_RX_HALT, &dev->flags))
3311 static void lan78xx_delayedwork(struct work_struct *work)
3314 struct lan78xx_net *dev;
3316 dev = container_of(work, struct lan78xx_net, wq.work);
3318 if (test_bit(EVENT_TX_HALT, &dev->flags)) {
3319 unlink_urbs(dev, &dev->txq);
3320 status = usb_autopm_get_interface(dev->intf);
3323 status = usb_clear_halt(dev->udev, dev->pipe_out);
3324 usb_autopm_put_interface(dev->intf);
3327 status != -ESHUTDOWN) {
3328 if (netif_msg_tx_err(dev))
3330 netdev_err(dev->net,
3331 "can't clear tx halt, status %d\n",
3334 clear_bit(EVENT_TX_HALT, &dev->flags);
3335 if (status != -ESHUTDOWN)
3336 netif_wake_queue(dev->net);
3339 if (test_bit(EVENT_RX_HALT, &dev->flags)) {
3340 unlink_urbs(dev, &dev->rxq);
3341 status = usb_autopm_get_interface(dev->intf);
3344 status = usb_clear_halt(dev->udev, dev->pipe_in);
3345 usb_autopm_put_interface(dev->intf);
3348 status != -ESHUTDOWN) {
3349 if (netif_msg_rx_err(dev))
3351 netdev_err(dev->net,
3352 "can't clear rx halt, status %d\n",
3355 clear_bit(EVENT_RX_HALT, &dev->flags);
3356 tasklet_schedule(&dev->bh);
3360 if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
3363 clear_bit(EVENT_LINK_RESET, &dev->flags);
3364 status = usb_autopm_get_interface(dev->intf);
3367 if (lan78xx_link_reset(dev) < 0) {
3368 usb_autopm_put_interface(dev->intf);
3370 netdev_info(dev->net, "link reset failed (%d)\n",
3373 usb_autopm_put_interface(dev->intf);
3377 if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
3378 lan78xx_update_stats(dev);
3380 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3382 mod_timer(&dev->stat_monitor,
3383 jiffies + (STAT_UPDATE_TIMER * dev->delta));
3385 dev->delta = min((dev->delta * 2), 50);
3389 static void intr_complete(struct urb *urb)
3391 struct lan78xx_net *dev = urb->context;
3392 int status = urb->status;
3397 lan78xx_status(dev, urb);
3400 /* software-driven interface shutdown */
3401 case -ENOENT: /* urb killed */
3402 case -ESHUTDOWN: /* hardware gone */
3403 netif_dbg(dev, ifdown, dev->net,
3404 "intr shutdown, code %d\n", status);
3407 /* NOTE: not throttling like RX/TX, since this endpoint
3408 * already polls infrequently
3411 netdev_dbg(dev->net, "intr status %d\n", status);
3415 if (!netif_running(dev->net))
3418 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
3419 status = usb_submit_urb(urb, GFP_ATOMIC);
3421 netif_err(dev, timer, dev->net,
3422 "intr resubmit --> %d\n", status);
3425 static void lan78xx_disconnect(struct usb_interface *intf)
3427 struct lan78xx_net *dev;
3428 struct usb_device *udev;
3429 struct net_device *net;
3431 dev = usb_get_intfdata(intf);
3432 usb_set_intfdata(intf, NULL);
3436 udev = interface_to_usbdev(intf);
3439 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
3440 phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
3442 phy_disconnect(net->phydev);
3444 unregister_netdev(net);
3446 cancel_delayed_work_sync(&dev->wq);
3448 usb_scuttle_anchored_urbs(&dev->deferred);
3450 lan78xx_unbind(dev, intf);
3452 usb_kill_urb(dev->urb_intr);
3453 usb_free_urb(dev->urb_intr);
3459 static void lan78xx_tx_timeout(struct net_device *net)
3461 struct lan78xx_net *dev = netdev_priv(net);
3463 unlink_urbs(dev, &dev->txq);
3464 tasklet_schedule(&dev->bh);
3467 static netdev_features_t lan78xx_features_check(struct sk_buff *skb,
3468 struct net_device *netdev,
3469 netdev_features_t features)
3471 if (skb->len + TX_OVERHEAD > MAX_SINGLE_PACKET_SIZE)
3472 features &= ~NETIF_F_GSO_MASK;
3474 features = vlan_features_check(skb, features);
3475 features = vxlan_features_check(skb, features);
3480 static const struct net_device_ops lan78xx_netdev_ops = {
3481 .ndo_open = lan78xx_open,
3482 .ndo_stop = lan78xx_stop,
3483 .ndo_start_xmit = lan78xx_start_xmit,
3484 .ndo_tx_timeout = lan78xx_tx_timeout,
3485 .ndo_change_mtu = lan78xx_change_mtu,
3486 .ndo_set_mac_address = lan78xx_set_mac_addr,
3487 .ndo_validate_addr = eth_validate_addr,
3488 .ndo_do_ioctl = lan78xx_ioctl,
3489 .ndo_set_rx_mode = lan78xx_set_multicast,
3490 .ndo_set_features = lan78xx_set_features,
3491 .ndo_vlan_rx_add_vid = lan78xx_vlan_rx_add_vid,
3492 .ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid,
3493 .ndo_features_check = lan78xx_features_check,
3496 static void lan78xx_stat_monitor(unsigned long param)
3498 struct lan78xx_net *dev;
3500 dev = (struct lan78xx_net *)param;
3502 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
3505 static int lan78xx_probe(struct usb_interface *intf,
3506 const struct usb_device_id *id)
3508 struct usb_host_endpoint *ep_blkin, *ep_blkout, *ep_intr;
3509 struct lan78xx_net *dev;
3510 struct net_device *netdev;
3511 struct usb_device *udev;
3517 udev = interface_to_usbdev(intf);
3518 udev = usb_get_dev(udev);
3520 netdev = alloc_etherdev(sizeof(struct lan78xx_net));
3522 dev_err(&intf->dev, "Error: OOM\n");
3527 /* netdev_printk() needs this */
3528 SET_NETDEV_DEV(netdev, &intf->dev);
3530 dev = netdev_priv(netdev);
3534 dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
3535 | NETIF_MSG_PROBE | NETIF_MSG_LINK);
3537 skb_queue_head_init(&dev->rxq);
3538 skb_queue_head_init(&dev->txq);
3539 skb_queue_head_init(&dev->done);
3540 skb_queue_head_init(&dev->rxq_pause);
3541 skb_queue_head_init(&dev->txq_pend);
3542 mutex_init(&dev->phy_mutex);
3544 tasklet_init(&dev->bh, lan78xx_bh, (unsigned long)dev);
3545 INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
3546 init_usb_anchor(&dev->deferred);
3548 netdev->netdev_ops = &lan78xx_netdev_ops;
3549 netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
3550 netdev->ethtool_ops = &lan78xx_ethtool_ops;
3552 dev->stat_monitor.function = lan78xx_stat_monitor;
3553 dev->stat_monitor.data = (unsigned long)dev;
3555 init_timer(&dev->stat_monitor);
3557 mutex_init(&dev->stats.access_lock);
3559 if (intf->cur_altsetting->desc.bNumEndpoints < 3) {
3564 dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
3565 ep_blkin = usb_pipe_endpoint(udev, dev->pipe_in);
3566 if (!ep_blkin || !usb_endpoint_is_bulk_in(&ep_blkin->desc)) {
3571 dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
3572 ep_blkout = usb_pipe_endpoint(udev, dev->pipe_out);
3573 if (!ep_blkout || !usb_endpoint_is_bulk_out(&ep_blkout->desc)) {
3578 ep_intr = &intf->cur_altsetting->endpoint[2];
3579 if (!usb_endpoint_is_int_in(&ep_intr->desc)) {
3584 dev->pipe_intr = usb_rcvintpipe(dev->udev,
3585 usb_endpoint_num(&ep_intr->desc));
3587 ret = lan78xx_bind(dev, intf);
3590 strcpy(netdev->name, "eth%d");
3592 if (netdev->mtu > (dev->hard_mtu - netdev->hard_header_len))
3593 netdev->mtu = dev->hard_mtu - netdev->hard_header_len;
3595 /* MTU range: 68 - 9000 */
3596 netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
3597 netif_set_gso_max_size(netdev, MAX_SINGLE_PACKET_SIZE - MAX_HEADER);
3599 period = ep_intr->desc.bInterval;
3600 maxp = usb_maxpacket(dev->udev, dev->pipe_intr, 0);
3601 buf = kmalloc(maxp, GFP_KERNEL);
3603 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
3604 if (!dev->urb_intr) {
3609 usb_fill_int_urb(dev->urb_intr, dev->udev,
3610 dev->pipe_intr, buf, maxp,
3611 intr_complete, dev, period);
3612 dev->urb_intr->transfer_flags |= URB_FREE_BUFFER;
3616 dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out, 1);
3618 /* driver requires remote-wakeup capability during autosuspend. */
3619 intf->needs_remote_wakeup = 1;
3621 ret = lan78xx_phy_init(dev);
3625 ret = register_netdev(netdev);
3627 netif_err(dev, probe, netdev, "couldn't register the device\n");
3631 usb_set_intfdata(intf, dev);
3633 ret = device_set_wakeup_enable(&udev->dev, true);
3635 /* Default delay of 2sec has more overhead than advantage.
3636 * Set to 10sec as default.
3638 pm_runtime_set_autosuspend_delay(&udev->dev,
3639 DEFAULT_AUTOSUSPEND_DELAY);
3644 phy_disconnect(netdev->phydev);
3646 usb_free_urb(dev->urb_intr);
3648 lan78xx_unbind(dev, intf);
3650 free_netdev(netdev);
3657 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
3659 const u16 crc16poly = 0x8005;
3665 for (i = 0; i < len; i++) {
3667 for (bit = 0; bit < 8; bit++) {
3671 if (msb ^ (u16)(data & 1)) {
3673 crc |= (u16)0x0001U;
3682 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
3690 const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
3691 const u8 ipv6_multicast[3] = { 0x33, 0x33 };
3692 const u8 arp_type[2] = { 0x08, 0x06 };
3694 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3695 buf &= ~MAC_TX_TXEN_;
3696 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3697 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3698 buf &= ~MAC_RX_RXEN_;
3699 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3701 ret = lan78xx_write_reg(dev, WUCSR, 0);
3702 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3703 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3708 ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
3709 temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
3710 temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
3712 for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
3713 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
3716 if (wol & WAKE_PHY) {
3717 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
3719 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3720 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3721 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3723 if (wol & WAKE_MAGIC) {
3724 temp_wucsr |= WUCSR_MPEN_;
3726 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3727 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3728 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
3730 if (wol & WAKE_BCAST) {
3731 temp_wucsr |= WUCSR_BCST_EN_;
3733 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3734 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3735 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3737 if (wol & WAKE_MCAST) {
3738 temp_wucsr |= WUCSR_WAKE_EN_;
3740 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
3741 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
3742 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3744 WUF_CFGX_TYPE_MCAST_ |
3745 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3746 (crc & WUF_CFGX_CRC16_MASK_));
3748 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
3749 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3750 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3751 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3754 /* for IPv6 Multicast */
3755 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
3756 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3758 WUF_CFGX_TYPE_MCAST_ |
3759 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3760 (crc & WUF_CFGX_CRC16_MASK_));
3762 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
3763 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3764 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3765 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3768 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3769 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3770 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3772 if (wol & WAKE_UCAST) {
3773 temp_wucsr |= WUCSR_PFDA_EN_;
3775 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3776 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3777 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3779 if (wol & WAKE_ARP) {
3780 temp_wucsr |= WUCSR_WAKE_EN_;
3782 /* set WUF_CFG & WUF_MASK
3783 * for packettype (offset 12,13) = ARP (0x0806)
3785 crc = lan78xx_wakeframe_crc16(arp_type, 2);
3786 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3788 WUF_CFGX_TYPE_ALL_ |
3789 (0 << WUF_CFGX_OFFSET_SHIFT_) |
3790 (crc & WUF_CFGX_CRC16_MASK_));
3792 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
3793 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3794 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3795 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3798 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3799 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3800 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3803 ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
3805 /* when multiple WOL bits are set */
3806 if (hweight_long((unsigned long)wol) > 1) {
3807 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3808 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3809 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3811 ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
3814 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3815 buf |= PMT_CTL_WUPS_MASK_;
3816 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3818 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3819 buf |= MAC_RX_RXEN_;
3820 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3825 static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
3827 struct lan78xx_net *dev = usb_get_intfdata(intf);
3828 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3833 event = message.event;
3835 if (!dev->suspend_count++) {
3836 spin_lock_irq(&dev->txq.lock);
3837 /* don't autosuspend while transmitting */
3838 if ((skb_queue_len(&dev->txq) ||
3839 skb_queue_len(&dev->txq_pend)) &&
3840 PMSG_IS_AUTO(message)) {
3841 spin_unlock_irq(&dev->txq.lock);
3845 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
3846 spin_unlock_irq(&dev->txq.lock);
3850 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3851 buf &= ~MAC_TX_TXEN_;
3852 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3853 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3854 buf &= ~MAC_RX_RXEN_;
3855 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3857 /* empty out the rx and queues */
3858 netif_device_detach(dev->net);
3859 lan78xx_terminate_urbs(dev);
3860 usb_kill_urb(dev->urb_intr);
3863 netif_device_attach(dev->net);
3866 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3867 del_timer(&dev->stat_monitor);
3869 if (PMSG_IS_AUTO(message)) {
3870 /* auto suspend (selective suspend) */
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 ret = lan78xx_write_reg(dev, WUCSR, 0);
3879 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3880 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3882 /* set goodframe wakeup */
3883 ret = lan78xx_read_reg(dev, WUCSR, &buf);
3885 buf |= WUCSR_RFE_WAKE_EN_;
3886 buf |= WUCSR_STORE_WAKE_;
3888 ret = lan78xx_write_reg(dev, WUCSR, buf);
3890 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3892 buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
3893 buf |= PMT_CTL_RES_CLR_WKP_STS_;
3895 buf |= PMT_CTL_PHY_WAKE_EN_;
3896 buf |= PMT_CTL_WOL_EN_;
3897 buf &= ~PMT_CTL_SUS_MODE_MASK_;
3898 buf |= PMT_CTL_SUS_MODE_3_;
3900 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3902 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3904 buf |= PMT_CTL_WUPS_MASK_;
3906 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3908 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3909 buf |= MAC_RX_RXEN_;
3910 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3912 lan78xx_set_suspend(dev, pdata->wol);
3921 static int lan78xx_resume(struct usb_interface *intf)
3923 struct lan78xx_net *dev = usb_get_intfdata(intf);
3924 struct sk_buff *skb;
3929 if (!timer_pending(&dev->stat_monitor)) {
3931 mod_timer(&dev->stat_monitor,
3932 jiffies + STAT_UPDATE_TIMER);
3935 if (!--dev->suspend_count) {
3936 /* resume interrupt URBs */
3937 if (dev->urb_intr && test_bit(EVENT_DEV_OPEN, &dev->flags))
3938 usb_submit_urb(dev->urb_intr, GFP_NOIO);
3940 spin_lock_irq(&dev->txq.lock);
3941 while ((res = usb_get_from_anchor(&dev->deferred))) {
3942 skb = (struct sk_buff *)res->context;
3943 ret = usb_submit_urb(res, GFP_ATOMIC);
3945 dev_kfree_skb_any(skb);
3947 usb_autopm_put_interface_async(dev->intf);
3949 netif_trans_update(dev->net);
3950 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3954 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
3955 spin_unlock_irq(&dev->txq.lock);
3957 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
3958 if (!(skb_queue_len(&dev->txq) >= dev->tx_qlen))
3959 netif_start_queue(dev->net);
3960 tasklet_schedule(&dev->bh);
3964 ret = lan78xx_write_reg(dev, WUCSR2, 0);
3965 ret = lan78xx_write_reg(dev, WUCSR, 0);
3966 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3968 ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
3970 WUCSR2_IPV6_TCPSYN_RCD_ |
3971 WUCSR2_IPV4_TCPSYN_RCD_);
3973 ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
3974 WUCSR_EEE_RX_WAKE_ |
3976 WUCSR_RFE_WAKE_FR_ |
3981 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3982 buf |= MAC_TX_TXEN_;
3983 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3988 static int lan78xx_reset_resume(struct usb_interface *intf)
3990 struct lan78xx_net *dev = usb_get_intfdata(intf);
3994 phy_start(dev->net->phydev);
3996 return lan78xx_resume(intf);
3999 static const struct usb_device_id products[] = {
4001 /* LAN7800 USB Gigabit Ethernet Device */
4002 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
4005 /* LAN7850 USB Gigabit Ethernet Device */
4006 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
4009 /* LAN7801 USB Gigabit Ethernet Device */
4010 USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
4014 MODULE_DEVICE_TABLE(usb, products);
4016 static struct usb_driver lan78xx_driver = {
4017 .name = DRIVER_NAME,
4018 .id_table = products,
4019 .probe = lan78xx_probe,
4020 .disconnect = lan78xx_disconnect,
4021 .suspend = lan78xx_suspend,
4022 .resume = lan78xx_resume,
4023 .reset_resume = lan78xx_reset_resume,
4024 .supports_autosuspend = 1,
4025 .disable_hub_initiated_lpm = 1,
4028 module_usb_driver(lan78xx_driver);
4030 MODULE_AUTHOR(DRIVER_AUTHOR);
4031 MODULE_DESCRIPTION(DRIVER_DESC);
4032 MODULE_LICENSE("GPL");