xref: /linux/drivers/net/usb/lan78xx.c (revision a19d0236f466f1ce8f44a04a96c302d3023eebf4)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2015 Microchip Technology
4  */
5 #include <linux/module.h>
6 #include <linux/netdevice.h>
7 #include <linux/etherdevice.h>
8 #include <linux/ethtool.h>
9 #include <linux/usb.h>
10 #include <linux/crc32.h>
11 #include <linux/signal.h>
12 #include <linux/slab.h>
13 #include <linux/if_vlan.h>
14 #include <linux/uaccess.h>
15 #include <linux/linkmode.h>
16 #include <linux/list.h>
17 #include <linux/ip.h>
18 #include <linux/ipv6.h>
19 #include <linux/mdio.h>
20 #include <linux/phy.h>
21 #include <net/ip6_checksum.h>
22 #include <net/vxlan.h>
23 #include <linux/interrupt.h>
24 #include <linux/irqdomain.h>
25 #include <linux/irq.h>
26 #include <linux/irqchip/chained_irq.h>
27 #include <linux/microchipphy.h>
28 #include <linux/phy_fixed.h>
29 #include <linux/of_mdio.h>
30 #include <linux/of_net.h>
31 #include "lan78xx.h"
32 
33 #define DRIVER_AUTHOR	"WOOJUNG HUH <woojung.huh@microchip.com>"
34 #define DRIVER_DESC	"LAN78XX USB 3.0 Gigabit Ethernet Devices"
35 #define DRIVER_NAME	"lan78xx"
36 
37 #define TX_TIMEOUT_JIFFIES		(5 * HZ)
38 #define THROTTLE_JIFFIES		(HZ / 8)
39 #define UNLINK_TIMEOUT_MS		3
40 
41 #define RX_MAX_QUEUE_MEMORY		(60 * 1518)
42 
43 #define SS_USB_PKT_SIZE			(1024)
44 #define HS_USB_PKT_SIZE			(512)
45 #define FS_USB_PKT_SIZE			(64)
46 
47 #define MAX_RX_FIFO_SIZE		(12 * 1024)
48 #define MAX_TX_FIFO_SIZE		(12 * 1024)
49 
50 #define FLOW_THRESHOLD(n)		((((n) + 511) / 512) & 0x7F)
51 #define FLOW_CTRL_THRESHOLD(on, off)	((FLOW_THRESHOLD(on)  << 0) | \
52 					 (FLOW_THRESHOLD(off) << 8))
53 
54 /* Flow control turned on when Rx FIFO level rises above this level (bytes) */
55 #define FLOW_ON_SS			9216
56 #define FLOW_ON_HS			8704
57 
58 /* Flow control turned off when Rx FIFO level falls below this level (bytes) */
59 #define FLOW_OFF_SS			4096
60 #define FLOW_OFF_HS			1024
61 
62 #define DEFAULT_BURST_CAP_SIZE		(MAX_TX_FIFO_SIZE)
63 #define DEFAULT_BULK_IN_DELAY		(0x0800)
64 #define MAX_SINGLE_PACKET_SIZE		(9000)
65 #define DEFAULT_TX_CSUM_ENABLE		(true)
66 #define DEFAULT_RX_CSUM_ENABLE		(true)
67 #define DEFAULT_TSO_CSUM_ENABLE		(true)
68 #define DEFAULT_VLAN_FILTER_ENABLE	(true)
69 #define DEFAULT_VLAN_RX_OFFLOAD		(true)
70 #define TX_ALIGNMENT			(4)
71 #define RXW_PADDING			2
72 
73 #define LAN78XX_USB_VENDOR_ID		(0x0424)
74 #define LAN7800_USB_PRODUCT_ID		(0x7800)
75 #define LAN7850_USB_PRODUCT_ID		(0x7850)
76 #define LAN7801_USB_PRODUCT_ID		(0x7801)
77 #define LAN78XX_EEPROM_MAGIC		(0x78A5)
78 #define LAN78XX_OTP_MAGIC		(0x78F3)
79 #define AT29M2AF_USB_VENDOR_ID		(0x07C9)
80 #define AT29M2AF_USB_PRODUCT_ID	(0x0012)
81 
82 #define	MII_READ			1
83 #define	MII_WRITE			0
84 
85 #define EEPROM_INDICATOR		(0xA5)
86 #define EEPROM_MAC_OFFSET		(0x01)
87 #define MAX_EEPROM_SIZE			512
88 #define OTP_INDICATOR_1			(0xF3)
89 #define OTP_INDICATOR_2			(0xF7)
90 
91 #define WAKE_ALL			(WAKE_PHY | WAKE_UCAST | \
92 					 WAKE_MCAST | WAKE_BCAST | \
93 					 WAKE_ARP | WAKE_MAGIC)
94 
95 #define TX_URB_NUM			10
96 #define TX_SS_URB_NUM			TX_URB_NUM
97 #define TX_HS_URB_NUM			TX_URB_NUM
98 #define TX_FS_URB_NUM			TX_URB_NUM
99 
100 /* A single URB buffer must be large enough to hold a complete jumbo packet
101  */
102 #define TX_SS_URB_SIZE			(32 * 1024)
103 #define TX_HS_URB_SIZE			(16 * 1024)
104 #define TX_FS_URB_SIZE			(10 * 1024)
105 
106 #define RX_SS_URB_NUM			30
107 #define RX_HS_URB_NUM			10
108 #define RX_FS_URB_NUM			10
109 #define RX_SS_URB_SIZE			TX_SS_URB_SIZE
110 #define RX_HS_URB_SIZE			TX_HS_URB_SIZE
111 #define RX_FS_URB_SIZE			TX_FS_URB_SIZE
112 
113 #define SS_BURST_CAP_SIZE		RX_SS_URB_SIZE
114 #define SS_BULK_IN_DELAY		0x2000
115 #define HS_BURST_CAP_SIZE		RX_HS_URB_SIZE
116 #define HS_BULK_IN_DELAY		0x2000
117 #define FS_BURST_CAP_SIZE		RX_FS_URB_SIZE
118 #define FS_BULK_IN_DELAY		0x2000
119 
120 #define TX_CMD_LEN			8
121 #define TX_SKB_MIN_LEN			(TX_CMD_LEN + ETH_HLEN)
122 #define LAN78XX_TSO_SIZE(dev)		((dev)->tx_urb_size - TX_SKB_MIN_LEN)
123 
124 #define RX_CMD_LEN			10
125 #define RX_SKB_MIN_LEN			(RX_CMD_LEN + ETH_HLEN)
126 #define RX_MAX_FRAME_LEN(mtu)		((mtu) + ETH_HLEN + VLAN_HLEN)
127 
128 /* USB related defines */
129 #define BULK_IN_PIPE			1
130 #define BULK_OUT_PIPE			2
131 
132 /* default autosuspend delay (mSec)*/
133 #define DEFAULT_AUTOSUSPEND_DELAY	(10 * 1000)
134 
135 /* statistic update interval (mSec) */
136 #define STAT_UPDATE_TIMER		(1 * 1000)
137 
138 /* time to wait for MAC or FCT to stop (jiffies) */
139 #define HW_DISABLE_TIMEOUT		(HZ / 10)
140 
141 /* time to wait between polling MAC or FCT state (ms) */
142 #define HW_DISABLE_DELAY_MS		1
143 
144 /* defines interrupts from interrupt EP */
145 #define MAX_INT_EP			(32)
146 #define INT_EP_INTEP			(31)
147 #define INT_EP_OTP_WR_DONE		(28)
148 #define INT_EP_EEE_TX_LPI_START		(26)
149 #define INT_EP_EEE_TX_LPI_STOP		(25)
150 #define INT_EP_EEE_RX_LPI		(24)
151 #define INT_EP_MAC_RESET_TIMEOUT	(23)
152 #define INT_EP_RDFO			(22)
153 #define INT_EP_TXE			(21)
154 #define INT_EP_USB_STATUS		(20)
155 #define INT_EP_TX_DIS			(19)
156 #define INT_EP_RX_DIS			(18)
157 #define INT_EP_PHY			(17)
158 #define INT_EP_DP			(16)
159 #define INT_EP_MAC_ERR			(15)
160 #define INT_EP_TDFU			(14)
161 #define INT_EP_TDFO			(13)
162 #define INT_EP_UTX			(12)
163 #define INT_EP_GPIO_11			(11)
164 #define INT_EP_GPIO_10			(10)
165 #define INT_EP_GPIO_9			(9)
166 #define INT_EP_GPIO_8			(8)
167 #define INT_EP_GPIO_7			(7)
168 #define INT_EP_GPIO_6			(6)
169 #define INT_EP_GPIO_5			(5)
170 #define INT_EP_GPIO_4			(4)
171 #define INT_EP_GPIO_3			(3)
172 #define INT_EP_GPIO_2			(2)
173 #define INT_EP_GPIO_1			(1)
174 #define INT_EP_GPIO_0			(0)
175 
176 static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {
177 	"RX FCS Errors",
178 	"RX Alignment Errors",
179 	"Rx Fragment Errors",
180 	"RX Jabber Errors",
181 	"RX Undersize Frame Errors",
182 	"RX Oversize Frame Errors",
183 	"RX Dropped Frames",
184 	"RX Unicast Byte Count",
185 	"RX Broadcast Byte Count",
186 	"RX Multicast Byte Count",
187 	"RX Unicast Frames",
188 	"RX Broadcast Frames",
189 	"RX Multicast Frames",
190 	"RX Pause Frames",
191 	"RX 64 Byte Frames",
192 	"RX 65 - 127 Byte Frames",
193 	"RX 128 - 255 Byte Frames",
194 	"RX 256 - 511 Bytes Frames",
195 	"RX 512 - 1023 Byte Frames",
196 	"RX 1024 - 1518 Byte Frames",
197 	"RX Greater 1518 Byte Frames",
198 	"EEE RX LPI Transitions",
199 	"EEE RX LPI Time",
200 	"TX FCS Errors",
201 	"TX Excess Deferral Errors",
202 	"TX Carrier Errors",
203 	"TX Bad Byte Count",
204 	"TX Single Collisions",
205 	"TX Multiple Collisions",
206 	"TX Excessive Collision",
207 	"TX Late Collisions",
208 	"TX Unicast Byte Count",
209 	"TX Broadcast Byte Count",
210 	"TX Multicast Byte Count",
211 	"TX Unicast Frames",
212 	"TX Broadcast Frames",
213 	"TX Multicast Frames",
214 	"TX Pause Frames",
215 	"TX 64 Byte Frames",
216 	"TX 65 - 127 Byte Frames",
217 	"TX 128 - 255 Byte Frames",
218 	"TX 256 - 511 Bytes Frames",
219 	"TX 512 - 1023 Byte Frames",
220 	"TX 1024 - 1518 Byte Frames",
221 	"TX Greater 1518 Byte Frames",
222 	"EEE TX LPI Transitions",
223 	"EEE TX LPI Time",
224 };
225 
226 struct lan78xx_statstage {
227 	u32 rx_fcs_errors;
228 	u32 rx_alignment_errors;
229 	u32 rx_fragment_errors;
230 	u32 rx_jabber_errors;
231 	u32 rx_undersize_frame_errors;
232 	u32 rx_oversize_frame_errors;
233 	u32 rx_dropped_frames;
234 	u32 rx_unicast_byte_count;
235 	u32 rx_broadcast_byte_count;
236 	u32 rx_multicast_byte_count;
237 	u32 rx_unicast_frames;
238 	u32 rx_broadcast_frames;
239 	u32 rx_multicast_frames;
240 	u32 rx_pause_frames;
241 	u32 rx_64_byte_frames;
242 	u32 rx_65_127_byte_frames;
243 	u32 rx_128_255_byte_frames;
244 	u32 rx_256_511_bytes_frames;
245 	u32 rx_512_1023_byte_frames;
246 	u32 rx_1024_1518_byte_frames;
247 	u32 rx_greater_1518_byte_frames;
248 	u32 eee_rx_lpi_transitions;
249 	u32 eee_rx_lpi_time;
250 	u32 tx_fcs_errors;
251 	u32 tx_excess_deferral_errors;
252 	u32 tx_carrier_errors;
253 	u32 tx_bad_byte_count;
254 	u32 tx_single_collisions;
255 	u32 tx_multiple_collisions;
256 	u32 tx_excessive_collision;
257 	u32 tx_late_collisions;
258 	u32 tx_unicast_byte_count;
259 	u32 tx_broadcast_byte_count;
260 	u32 tx_multicast_byte_count;
261 	u32 tx_unicast_frames;
262 	u32 tx_broadcast_frames;
263 	u32 tx_multicast_frames;
264 	u32 tx_pause_frames;
265 	u32 tx_64_byte_frames;
266 	u32 tx_65_127_byte_frames;
267 	u32 tx_128_255_byte_frames;
268 	u32 tx_256_511_bytes_frames;
269 	u32 tx_512_1023_byte_frames;
270 	u32 tx_1024_1518_byte_frames;
271 	u32 tx_greater_1518_byte_frames;
272 	u32 eee_tx_lpi_transitions;
273 	u32 eee_tx_lpi_time;
274 };
275 
276 struct lan78xx_statstage64 {
277 	u64 rx_fcs_errors;
278 	u64 rx_alignment_errors;
279 	u64 rx_fragment_errors;
280 	u64 rx_jabber_errors;
281 	u64 rx_undersize_frame_errors;
282 	u64 rx_oversize_frame_errors;
283 	u64 rx_dropped_frames;
284 	u64 rx_unicast_byte_count;
285 	u64 rx_broadcast_byte_count;
286 	u64 rx_multicast_byte_count;
287 	u64 rx_unicast_frames;
288 	u64 rx_broadcast_frames;
289 	u64 rx_multicast_frames;
290 	u64 rx_pause_frames;
291 	u64 rx_64_byte_frames;
292 	u64 rx_65_127_byte_frames;
293 	u64 rx_128_255_byte_frames;
294 	u64 rx_256_511_bytes_frames;
295 	u64 rx_512_1023_byte_frames;
296 	u64 rx_1024_1518_byte_frames;
297 	u64 rx_greater_1518_byte_frames;
298 	u64 eee_rx_lpi_transitions;
299 	u64 eee_rx_lpi_time;
300 	u64 tx_fcs_errors;
301 	u64 tx_excess_deferral_errors;
302 	u64 tx_carrier_errors;
303 	u64 tx_bad_byte_count;
304 	u64 tx_single_collisions;
305 	u64 tx_multiple_collisions;
306 	u64 tx_excessive_collision;
307 	u64 tx_late_collisions;
308 	u64 tx_unicast_byte_count;
309 	u64 tx_broadcast_byte_count;
310 	u64 tx_multicast_byte_count;
311 	u64 tx_unicast_frames;
312 	u64 tx_broadcast_frames;
313 	u64 tx_multicast_frames;
314 	u64 tx_pause_frames;
315 	u64 tx_64_byte_frames;
316 	u64 tx_65_127_byte_frames;
317 	u64 tx_128_255_byte_frames;
318 	u64 tx_256_511_bytes_frames;
319 	u64 tx_512_1023_byte_frames;
320 	u64 tx_1024_1518_byte_frames;
321 	u64 tx_greater_1518_byte_frames;
322 	u64 eee_tx_lpi_transitions;
323 	u64 eee_tx_lpi_time;
324 };
325 
326 static u32 lan78xx_regs[] = {
327 	ID_REV,
328 	INT_STS,
329 	HW_CFG,
330 	PMT_CTL,
331 	E2P_CMD,
332 	E2P_DATA,
333 	USB_STATUS,
334 	VLAN_TYPE,
335 	MAC_CR,
336 	MAC_RX,
337 	MAC_TX,
338 	FLOW,
339 	ERR_STS,
340 	MII_ACC,
341 	MII_DATA,
342 	EEE_TX_LPI_REQ_DLY,
343 	EEE_TW_TX_SYS,
344 	EEE_TX_LPI_REM_DLY,
345 	WUCSR
346 };
347 
348 #define PHY_REG_SIZE (32 * sizeof(u32))
349 
350 struct lan78xx_net;
351 
352 struct lan78xx_priv {
353 	struct lan78xx_net *dev;
354 	u32 rfe_ctl;
355 	u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicast hash table */
356 	u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */
357 	u32 vlan_table[DP_SEL_VHF_VLAN_LEN];
358 	struct mutex dataport_mutex; /* for dataport access */
359 	spinlock_t rfe_ctl_lock; /* for rfe register access */
360 	struct work_struct set_multicast;
361 	struct work_struct set_vlan;
362 	u32 wol;
363 };
364 
365 enum skb_state {
366 	illegal = 0,
367 	tx_start,
368 	tx_done,
369 	rx_start,
370 	rx_done,
371 	rx_cleanup,
372 	unlink_start
373 };
374 
375 struct skb_data {		/* skb->cb is one of these */
376 	struct urb *urb;
377 	struct lan78xx_net *dev;
378 	enum skb_state state;
379 	size_t length;
380 	int num_of_packet;
381 };
382 
383 #define EVENT_TX_HALT			0
384 #define EVENT_RX_HALT			1
385 #define EVENT_RX_MEMORY			2
386 #define EVENT_STS_SPLIT			3
387 #define EVENT_LINK_RESET		4
388 #define EVENT_RX_PAUSED			5
389 #define EVENT_DEV_WAKING		6
390 #define EVENT_DEV_ASLEEP		7
391 #define EVENT_DEV_OPEN			8
392 #define EVENT_STAT_UPDATE		9
393 #define EVENT_DEV_DISCONNECT		10
394 
395 struct statstage {
396 	struct mutex			access_lock;	/* for stats access */
397 	struct lan78xx_statstage	saved;
398 	struct lan78xx_statstage	rollover_count;
399 	struct lan78xx_statstage	rollover_max;
400 	struct lan78xx_statstage64	curr_stat;
401 };
402 
403 struct irq_domain_data {
404 	struct irq_domain	*irqdomain;
405 	unsigned int		phyirq;
406 	struct irq_chip		*irqchip;
407 	irq_flow_handler_t	irq_handler;
408 	u32			irqenable;
409 	struct mutex		irq_lock;		/* for irq bus access */
410 };
411 
412 struct lan78xx_net {
413 	struct net_device	*net;
414 	struct usb_device	*udev;
415 	struct usb_interface	*intf;
416 	void			*driver_priv;
417 
418 	unsigned int		tx_pend_data_len;
419 	size_t			n_tx_urbs;
420 	size_t			n_rx_urbs;
421 	size_t			tx_urb_size;
422 	size_t			rx_urb_size;
423 
424 	struct sk_buff_head	rxq_free;
425 	struct sk_buff_head	rxq;
426 	struct sk_buff_head	rxq_done;
427 	struct sk_buff_head	rxq_overflow;
428 	struct sk_buff_head	txq_free;
429 	struct sk_buff_head	txq;
430 	struct sk_buff_head	txq_pend;
431 
432 	struct napi_struct	napi;
433 
434 	struct delayed_work	wq;
435 
436 	int			msg_enable;
437 
438 	struct urb		*urb_intr;
439 	struct usb_anchor	deferred;
440 
441 	struct mutex		dev_mutex; /* serialise open/stop wrt suspend/resume */
442 	struct mutex		mdiobus_mutex; /* for MDIO bus access */
443 	unsigned int		pipe_in, pipe_out, pipe_intr;
444 
445 	unsigned int		bulk_in_delay;
446 	unsigned int		burst_cap;
447 
448 	unsigned long		flags;
449 
450 	wait_queue_head_t	*wait;
451 	unsigned char		suspend_count;
452 
453 	unsigned int		maxpacket;
454 	struct timer_list	stat_monitor;
455 
456 	unsigned long		data[5];
457 
458 	int			link_on;
459 	u8			mdix_ctrl;
460 
461 	u32			chipid;
462 	u32			chiprev;
463 	struct mii_bus		*mdiobus;
464 	phy_interface_t		interface;
465 
466 	int			fc_autoneg;
467 	u8			fc_request_control;
468 
469 	int			delta;
470 	struct statstage	stats;
471 
472 	struct irq_domain_data	domain_data;
473 };
474 
475 /* use ethtool to change the level for any given device */
476 static int msg_level = -1;
477 module_param(msg_level, int, 0);
478 MODULE_PARM_DESC(msg_level, "Override default message level");
479 
480 static struct sk_buff *lan78xx_get_buf(struct sk_buff_head *buf_pool)
481 {
482 	if (skb_queue_empty(buf_pool))
483 		return NULL;
484 
485 	return skb_dequeue(buf_pool);
486 }
487 
488 static void lan78xx_release_buf(struct sk_buff_head *buf_pool,
489 				struct sk_buff *buf)
490 {
491 	buf->data = buf->head;
492 	skb_reset_tail_pointer(buf);
493 
494 	buf->len = 0;
495 	buf->data_len = 0;
496 
497 	skb_queue_tail(buf_pool, buf);
498 }
499 
500 static void lan78xx_free_buf_pool(struct sk_buff_head *buf_pool)
501 {
502 	struct skb_data *entry;
503 	struct sk_buff *buf;
504 
505 	while (!skb_queue_empty(buf_pool)) {
506 		buf = skb_dequeue(buf_pool);
507 		if (buf) {
508 			entry = (struct skb_data *)buf->cb;
509 			usb_free_urb(entry->urb);
510 			dev_kfree_skb_any(buf);
511 		}
512 	}
513 }
514 
515 static int lan78xx_alloc_buf_pool(struct sk_buff_head *buf_pool,
516 				  size_t n_urbs, size_t urb_size,
517 				  struct lan78xx_net *dev)
518 {
519 	struct skb_data *entry;
520 	struct sk_buff *buf;
521 	struct urb *urb;
522 	int i;
523 
524 	skb_queue_head_init(buf_pool);
525 
526 	for (i = 0; i < n_urbs; i++) {
527 		buf = alloc_skb(urb_size, GFP_ATOMIC);
528 		if (!buf)
529 			goto error;
530 
531 		if (skb_linearize(buf) != 0) {
532 			dev_kfree_skb_any(buf);
533 			goto error;
534 		}
535 
536 		urb = usb_alloc_urb(0, GFP_ATOMIC);
537 		if (!urb) {
538 			dev_kfree_skb_any(buf);
539 			goto error;
540 		}
541 
542 		entry = (struct skb_data *)buf->cb;
543 		entry->urb = urb;
544 		entry->dev = dev;
545 		entry->length = 0;
546 		entry->num_of_packet = 0;
547 
548 		skb_queue_tail(buf_pool, buf);
549 	}
550 
551 	return 0;
552 
553 error:
554 	lan78xx_free_buf_pool(buf_pool);
555 
556 	return -ENOMEM;
557 }
558 
559 static struct sk_buff *lan78xx_get_rx_buf(struct lan78xx_net *dev)
560 {
561 	return lan78xx_get_buf(&dev->rxq_free);
562 }
563 
564 static void lan78xx_release_rx_buf(struct lan78xx_net *dev,
565 				   struct sk_buff *rx_buf)
566 {
567 	lan78xx_release_buf(&dev->rxq_free, rx_buf);
568 }
569 
570 static void lan78xx_free_rx_resources(struct lan78xx_net *dev)
571 {
572 	lan78xx_free_buf_pool(&dev->rxq_free);
573 }
574 
575 static int lan78xx_alloc_rx_resources(struct lan78xx_net *dev)
576 {
577 	return lan78xx_alloc_buf_pool(&dev->rxq_free,
578 				      dev->n_rx_urbs, dev->rx_urb_size, dev);
579 }
580 
581 static struct sk_buff *lan78xx_get_tx_buf(struct lan78xx_net *dev)
582 {
583 	return lan78xx_get_buf(&dev->txq_free);
584 }
585 
586 static void lan78xx_release_tx_buf(struct lan78xx_net *dev,
587 				   struct sk_buff *tx_buf)
588 {
589 	lan78xx_release_buf(&dev->txq_free, tx_buf);
590 }
591 
592 static void lan78xx_free_tx_resources(struct lan78xx_net *dev)
593 {
594 	lan78xx_free_buf_pool(&dev->txq_free);
595 }
596 
597 static int lan78xx_alloc_tx_resources(struct lan78xx_net *dev)
598 {
599 	return lan78xx_alloc_buf_pool(&dev->txq_free,
600 				      dev->n_tx_urbs, dev->tx_urb_size, dev);
601 }
602 
603 static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
604 {
605 	u32 *buf;
606 	int ret;
607 
608 	if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
609 		return -ENODEV;
610 
611 	buf = kmalloc(sizeof(u32), GFP_KERNEL);
612 	if (!buf)
613 		return -ENOMEM;
614 
615 	ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
616 			      USB_VENDOR_REQUEST_READ_REGISTER,
617 			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
618 			      0, index, buf, 4, USB_CTRL_GET_TIMEOUT);
619 	if (likely(ret >= 0)) {
620 		le32_to_cpus(buf);
621 		*data = *buf;
622 	} else if (net_ratelimit()) {
623 		netdev_warn(dev->net,
624 			    "Failed to read register index 0x%08x. ret = %pe",
625 			    index, ERR_PTR(ret));
626 	}
627 
628 	kfree(buf);
629 
630 	return ret;
631 }
632 
633 static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
634 {
635 	u32 *buf;
636 	int ret;
637 
638 	if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
639 		return -ENODEV;
640 
641 	buf = kmalloc(sizeof(u32), GFP_KERNEL);
642 	if (!buf)
643 		return -ENOMEM;
644 
645 	*buf = data;
646 	cpu_to_le32s(buf);
647 
648 	ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
649 			      USB_VENDOR_REQUEST_WRITE_REGISTER,
650 			      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
651 			      0, index, buf, 4, USB_CTRL_SET_TIMEOUT);
652 	if (unlikely(ret < 0) &&
653 	    net_ratelimit()) {
654 		netdev_warn(dev->net,
655 			    "Failed to write register index 0x%08x. ret = %pe",
656 			    index, ERR_PTR(ret));
657 	}
658 
659 	kfree(buf);
660 
661 	return ret;
662 }
663 
664 static int lan78xx_update_reg(struct lan78xx_net *dev, u32 reg, u32 mask,
665 			      u32 data)
666 {
667 	int ret;
668 	u32 buf;
669 
670 	ret = lan78xx_read_reg(dev, reg, &buf);
671 	if (ret < 0)
672 		return ret;
673 
674 	buf &= ~mask;
675 	buf |= (mask & data);
676 
677 	return lan78xx_write_reg(dev, reg, buf);
678 }
679 
680 static int lan78xx_read_stats(struct lan78xx_net *dev,
681 			      struct lan78xx_statstage *data)
682 {
683 	int ret = 0;
684 	int i;
685 	struct lan78xx_statstage *stats;
686 	u32 *src;
687 	u32 *dst;
688 
689 	stats = kmalloc(sizeof(*stats), GFP_KERNEL);
690 	if (!stats)
691 		return -ENOMEM;
692 
693 	ret = usb_control_msg(dev->udev,
694 			      usb_rcvctrlpipe(dev->udev, 0),
695 			      USB_VENDOR_REQUEST_GET_STATS,
696 			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
697 			      0,
698 			      0,
699 			      (void *)stats,
700 			      sizeof(*stats),
701 			      USB_CTRL_SET_TIMEOUT);
702 	if (likely(ret >= 0)) {
703 		src = (u32 *)stats;
704 		dst = (u32 *)data;
705 		for (i = 0; i < sizeof(*stats) / sizeof(u32); i++) {
706 			le32_to_cpus(&src[i]);
707 			dst[i] = src[i];
708 		}
709 	} else {
710 		netdev_warn(dev->net,
711 			    "Failed to read stat ret = %d", ret);
712 	}
713 
714 	kfree(stats);
715 
716 	return ret;
717 }
718 
719 #define check_counter_rollover(struct1, dev_stats, member)		\
720 	do {								\
721 		if ((struct1)->member < (dev_stats).saved.member)	\
722 			(dev_stats).rollover_count.member++;		\
723 	} while (0)
724 
725 static void lan78xx_check_stat_rollover(struct lan78xx_net *dev,
726 					struct lan78xx_statstage *stats)
727 {
728 	check_counter_rollover(stats, dev->stats, rx_fcs_errors);
729 	check_counter_rollover(stats, dev->stats, rx_alignment_errors);
730 	check_counter_rollover(stats, dev->stats, rx_fragment_errors);
731 	check_counter_rollover(stats, dev->stats, rx_jabber_errors);
732 	check_counter_rollover(stats, dev->stats, rx_undersize_frame_errors);
733 	check_counter_rollover(stats, dev->stats, rx_oversize_frame_errors);
734 	check_counter_rollover(stats, dev->stats, rx_dropped_frames);
735 	check_counter_rollover(stats, dev->stats, rx_unicast_byte_count);
736 	check_counter_rollover(stats, dev->stats, rx_broadcast_byte_count);
737 	check_counter_rollover(stats, dev->stats, rx_multicast_byte_count);
738 	check_counter_rollover(stats, dev->stats, rx_unicast_frames);
739 	check_counter_rollover(stats, dev->stats, rx_broadcast_frames);
740 	check_counter_rollover(stats, dev->stats, rx_multicast_frames);
741 	check_counter_rollover(stats, dev->stats, rx_pause_frames);
742 	check_counter_rollover(stats, dev->stats, rx_64_byte_frames);
743 	check_counter_rollover(stats, dev->stats, rx_65_127_byte_frames);
744 	check_counter_rollover(stats, dev->stats, rx_128_255_byte_frames);
745 	check_counter_rollover(stats, dev->stats, rx_256_511_bytes_frames);
746 	check_counter_rollover(stats, dev->stats, rx_512_1023_byte_frames);
747 	check_counter_rollover(stats, dev->stats, rx_1024_1518_byte_frames);
748 	check_counter_rollover(stats, dev->stats, rx_greater_1518_byte_frames);
749 	check_counter_rollover(stats, dev->stats, eee_rx_lpi_transitions);
750 	check_counter_rollover(stats, dev->stats, eee_rx_lpi_time);
751 	check_counter_rollover(stats, dev->stats, tx_fcs_errors);
752 	check_counter_rollover(stats, dev->stats, tx_excess_deferral_errors);
753 	check_counter_rollover(stats, dev->stats, tx_carrier_errors);
754 	check_counter_rollover(stats, dev->stats, tx_bad_byte_count);
755 	check_counter_rollover(stats, dev->stats, tx_single_collisions);
756 	check_counter_rollover(stats, dev->stats, tx_multiple_collisions);
757 	check_counter_rollover(stats, dev->stats, tx_excessive_collision);
758 	check_counter_rollover(stats, dev->stats, tx_late_collisions);
759 	check_counter_rollover(stats, dev->stats, tx_unicast_byte_count);
760 	check_counter_rollover(stats, dev->stats, tx_broadcast_byte_count);
761 	check_counter_rollover(stats, dev->stats, tx_multicast_byte_count);
762 	check_counter_rollover(stats, dev->stats, tx_unicast_frames);
763 	check_counter_rollover(stats, dev->stats, tx_broadcast_frames);
764 	check_counter_rollover(stats, dev->stats, tx_multicast_frames);
765 	check_counter_rollover(stats, dev->stats, tx_pause_frames);
766 	check_counter_rollover(stats, dev->stats, tx_64_byte_frames);
767 	check_counter_rollover(stats, dev->stats, tx_65_127_byte_frames);
768 	check_counter_rollover(stats, dev->stats, tx_128_255_byte_frames);
769 	check_counter_rollover(stats, dev->stats, tx_256_511_bytes_frames);
770 	check_counter_rollover(stats, dev->stats, tx_512_1023_byte_frames);
771 	check_counter_rollover(stats, dev->stats, tx_1024_1518_byte_frames);
772 	check_counter_rollover(stats, dev->stats, tx_greater_1518_byte_frames);
773 	check_counter_rollover(stats, dev->stats, eee_tx_lpi_transitions);
774 	check_counter_rollover(stats, dev->stats, eee_tx_lpi_time);
775 
776 	memcpy(&dev->stats.saved, stats, sizeof(struct lan78xx_statstage));
777 }
778 
779 static void lan78xx_update_stats(struct lan78xx_net *dev)
780 {
781 	u32 *p, *count, *max;
782 	u64 *data;
783 	int i;
784 	struct lan78xx_statstage lan78xx_stats;
785 
786 	if (usb_autopm_get_interface(dev->intf) < 0)
787 		return;
788 
789 	p = (u32 *)&lan78xx_stats;
790 	count = (u32 *)&dev->stats.rollover_count;
791 	max = (u32 *)&dev->stats.rollover_max;
792 	data = (u64 *)&dev->stats.curr_stat;
793 
794 	mutex_lock(&dev->stats.access_lock);
795 
796 	if (lan78xx_read_stats(dev, &lan78xx_stats) > 0)
797 		lan78xx_check_stat_rollover(dev, &lan78xx_stats);
798 
799 	for (i = 0; i < (sizeof(lan78xx_stats) / (sizeof(u32))); i++)
800 		data[i] = (u64)p[i] + ((u64)count[i] * ((u64)max[i] + 1));
801 
802 	mutex_unlock(&dev->stats.access_lock);
803 
804 	usb_autopm_put_interface(dev->intf);
805 }
806 
807 static int lan78xx_start_hw(struct lan78xx_net *dev, u32 reg, u32 hw_enable)
808 {
809 	return lan78xx_update_reg(dev, reg, hw_enable, hw_enable);
810 }
811 
812 static int lan78xx_stop_hw(struct lan78xx_net *dev, u32 reg, u32 hw_enabled,
813 			   u32 hw_disabled)
814 {
815 	unsigned long timeout;
816 	bool stopped = true;
817 	int ret;
818 	u32 buf;
819 
820 	/* Stop the h/w block (if not already stopped) */
821 
822 	ret = lan78xx_read_reg(dev, reg, &buf);
823 	if (ret < 0)
824 		return ret;
825 
826 	if (buf & hw_enabled) {
827 		buf &= ~hw_enabled;
828 
829 		ret = lan78xx_write_reg(dev, reg, buf);
830 		if (ret < 0)
831 			return ret;
832 
833 		stopped = false;
834 		timeout = jiffies + HW_DISABLE_TIMEOUT;
835 		do  {
836 			ret = lan78xx_read_reg(dev, reg, &buf);
837 			if (ret < 0)
838 				return ret;
839 
840 			if (buf & hw_disabled)
841 				stopped = true;
842 			else
843 				msleep(HW_DISABLE_DELAY_MS);
844 		} while (!stopped && !time_after(jiffies, timeout));
845 	}
846 
847 	return stopped ? 0 : -ETIMEDOUT;
848 }
849 
850 static int lan78xx_flush_fifo(struct lan78xx_net *dev, u32 reg, u32 fifo_flush)
851 {
852 	return lan78xx_update_reg(dev, reg, fifo_flush, fifo_flush);
853 }
854 
855 static int lan78xx_start_tx_path(struct lan78xx_net *dev)
856 {
857 	int ret;
858 
859 	netif_dbg(dev, drv, dev->net, "start tx path");
860 
861 	/* Start the MAC transmitter */
862 
863 	ret = lan78xx_start_hw(dev, MAC_TX, MAC_TX_TXEN_);
864 	if (ret < 0)
865 		return ret;
866 
867 	/* Start the Tx FIFO */
868 
869 	ret = lan78xx_start_hw(dev, FCT_TX_CTL, FCT_TX_CTL_EN_);
870 	if (ret < 0)
871 		return ret;
872 
873 	return 0;
874 }
875 
876 static int lan78xx_stop_tx_path(struct lan78xx_net *dev)
877 {
878 	int ret;
879 
880 	netif_dbg(dev, drv, dev->net, "stop tx path");
881 
882 	/* Stop the Tx FIFO */
883 
884 	ret = lan78xx_stop_hw(dev, FCT_TX_CTL, FCT_TX_CTL_EN_, FCT_TX_CTL_DIS_);
885 	if (ret < 0)
886 		return ret;
887 
888 	/* Stop the MAC transmitter */
889 
890 	ret = lan78xx_stop_hw(dev, MAC_TX, MAC_TX_TXEN_, MAC_TX_TXD_);
891 	if (ret < 0)
892 		return ret;
893 
894 	return 0;
895 }
896 
897 /* The caller must ensure the Tx path is stopped before calling
898  * lan78xx_flush_tx_fifo().
899  */
900 static int lan78xx_flush_tx_fifo(struct lan78xx_net *dev)
901 {
902 	return lan78xx_flush_fifo(dev, FCT_TX_CTL, FCT_TX_CTL_RST_);
903 }
904 
905 static int lan78xx_start_rx_path(struct lan78xx_net *dev)
906 {
907 	int ret;
908 
909 	netif_dbg(dev, drv, dev->net, "start rx path");
910 
911 	/* Start the Rx FIFO */
912 
913 	ret = lan78xx_start_hw(dev, FCT_RX_CTL, FCT_RX_CTL_EN_);
914 	if (ret < 0)
915 		return ret;
916 
917 	/* Start the MAC receiver*/
918 
919 	ret = lan78xx_start_hw(dev, MAC_RX, MAC_RX_RXEN_);
920 	if (ret < 0)
921 		return ret;
922 
923 	return 0;
924 }
925 
926 static int lan78xx_stop_rx_path(struct lan78xx_net *dev)
927 {
928 	int ret;
929 
930 	netif_dbg(dev, drv, dev->net, "stop rx path");
931 
932 	/* Stop the MAC receiver */
933 
934 	ret = lan78xx_stop_hw(dev, MAC_RX, MAC_RX_RXEN_, MAC_RX_RXD_);
935 	if (ret < 0)
936 		return ret;
937 
938 	/* Stop the Rx FIFO */
939 
940 	ret = lan78xx_stop_hw(dev, FCT_RX_CTL, FCT_RX_CTL_EN_, FCT_RX_CTL_DIS_);
941 	if (ret < 0)
942 		return ret;
943 
944 	return 0;
945 }
946 
947 /* The caller must ensure the Rx path is stopped before calling
948  * lan78xx_flush_rx_fifo().
949  */
950 static int lan78xx_flush_rx_fifo(struct lan78xx_net *dev)
951 {
952 	return lan78xx_flush_fifo(dev, FCT_RX_CTL, FCT_RX_CTL_RST_);
953 }
954 
955 /* Loop until the read is completed with timeout called with mdiobus_mutex held */
956 static int lan78xx_mdiobus_wait_not_busy(struct lan78xx_net *dev)
957 {
958 	unsigned long start_time = jiffies;
959 	u32 val;
960 	int ret;
961 
962 	do {
963 		ret = lan78xx_read_reg(dev, MII_ACC, &val);
964 		if (ret < 0)
965 			return ret;
966 
967 		if (!(val & MII_ACC_MII_BUSY_))
968 			return 0;
969 	} while (!time_after(jiffies, start_time + HZ));
970 
971 	return -ETIMEDOUT;
972 }
973 
974 static inline u32 mii_access(int id, int index, int read)
975 {
976 	u32 ret;
977 
978 	ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;
979 	ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;
980 	if (read)
981 		ret |= MII_ACC_MII_READ_;
982 	else
983 		ret |= MII_ACC_MII_WRITE_;
984 	ret |= MII_ACC_MII_BUSY_;
985 
986 	return ret;
987 }
988 
989 static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
990 {
991 	unsigned long start_time = jiffies;
992 	u32 val;
993 	int ret;
994 
995 	do {
996 		ret = lan78xx_read_reg(dev, E2P_CMD, &val);
997 		if (ret < 0)
998 			return ret;
999 
1000 		if (!(val & E2P_CMD_EPC_BUSY_) ||
1001 		    (val & E2P_CMD_EPC_TIMEOUT_))
1002 			break;
1003 		usleep_range(40, 100);
1004 	} while (!time_after(jiffies, start_time + HZ));
1005 
1006 	if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
1007 		netdev_warn(dev->net, "EEPROM read operation timeout");
1008 		return -ETIMEDOUT;
1009 	}
1010 
1011 	return 0;
1012 }
1013 
1014 static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
1015 {
1016 	unsigned long start_time = jiffies;
1017 	u32 val;
1018 	int ret;
1019 
1020 	do {
1021 		ret = lan78xx_read_reg(dev, E2P_CMD, &val);
1022 		if (ret < 0)
1023 			return ret;
1024 
1025 		if (!(val & E2P_CMD_EPC_BUSY_))
1026 			return 0;
1027 
1028 		usleep_range(40, 100);
1029 	} while (!time_after(jiffies, start_time + HZ));
1030 
1031 	netdev_warn(dev->net, "EEPROM is busy");
1032 	return -ETIMEDOUT;
1033 }
1034 
1035 static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
1036 				   u32 length, u8 *data)
1037 {
1038 	u32 val, saved;
1039 	int i, ret;
1040 
1041 	/* depends on chip, some EEPROM pins are muxed with LED function.
1042 	 * disable & restore LED function to access EEPROM.
1043 	 */
1044 	ret = lan78xx_read_reg(dev, HW_CFG, &val);
1045 	if (ret < 0)
1046 		return ret;
1047 
1048 	saved = val;
1049 	if (dev->chipid == ID_REV_CHIP_ID_7800_) {
1050 		val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
1051 		ret = lan78xx_write_reg(dev, HW_CFG, val);
1052 		if (ret < 0)
1053 			return ret;
1054 	}
1055 
1056 	ret = lan78xx_eeprom_confirm_not_busy(dev);
1057 	if (ret == -ETIMEDOUT)
1058 		goto read_raw_eeprom_done;
1059 	/* If USB fails, there is nothing to do */
1060 	if (ret < 0)
1061 		return ret;
1062 
1063 	for (i = 0; i < length; i++) {
1064 		val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
1065 		val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
1066 		ret = lan78xx_write_reg(dev, E2P_CMD, val);
1067 		if (ret < 0)
1068 			return ret;
1069 
1070 		ret = lan78xx_wait_eeprom(dev);
1071 		/* Looks like not USB specific error, try to recover */
1072 		if (ret == -ETIMEDOUT)
1073 			goto read_raw_eeprom_done;
1074 		/* If USB fails, there is nothing to do */
1075 		if (ret < 0)
1076 			return ret;
1077 
1078 		ret = lan78xx_read_reg(dev, E2P_DATA, &val);
1079 		if (ret < 0)
1080 			return ret;
1081 
1082 		data[i] = val & 0xFF;
1083 		offset++;
1084 	}
1085 
1086 read_raw_eeprom_done:
1087 	if (dev->chipid == ID_REV_CHIP_ID_7800_)
1088 		return lan78xx_write_reg(dev, HW_CFG, saved);
1089 
1090 	return 0;
1091 }
1092 
1093 static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
1094 			       u32 length, u8 *data)
1095 {
1096 	int ret;
1097 	u8 sig;
1098 
1099 	ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
1100 	if (ret < 0)
1101 		return ret;
1102 
1103 	if (sig != EEPROM_INDICATOR)
1104 		return -ENODATA;
1105 
1106 	return lan78xx_read_raw_eeprom(dev, offset, length, data);
1107 }
1108 
1109 static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
1110 				    u32 length, u8 *data)
1111 {
1112 	u32 val;
1113 	u32 saved;
1114 	int i, ret;
1115 
1116 	/* depends on chip, some EEPROM pins are muxed with LED function.
1117 	 * disable & restore LED function to access EEPROM.
1118 	 */
1119 	ret = lan78xx_read_reg(dev, HW_CFG, &val);
1120 	if (ret < 0)
1121 		return ret;
1122 
1123 	saved = val;
1124 	if (dev->chipid == ID_REV_CHIP_ID_7800_) {
1125 		val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
1126 		ret = lan78xx_write_reg(dev, HW_CFG, val);
1127 		if (ret < 0)
1128 			return ret;
1129 	}
1130 
1131 	ret = lan78xx_eeprom_confirm_not_busy(dev);
1132 	/* Looks like not USB specific error, try to recover */
1133 	if (ret == -ETIMEDOUT)
1134 		goto write_raw_eeprom_done;
1135 	/* If USB fails, there is nothing to do */
1136 	if (ret < 0)
1137 		return ret;
1138 
1139 	/* Issue write/erase enable command */
1140 	val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
1141 	ret = lan78xx_write_reg(dev, E2P_CMD, val);
1142 	if (ret < 0)
1143 		return ret;
1144 
1145 	ret = lan78xx_wait_eeprom(dev);
1146 	/* Looks like not USB specific error, try to recover */
1147 	if (ret == -ETIMEDOUT)
1148 		goto write_raw_eeprom_done;
1149 	/* If USB fails, there is nothing to do */
1150 	if (ret < 0)
1151 		return ret;
1152 
1153 	for (i = 0; i < length; i++) {
1154 		/* Fill data register */
1155 		val = data[i];
1156 		ret = lan78xx_write_reg(dev, E2P_DATA, val);
1157 		if (ret < 0)
1158 			return ret;
1159 
1160 		/* Send "write" command */
1161 		val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
1162 		val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
1163 		ret = lan78xx_write_reg(dev, E2P_CMD, val);
1164 		if (ret < 0)
1165 			return ret;
1166 
1167 		ret = lan78xx_wait_eeprom(dev);
1168 		/* Looks like not USB specific error, try to recover */
1169 		if (ret == -ETIMEDOUT)
1170 			goto write_raw_eeprom_done;
1171 		/* If USB fails, there is nothing to do */
1172 		if (ret < 0)
1173 			return ret;
1174 
1175 		offset++;
1176 	}
1177 
1178 write_raw_eeprom_done:
1179 	if (dev->chipid == ID_REV_CHIP_ID_7800_)
1180 		return lan78xx_write_reg(dev, HW_CFG, saved);
1181 
1182 	return 0;
1183 }
1184 
1185 static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
1186 				u32 length, u8 *data)
1187 {
1188 	unsigned long timeout;
1189 	int ret, i;
1190 	u32 buf;
1191 
1192 	ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1193 	if (ret < 0)
1194 		return ret;
1195 
1196 	if (buf & OTP_PWR_DN_PWRDN_N_) {
1197 		/* clear it and wait to be cleared */
1198 		ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
1199 		if (ret < 0)
1200 			return ret;
1201 
1202 		timeout = jiffies + HZ;
1203 		do {
1204 			usleep_range(1, 10);
1205 			ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1206 			if (ret < 0)
1207 				return ret;
1208 
1209 			if (time_after(jiffies, timeout)) {
1210 				netdev_warn(dev->net,
1211 					    "timeout on OTP_PWR_DN");
1212 				return -ETIMEDOUT;
1213 			}
1214 		} while (buf & OTP_PWR_DN_PWRDN_N_);
1215 	}
1216 
1217 	for (i = 0; i < length; i++) {
1218 		ret = lan78xx_write_reg(dev, OTP_ADDR1,
1219 					((offset + i) >> 8) & OTP_ADDR1_15_11);
1220 		if (ret < 0)
1221 			return ret;
1222 
1223 		ret = lan78xx_write_reg(dev, OTP_ADDR2,
1224 					((offset + i) & OTP_ADDR2_10_3));
1225 		if (ret < 0)
1226 			return ret;
1227 
1228 		ret = lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
1229 		if (ret < 0)
1230 			return ret;
1231 
1232 		ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
1233 		if (ret < 0)
1234 			return ret;
1235 
1236 		timeout = jiffies + HZ;
1237 		do {
1238 			udelay(1);
1239 			ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
1240 			if (ret < 0)
1241 				return ret;
1242 
1243 			if (time_after(jiffies, timeout)) {
1244 				netdev_warn(dev->net,
1245 					    "timeout on OTP_STATUS");
1246 				return -ETIMEDOUT;
1247 			}
1248 		} while (buf & OTP_STATUS_BUSY_);
1249 
1250 		ret = lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
1251 		if (ret < 0)
1252 			return ret;
1253 
1254 		data[i] = (u8)(buf & 0xFF);
1255 	}
1256 
1257 	return 0;
1258 }
1259 
1260 static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
1261 				 u32 length, u8 *data)
1262 {
1263 	int i;
1264 	u32 buf;
1265 	unsigned long timeout;
1266 	int ret;
1267 
1268 	ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1269 	if (ret < 0)
1270 		return ret;
1271 
1272 	if (buf & OTP_PWR_DN_PWRDN_N_) {
1273 		/* clear it and wait to be cleared */
1274 		ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
1275 		if (ret < 0)
1276 			return ret;
1277 
1278 		timeout = jiffies + HZ;
1279 		do {
1280 			udelay(1);
1281 			ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1282 			if (ret < 0)
1283 				return ret;
1284 
1285 			if (time_after(jiffies, timeout)) {
1286 				netdev_warn(dev->net,
1287 					    "timeout on OTP_PWR_DN completion");
1288 				return -ETIMEDOUT;
1289 			}
1290 		} while (buf & OTP_PWR_DN_PWRDN_N_);
1291 	}
1292 
1293 	/* set to BYTE program mode */
1294 	ret = lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
1295 	if (ret < 0)
1296 		return ret;
1297 
1298 	for (i = 0; i < length; i++) {
1299 		ret = lan78xx_write_reg(dev, OTP_ADDR1,
1300 					((offset + i) >> 8) & OTP_ADDR1_15_11);
1301 		if (ret < 0)
1302 			return ret;
1303 
1304 		ret = lan78xx_write_reg(dev, OTP_ADDR2,
1305 					((offset + i) & OTP_ADDR2_10_3));
1306 		if (ret < 0)
1307 			return ret;
1308 
1309 		ret = lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
1310 		if (ret < 0)
1311 			return ret;
1312 
1313 		ret = lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
1314 		if (ret < 0)
1315 			return ret;
1316 
1317 		ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
1318 		if (ret < 0)
1319 			return ret;
1320 
1321 		timeout = jiffies + HZ;
1322 		do {
1323 			udelay(1);
1324 			ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
1325 			if (ret < 0)
1326 				return ret;
1327 
1328 			if (time_after(jiffies, timeout)) {
1329 				netdev_warn(dev->net,
1330 					    "Timeout on OTP_STATUS completion");
1331 				return -ETIMEDOUT;
1332 			}
1333 		} while (buf & OTP_STATUS_BUSY_);
1334 	}
1335 
1336 	return 0;
1337 }
1338 
1339 static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
1340 			    u32 length, u8 *data)
1341 {
1342 	u8 sig;
1343 	int ret;
1344 
1345 	ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
1346 
1347 	if (ret == 0) {
1348 		if (sig == OTP_INDICATOR_2)
1349 			offset += 0x100;
1350 		else if (sig != OTP_INDICATOR_1)
1351 			ret = -EINVAL;
1352 		if (!ret)
1353 			ret = lan78xx_read_raw_otp(dev, offset, length, data);
1354 	}
1355 
1356 	return ret;
1357 }
1358 
1359 static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
1360 {
1361 	int i, ret;
1362 
1363 	for (i = 0; i < 100; i++) {
1364 		u32 dp_sel;
1365 
1366 		ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
1367 		if (unlikely(ret < 0))
1368 			return ret;
1369 
1370 		if (dp_sel & DP_SEL_DPRDY_)
1371 			return 0;
1372 
1373 		usleep_range(40, 100);
1374 	}
1375 
1376 	netdev_warn(dev->net, "%s timed out", __func__);
1377 
1378 	return -ETIMEDOUT;
1379 }
1380 
1381 static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
1382 				  u32 addr, u32 length, u32 *buf)
1383 {
1384 	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1385 	int i, ret;
1386 
1387 	ret = usb_autopm_get_interface(dev->intf);
1388 	if (ret < 0)
1389 		return ret;
1390 
1391 	mutex_lock(&pdata->dataport_mutex);
1392 
1393 	ret = lan78xx_dataport_wait_not_busy(dev);
1394 	if (ret < 0)
1395 		goto dataport_write;
1396 
1397 	ret = lan78xx_update_reg(dev, DP_SEL, DP_SEL_RSEL_MASK_, ram_select);
1398 	if (ret < 0)
1399 		goto dataport_write;
1400 
1401 	for (i = 0; i < length; i++) {
1402 		ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
1403 		if (ret < 0)
1404 			goto dataport_write;
1405 
1406 		ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
1407 		if (ret < 0)
1408 			goto dataport_write;
1409 
1410 		ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
1411 		if (ret < 0)
1412 			goto dataport_write;
1413 
1414 		ret = lan78xx_dataport_wait_not_busy(dev);
1415 		if (ret < 0)
1416 			goto dataport_write;
1417 	}
1418 
1419 dataport_write:
1420 	if (ret < 0)
1421 		netdev_warn(dev->net, "dataport write failed %pe", ERR_PTR(ret));
1422 
1423 	mutex_unlock(&pdata->dataport_mutex);
1424 	usb_autopm_put_interface(dev->intf);
1425 
1426 	return ret;
1427 }
1428 
1429 static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,
1430 				    int index, u8 addr[ETH_ALEN])
1431 {
1432 	u32 temp;
1433 
1434 	if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {
1435 		temp = addr[3];
1436 		temp = addr[2] | (temp << 8);
1437 		temp = addr[1] | (temp << 8);
1438 		temp = addr[0] | (temp << 8);
1439 		pdata->pfilter_table[index][1] = temp;
1440 		temp = addr[5];
1441 		temp = addr[4] | (temp << 8);
1442 		temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;
1443 		pdata->pfilter_table[index][0] = temp;
1444 	}
1445 }
1446 
1447 /* returns hash bit number for given MAC address */
1448 static inline u32 lan78xx_hash(char addr[ETH_ALEN])
1449 {
1450 	return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
1451 }
1452 
1453 static void lan78xx_deferred_multicast_write(struct work_struct *param)
1454 {
1455 	struct lan78xx_priv *pdata =
1456 			container_of(param, struct lan78xx_priv, set_multicast);
1457 	struct lan78xx_net *dev = pdata->dev;
1458 	int i, ret;
1459 
1460 	netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
1461 		  pdata->rfe_ctl);
1462 
1463 	ret = lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_,
1464 				     DP_SEL_VHF_VLAN_LEN,
1465 				     DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
1466 	if (ret < 0)
1467 		goto multicast_write_done;
1468 
1469 	for (i = 1; i < NUM_OF_MAF; i++) {
1470 		ret = lan78xx_write_reg(dev, MAF_HI(i), 0);
1471 		if (ret < 0)
1472 			goto multicast_write_done;
1473 
1474 		ret = lan78xx_write_reg(dev, MAF_LO(i),
1475 					pdata->pfilter_table[i][1]);
1476 		if (ret < 0)
1477 			goto multicast_write_done;
1478 
1479 		ret = lan78xx_write_reg(dev, MAF_HI(i),
1480 					pdata->pfilter_table[i][0]);
1481 		if (ret < 0)
1482 			goto multicast_write_done;
1483 	}
1484 
1485 	ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1486 
1487 multicast_write_done:
1488 	if (ret < 0)
1489 		netdev_warn(dev->net, "multicast write failed %pe", ERR_PTR(ret));
1490 	return;
1491 }
1492 
1493 static void lan78xx_set_multicast(struct net_device *netdev)
1494 {
1495 	struct lan78xx_net *dev = netdev_priv(netdev);
1496 	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1497 	unsigned long flags;
1498 	int i;
1499 
1500 	spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1501 
1502 	pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |
1503 			    RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
1504 
1505 	for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
1506 		pdata->mchash_table[i] = 0;
1507 
1508 	/* pfilter_table[0] has own HW address */
1509 	for (i = 1; i < NUM_OF_MAF; i++) {
1510 		pdata->pfilter_table[i][0] = 0;
1511 		pdata->pfilter_table[i][1] = 0;
1512 	}
1513 
1514 	pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;
1515 
1516 	if (dev->net->flags & IFF_PROMISC) {
1517 		netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
1518 		pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;
1519 	} else {
1520 		if (dev->net->flags & IFF_ALLMULTI) {
1521 			netif_dbg(dev, drv, dev->net,
1522 				  "receive all multicast enabled");
1523 			pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;
1524 		}
1525 	}
1526 
1527 	if (netdev_mc_count(dev->net)) {
1528 		struct netdev_hw_addr *ha;
1529 		int i;
1530 
1531 		netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
1532 
1533 		pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;
1534 
1535 		i = 1;
1536 		netdev_for_each_mc_addr(ha, netdev) {
1537 			/* set first 32 into Perfect Filter */
1538 			if (i < 33) {
1539 				lan78xx_set_addr_filter(pdata, i, ha->addr);
1540 			} else {
1541 				u32 bitnum = lan78xx_hash(ha->addr);
1542 
1543 				pdata->mchash_table[bitnum / 32] |=
1544 							(1 << (bitnum % 32));
1545 				pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;
1546 			}
1547 			i++;
1548 		}
1549 	}
1550 
1551 	spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1552 
1553 	/* defer register writes to a sleepable context */
1554 	schedule_work(&pdata->set_multicast);
1555 }
1556 
1557 static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1558 				      u16 lcladv, u16 rmtadv)
1559 {
1560 	u32 flow = 0, fct_flow = 0;
1561 	u8 cap;
1562 
1563 	if (dev->fc_autoneg)
1564 		cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1565 	else
1566 		cap = dev->fc_request_control;
1567 
1568 	if (cap & FLOW_CTRL_TX)
1569 		flow |= (FLOW_CR_TX_FCEN_ | 0xFFFF);
1570 
1571 	if (cap & FLOW_CTRL_RX)
1572 		flow |= FLOW_CR_RX_FCEN_;
1573 
1574 	if (dev->udev->speed == USB_SPEED_SUPER)
1575 		fct_flow = FLOW_CTRL_THRESHOLD(FLOW_ON_SS, FLOW_OFF_SS);
1576 	else if (dev->udev->speed == USB_SPEED_HIGH)
1577 		fct_flow = FLOW_CTRL_THRESHOLD(FLOW_ON_HS, FLOW_OFF_HS);
1578 
1579 	netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1580 		  (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
1581 		  (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
1582 
1583 	lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1584 
1585 	/* threshold value should be set before enabling flow */
1586 	lan78xx_write_reg(dev, FLOW, flow);
1587 
1588 	return 0;
1589 }
1590 
1591 static void lan78xx_rx_urb_submit_all(struct lan78xx_net *dev);
1592 
1593 static int lan78xx_mac_reset(struct lan78xx_net *dev)
1594 {
1595 	unsigned long start_time = jiffies;
1596 	u32 val;
1597 	int ret;
1598 
1599 	mutex_lock(&dev->mdiobus_mutex);
1600 
1601 	/* Resetting the device while there is activity on the MDIO
1602 	 * bus can result in the MAC interface locking up and not
1603 	 * completing register access transactions.
1604 	 */
1605 	ret = lan78xx_mdiobus_wait_not_busy(dev);
1606 	if (ret < 0)
1607 		goto exit_unlock;
1608 
1609 	ret = lan78xx_read_reg(dev, MAC_CR, &val);
1610 	if (ret < 0)
1611 		goto exit_unlock;
1612 
1613 	val |= MAC_CR_RST_;
1614 	ret = lan78xx_write_reg(dev, MAC_CR, val);
1615 	if (ret < 0)
1616 		goto exit_unlock;
1617 
1618 	/* Wait for the reset to complete before allowing any further
1619 	 * MAC register accesses otherwise the MAC may lock up.
1620 	 */
1621 	do {
1622 		ret = lan78xx_read_reg(dev, MAC_CR, &val);
1623 		if (ret < 0)
1624 			goto exit_unlock;
1625 
1626 		if (!(val & MAC_CR_RST_)) {
1627 			ret = 0;
1628 			goto exit_unlock;
1629 		}
1630 	} while (!time_after(jiffies, start_time + HZ));
1631 
1632 	ret = -ETIMEDOUT;
1633 exit_unlock:
1634 	mutex_unlock(&dev->mdiobus_mutex);
1635 
1636 	return ret;
1637 }
1638 
1639 static int lan78xx_link_reset(struct lan78xx_net *dev)
1640 {
1641 	struct phy_device *phydev = dev->net->phydev;
1642 	struct ethtool_link_ksettings ecmd;
1643 	int ladv, radv, ret, link;
1644 	u32 buf;
1645 
1646 	/* clear LAN78xx interrupt status */
1647 	ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1648 	if (unlikely(ret < 0))
1649 		return ret;
1650 
1651 	mutex_lock(&phydev->lock);
1652 	phy_read_status(phydev);
1653 	link = phydev->link;
1654 	mutex_unlock(&phydev->lock);
1655 
1656 	if (!link && dev->link_on) {
1657 		dev->link_on = false;
1658 
1659 		/* reset MAC */
1660 		ret = lan78xx_mac_reset(dev);
1661 		if (ret < 0)
1662 			return ret;
1663 
1664 		del_timer(&dev->stat_monitor);
1665 	} else if (link && !dev->link_on) {
1666 		dev->link_on = true;
1667 
1668 		phy_ethtool_ksettings_get(phydev, &ecmd);
1669 
1670 		if (dev->udev->speed == USB_SPEED_SUPER) {
1671 			if (ecmd.base.speed == 1000) {
1672 				/* disable U2 */
1673 				ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1674 				if (ret < 0)
1675 					return ret;
1676 				buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1677 				ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1678 				if (ret < 0)
1679 					return ret;
1680 				/* enable U1 */
1681 				ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1682 				if (ret < 0)
1683 					return ret;
1684 				buf |= USB_CFG1_DEV_U1_INIT_EN_;
1685 				ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1686 				if (ret < 0)
1687 					return ret;
1688 			} else {
1689 				/* enable U1 & U2 */
1690 				ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1691 				if (ret < 0)
1692 					return ret;
1693 				buf |= USB_CFG1_DEV_U2_INIT_EN_;
1694 				buf |= USB_CFG1_DEV_U1_INIT_EN_;
1695 				ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1696 				if (ret < 0)
1697 					return ret;
1698 			}
1699 		}
1700 
1701 		ladv = phy_read(phydev, MII_ADVERTISE);
1702 		if (ladv < 0)
1703 			return ladv;
1704 
1705 		radv = phy_read(phydev, MII_LPA);
1706 		if (radv < 0)
1707 			return radv;
1708 
1709 		netif_dbg(dev, link, dev->net,
1710 			  "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1711 			  ecmd.base.speed, ecmd.base.duplex, ladv, radv);
1712 
1713 		ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,
1714 						 radv);
1715 		if (ret < 0)
1716 			return ret;
1717 
1718 		if (!timer_pending(&dev->stat_monitor)) {
1719 			dev->delta = 1;
1720 			mod_timer(&dev->stat_monitor,
1721 				  jiffies + STAT_UPDATE_TIMER);
1722 		}
1723 
1724 		lan78xx_rx_urb_submit_all(dev);
1725 
1726 		local_bh_disable();
1727 		napi_schedule(&dev->napi);
1728 		local_bh_enable();
1729 	}
1730 
1731 	return 0;
1732 }
1733 
1734 /* some work can't be done in tasklets, so we use keventd
1735  *
1736  * NOTE:  annoying asymmetry:  if it's active, schedule_work() fails,
1737  * but tasklet_schedule() doesn't.	hope the failure is rare.
1738  */
1739 static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1740 {
1741 	set_bit(work, &dev->flags);
1742 	if (!schedule_delayed_work(&dev->wq, 0))
1743 		netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1744 }
1745 
1746 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1747 {
1748 	u32 intdata;
1749 
1750 	if (urb->actual_length != 4) {
1751 		netdev_warn(dev->net,
1752 			    "unexpected urb length %d", urb->actual_length);
1753 		return;
1754 	}
1755 
1756 	intdata = get_unaligned_le32(urb->transfer_buffer);
1757 
1758 	if (intdata & INT_ENP_PHY_INT) {
1759 		netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1760 		lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1761 
1762 		if (dev->domain_data.phyirq > 0)
1763 			generic_handle_irq_safe(dev->domain_data.phyirq);
1764 	} else {
1765 		netdev_warn(dev->net,
1766 			    "unexpected interrupt: 0x%08x\n", intdata);
1767 	}
1768 }
1769 
1770 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1771 {
1772 	return MAX_EEPROM_SIZE;
1773 }
1774 
1775 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1776 				      struct ethtool_eeprom *ee, u8 *data)
1777 {
1778 	struct lan78xx_net *dev = netdev_priv(netdev);
1779 	int ret;
1780 
1781 	ret = usb_autopm_get_interface(dev->intf);
1782 	if (ret)
1783 		return ret;
1784 
1785 	ee->magic = LAN78XX_EEPROM_MAGIC;
1786 
1787 	ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1788 
1789 	usb_autopm_put_interface(dev->intf);
1790 
1791 	return ret;
1792 }
1793 
1794 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1795 				      struct ethtool_eeprom *ee, u8 *data)
1796 {
1797 	struct lan78xx_net *dev = netdev_priv(netdev);
1798 	int ret;
1799 
1800 	ret = usb_autopm_get_interface(dev->intf);
1801 	if (ret)
1802 		return ret;
1803 
1804 	/* Invalid EEPROM_INDICATOR at offset zero will result in a failure
1805 	 * to load data from EEPROM
1806 	 */
1807 	if (ee->magic == LAN78XX_EEPROM_MAGIC)
1808 		ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1809 	else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1810 		 (ee->offset == 0) &&
1811 		 (ee->len == 512) &&
1812 		 (data[0] == OTP_INDICATOR_1))
1813 		ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1814 
1815 	usb_autopm_put_interface(dev->intf);
1816 
1817 	return ret;
1818 }
1819 
1820 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1821 				u8 *data)
1822 {
1823 	if (stringset == ETH_SS_STATS)
1824 		memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1825 }
1826 
1827 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1828 {
1829 	if (sset == ETH_SS_STATS)
1830 		return ARRAY_SIZE(lan78xx_gstrings);
1831 	else
1832 		return -EOPNOTSUPP;
1833 }
1834 
1835 static void lan78xx_get_stats(struct net_device *netdev,
1836 			      struct ethtool_stats *stats, u64 *data)
1837 {
1838 	struct lan78xx_net *dev = netdev_priv(netdev);
1839 
1840 	lan78xx_update_stats(dev);
1841 
1842 	mutex_lock(&dev->stats.access_lock);
1843 	memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1844 	mutex_unlock(&dev->stats.access_lock);
1845 }
1846 
1847 static void lan78xx_get_wol(struct net_device *netdev,
1848 			    struct ethtool_wolinfo *wol)
1849 {
1850 	struct lan78xx_net *dev = netdev_priv(netdev);
1851 	int ret;
1852 	u32 buf;
1853 	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1854 
1855 	if (usb_autopm_get_interface(dev->intf) < 0)
1856 		return;
1857 
1858 	ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1859 	if (unlikely(ret < 0)) {
1860 		netdev_warn(dev->net, "failed to get WoL %pe", ERR_PTR(ret));
1861 		wol->supported = 0;
1862 		wol->wolopts = 0;
1863 	} else {
1864 		if (buf & USB_CFG_RMT_WKP_) {
1865 			wol->supported = WAKE_ALL;
1866 			wol->wolopts = pdata->wol;
1867 		} else {
1868 			wol->supported = 0;
1869 			wol->wolopts = 0;
1870 		}
1871 	}
1872 
1873 	usb_autopm_put_interface(dev->intf);
1874 }
1875 
1876 static int lan78xx_set_wol(struct net_device *netdev,
1877 			   struct ethtool_wolinfo *wol)
1878 {
1879 	struct lan78xx_net *dev = netdev_priv(netdev);
1880 	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1881 	int ret;
1882 
1883 	if (wol->wolopts & ~WAKE_ALL)
1884 		return -EINVAL;
1885 
1886 	ret = usb_autopm_get_interface(dev->intf);
1887 	if (ret < 0)
1888 		return ret;
1889 
1890 	pdata->wol = wol->wolopts;
1891 
1892 	ret = device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1893 	if (ret < 0)
1894 		goto exit_pm_put;
1895 
1896 	ret = phy_ethtool_set_wol(netdev->phydev, wol);
1897 
1898 exit_pm_put:
1899 	usb_autopm_put_interface(dev->intf);
1900 
1901 	return ret;
1902 }
1903 
1904 static int lan78xx_get_eee(struct net_device *net, struct ethtool_keee *edata)
1905 {
1906 	struct lan78xx_net *dev = netdev_priv(net);
1907 	struct phy_device *phydev = net->phydev;
1908 	int ret;
1909 	u32 buf;
1910 
1911 	ret = usb_autopm_get_interface(dev->intf);
1912 	if (ret < 0)
1913 		return ret;
1914 
1915 	ret = phy_ethtool_get_eee(phydev, edata);
1916 	if (ret < 0)
1917 		goto exit;
1918 
1919 	ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1920 	if (buf & MAC_CR_EEE_EN_) {
1921 		/* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1922 		ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1923 		edata->tx_lpi_timer = buf;
1924 	} else {
1925 		edata->tx_lpi_timer = 0;
1926 	}
1927 
1928 	ret = 0;
1929 exit:
1930 	usb_autopm_put_interface(dev->intf);
1931 
1932 	return ret;
1933 }
1934 
1935 static int lan78xx_set_eee(struct net_device *net, struct ethtool_keee *edata)
1936 {
1937 	struct lan78xx_net *dev = netdev_priv(net);
1938 	int ret;
1939 	u32 buf;
1940 
1941 	ret = usb_autopm_get_interface(dev->intf);
1942 	if (ret < 0)
1943 		return ret;
1944 
1945 	ret = phy_ethtool_set_eee(net->phydev, edata);
1946 	if (ret < 0)
1947 		goto out;
1948 
1949 	buf = (u32)edata->tx_lpi_timer;
1950 	ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1951 out:
1952 	usb_autopm_put_interface(dev->intf);
1953 
1954 	return ret;
1955 }
1956 
1957 static u32 lan78xx_get_link(struct net_device *net)
1958 {
1959 	u32 link;
1960 
1961 	mutex_lock(&net->phydev->lock);
1962 	phy_read_status(net->phydev);
1963 	link = net->phydev->link;
1964 	mutex_unlock(&net->phydev->lock);
1965 
1966 	return link;
1967 }
1968 
1969 static void lan78xx_get_drvinfo(struct net_device *net,
1970 				struct ethtool_drvinfo *info)
1971 {
1972 	struct lan78xx_net *dev = netdev_priv(net);
1973 
1974 	strscpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1975 	usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1976 }
1977 
1978 static u32 lan78xx_get_msglevel(struct net_device *net)
1979 {
1980 	struct lan78xx_net *dev = netdev_priv(net);
1981 
1982 	return dev->msg_enable;
1983 }
1984 
1985 static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1986 {
1987 	struct lan78xx_net *dev = netdev_priv(net);
1988 
1989 	dev->msg_enable = level;
1990 }
1991 
1992 static int lan78xx_get_link_ksettings(struct net_device *net,
1993 				      struct ethtool_link_ksettings *cmd)
1994 {
1995 	struct lan78xx_net *dev = netdev_priv(net);
1996 	struct phy_device *phydev = net->phydev;
1997 	int ret;
1998 
1999 	ret = usb_autopm_get_interface(dev->intf);
2000 	if (ret < 0)
2001 		return ret;
2002 
2003 	phy_ethtool_ksettings_get(phydev, cmd);
2004 
2005 	usb_autopm_put_interface(dev->intf);
2006 
2007 	return ret;
2008 }
2009 
2010 static int lan78xx_set_link_ksettings(struct net_device *net,
2011 				      const struct ethtool_link_ksettings *cmd)
2012 {
2013 	struct lan78xx_net *dev = netdev_priv(net);
2014 	struct phy_device *phydev = net->phydev;
2015 	int ret = 0;
2016 	int temp;
2017 
2018 	ret = usb_autopm_get_interface(dev->intf);
2019 	if (ret < 0)
2020 		return ret;
2021 
2022 	/* change speed & duplex */
2023 	ret = phy_ethtool_ksettings_set(phydev, cmd);
2024 
2025 	if (!cmd->base.autoneg) {
2026 		/* force link down */
2027 		temp = phy_read(phydev, MII_BMCR);
2028 		phy_write(phydev, MII_BMCR, temp | BMCR_LOOPBACK);
2029 		mdelay(1);
2030 		phy_write(phydev, MII_BMCR, temp);
2031 	}
2032 
2033 	usb_autopm_put_interface(dev->intf);
2034 
2035 	return ret;
2036 }
2037 
2038 static void lan78xx_get_pause(struct net_device *net,
2039 			      struct ethtool_pauseparam *pause)
2040 {
2041 	struct lan78xx_net *dev = netdev_priv(net);
2042 	struct phy_device *phydev = net->phydev;
2043 	struct ethtool_link_ksettings ecmd;
2044 
2045 	phy_ethtool_ksettings_get(phydev, &ecmd);
2046 
2047 	pause->autoneg = dev->fc_autoneg;
2048 
2049 	if (dev->fc_request_control & FLOW_CTRL_TX)
2050 		pause->tx_pause = 1;
2051 
2052 	if (dev->fc_request_control & FLOW_CTRL_RX)
2053 		pause->rx_pause = 1;
2054 }
2055 
2056 static int lan78xx_set_pause(struct net_device *net,
2057 			     struct ethtool_pauseparam *pause)
2058 {
2059 	struct lan78xx_net *dev = netdev_priv(net);
2060 	struct phy_device *phydev = net->phydev;
2061 	struct ethtool_link_ksettings ecmd;
2062 	int ret;
2063 
2064 	phy_ethtool_ksettings_get(phydev, &ecmd);
2065 
2066 	if (pause->autoneg && !ecmd.base.autoneg) {
2067 		ret = -EINVAL;
2068 		goto exit;
2069 	}
2070 
2071 	dev->fc_request_control = 0;
2072 	if (pause->rx_pause)
2073 		dev->fc_request_control |= FLOW_CTRL_RX;
2074 
2075 	if (pause->tx_pause)
2076 		dev->fc_request_control |= FLOW_CTRL_TX;
2077 
2078 	if (ecmd.base.autoneg) {
2079 		__ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
2080 		u32 mii_adv;
2081 
2082 		linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2083 				   ecmd.link_modes.advertising);
2084 		linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2085 				   ecmd.link_modes.advertising);
2086 		mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2087 		mii_adv_to_linkmode_adv_t(fc, mii_adv);
2088 		linkmode_or(ecmd.link_modes.advertising, fc,
2089 			    ecmd.link_modes.advertising);
2090 
2091 		phy_ethtool_ksettings_set(phydev, &ecmd);
2092 	}
2093 
2094 	dev->fc_autoneg = pause->autoneg;
2095 
2096 	ret = 0;
2097 exit:
2098 	return ret;
2099 }
2100 
2101 static int lan78xx_get_regs_len(struct net_device *netdev)
2102 {
2103 	return sizeof(lan78xx_regs);
2104 }
2105 
2106 static void
2107 lan78xx_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
2108 		 void *buf)
2109 {
2110 	struct lan78xx_net *dev = netdev_priv(netdev);
2111 	unsigned int data_count = 0;
2112 	u32 *data = buf;
2113 	int i, ret;
2114 
2115 	/* Read Device/MAC registers */
2116 	for (i = 0; i < ARRAY_SIZE(lan78xx_regs); i++) {
2117 		ret = lan78xx_read_reg(dev, lan78xx_regs[i], &data[i]);
2118 		if (ret < 0) {
2119 			netdev_warn(dev->net,
2120 				    "failed to read register 0x%08x\n",
2121 				    lan78xx_regs[i]);
2122 			goto clean_data;
2123 		}
2124 
2125 		data_count++;
2126 	}
2127 
2128 	return;
2129 
2130 clean_data:
2131 	memset(data, 0, data_count * sizeof(u32));
2132 }
2133 
2134 static const struct ethtool_ops lan78xx_ethtool_ops = {
2135 	.get_link	= lan78xx_get_link,
2136 	.nway_reset	= phy_ethtool_nway_reset,
2137 	.get_drvinfo	= lan78xx_get_drvinfo,
2138 	.get_msglevel	= lan78xx_get_msglevel,
2139 	.set_msglevel	= lan78xx_set_msglevel,
2140 	.get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
2141 	.get_eeprom	= lan78xx_ethtool_get_eeprom,
2142 	.set_eeprom	= lan78xx_ethtool_set_eeprom,
2143 	.get_ethtool_stats = lan78xx_get_stats,
2144 	.get_sset_count = lan78xx_get_sset_count,
2145 	.get_strings	= lan78xx_get_strings,
2146 	.get_wol	= lan78xx_get_wol,
2147 	.set_wol	= lan78xx_set_wol,
2148 	.get_ts_info	= ethtool_op_get_ts_info,
2149 	.get_eee	= lan78xx_get_eee,
2150 	.set_eee	= lan78xx_set_eee,
2151 	.get_pauseparam	= lan78xx_get_pause,
2152 	.set_pauseparam	= lan78xx_set_pause,
2153 	.get_link_ksettings = lan78xx_get_link_ksettings,
2154 	.set_link_ksettings = lan78xx_set_link_ksettings,
2155 	.get_regs_len	= lan78xx_get_regs_len,
2156 	.get_regs	= lan78xx_get_regs,
2157 };
2158 
2159 static int lan78xx_init_mac_address(struct lan78xx_net *dev)
2160 {
2161 	u32 addr_lo, addr_hi;
2162 	u8 addr[6];
2163 	int ret;
2164 
2165 	ret = lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
2166 	if (ret < 0)
2167 		return ret;
2168 
2169 	ret = lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
2170 	if (ret < 0)
2171 		return ret;
2172 
2173 	addr[0] = addr_lo & 0xFF;
2174 	addr[1] = (addr_lo >> 8) & 0xFF;
2175 	addr[2] = (addr_lo >> 16) & 0xFF;
2176 	addr[3] = (addr_lo >> 24) & 0xFF;
2177 	addr[4] = addr_hi & 0xFF;
2178 	addr[5] = (addr_hi >> 8) & 0xFF;
2179 
2180 	if (!is_valid_ether_addr(addr)) {
2181 		if (!eth_platform_get_mac_address(&dev->udev->dev, addr)) {
2182 			/* valid address present in Device Tree */
2183 			netif_dbg(dev, ifup, dev->net,
2184 				  "MAC address read from Device Tree");
2185 		} else if (((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET,
2186 						 ETH_ALEN, addr) == 0) ||
2187 			    (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET,
2188 					      ETH_ALEN, addr) == 0)) &&
2189 			   is_valid_ether_addr(addr)) {
2190 			/* eeprom values are valid so use them */
2191 			netif_dbg(dev, ifup, dev->net,
2192 				  "MAC address read from EEPROM");
2193 		} else {
2194 			/* generate random MAC */
2195 			eth_random_addr(addr);
2196 			netif_dbg(dev, ifup, dev->net,
2197 				  "MAC address set to random addr");
2198 		}
2199 
2200 		addr_lo = addr[0] | (addr[1] << 8) |
2201 			  (addr[2] << 16) | (addr[3] << 24);
2202 		addr_hi = addr[4] | (addr[5] << 8);
2203 
2204 		ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2205 		if (ret < 0)
2206 			return ret;
2207 
2208 		ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2209 		if (ret < 0)
2210 			return ret;
2211 	}
2212 
2213 	ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2214 	if (ret < 0)
2215 		return ret;
2216 
2217 	ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2218 	if (ret < 0)
2219 		return ret;
2220 
2221 	eth_hw_addr_set(dev->net, addr);
2222 
2223 	return 0;
2224 }
2225 
2226 /* MDIO read and write wrappers for phylib */
2227 static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
2228 {
2229 	struct lan78xx_net *dev = bus->priv;
2230 	u32 val, addr;
2231 	int ret;
2232 
2233 	ret = usb_autopm_get_interface(dev->intf);
2234 	if (ret < 0)
2235 		return ret;
2236 
2237 	mutex_lock(&dev->mdiobus_mutex);
2238 
2239 	/* confirm MII not busy */
2240 	ret = lan78xx_mdiobus_wait_not_busy(dev);
2241 	if (ret < 0)
2242 		goto done;
2243 
2244 	/* set the address, index & direction (read from PHY) */
2245 	addr = mii_access(phy_id, idx, MII_READ);
2246 	ret = lan78xx_write_reg(dev, MII_ACC, addr);
2247 	if (ret < 0)
2248 		goto done;
2249 
2250 	ret = lan78xx_mdiobus_wait_not_busy(dev);
2251 	if (ret < 0)
2252 		goto done;
2253 
2254 	ret = lan78xx_read_reg(dev, MII_DATA, &val);
2255 	if (ret < 0)
2256 		goto done;
2257 
2258 	ret = (int)(val & 0xFFFF);
2259 
2260 done:
2261 	mutex_unlock(&dev->mdiobus_mutex);
2262 	usb_autopm_put_interface(dev->intf);
2263 
2264 	return ret;
2265 }
2266 
2267 static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
2268 				 u16 regval)
2269 {
2270 	struct lan78xx_net *dev = bus->priv;
2271 	u32 val, addr;
2272 	int ret;
2273 
2274 	ret = usb_autopm_get_interface(dev->intf);
2275 	if (ret < 0)
2276 		return ret;
2277 
2278 	mutex_lock(&dev->mdiobus_mutex);
2279 
2280 	/* confirm MII not busy */
2281 	ret = lan78xx_mdiobus_wait_not_busy(dev);
2282 	if (ret < 0)
2283 		goto done;
2284 
2285 	val = (u32)regval;
2286 	ret = lan78xx_write_reg(dev, MII_DATA, val);
2287 	if (ret < 0)
2288 		goto done;
2289 
2290 	/* set the address, index & direction (write to PHY) */
2291 	addr = mii_access(phy_id, idx, MII_WRITE);
2292 	ret = lan78xx_write_reg(dev, MII_ACC, addr);
2293 	if (ret < 0)
2294 		goto done;
2295 
2296 	ret = lan78xx_mdiobus_wait_not_busy(dev);
2297 	if (ret < 0)
2298 		goto done;
2299 
2300 done:
2301 	mutex_unlock(&dev->mdiobus_mutex);
2302 	usb_autopm_put_interface(dev->intf);
2303 	return ret;
2304 }
2305 
2306 static int lan78xx_mdio_init(struct lan78xx_net *dev)
2307 {
2308 	struct device_node *node;
2309 	int ret;
2310 
2311 	dev->mdiobus = mdiobus_alloc();
2312 	if (!dev->mdiobus) {
2313 		netdev_err(dev->net, "can't allocate MDIO bus\n");
2314 		return -ENOMEM;
2315 	}
2316 
2317 	dev->mdiobus->priv = (void *)dev;
2318 	dev->mdiobus->read = lan78xx_mdiobus_read;
2319 	dev->mdiobus->write = lan78xx_mdiobus_write;
2320 	dev->mdiobus->name = "lan78xx-mdiobus";
2321 	dev->mdiobus->parent = &dev->udev->dev;
2322 
2323 	snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
2324 		 dev->udev->bus->busnum, dev->udev->devnum);
2325 
2326 	switch (dev->chipid) {
2327 	case ID_REV_CHIP_ID_7800_:
2328 	case ID_REV_CHIP_ID_7850_:
2329 		/* set to internal PHY id */
2330 		dev->mdiobus->phy_mask = ~(1 << 1);
2331 		break;
2332 	case ID_REV_CHIP_ID_7801_:
2333 		/* scan thru PHYAD[2..0] */
2334 		dev->mdiobus->phy_mask = ~(0xFF);
2335 		break;
2336 	}
2337 
2338 	node = of_get_child_by_name(dev->udev->dev.of_node, "mdio");
2339 	ret = of_mdiobus_register(dev->mdiobus, node);
2340 	of_node_put(node);
2341 	if (ret) {
2342 		netdev_err(dev->net, "can't register MDIO bus\n");
2343 		goto exit1;
2344 	}
2345 
2346 	netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
2347 	return 0;
2348 exit1:
2349 	mdiobus_free(dev->mdiobus);
2350 	return ret;
2351 }
2352 
2353 static void lan78xx_remove_mdio(struct lan78xx_net *dev)
2354 {
2355 	mdiobus_unregister(dev->mdiobus);
2356 	mdiobus_free(dev->mdiobus);
2357 }
2358 
2359 static void lan78xx_link_status_change(struct net_device *net)
2360 {
2361 	struct lan78xx_net *dev = netdev_priv(net);
2362 	struct phy_device *phydev = net->phydev;
2363 	u32 data;
2364 	int ret;
2365 
2366 	ret = lan78xx_read_reg(dev, MAC_CR, &data);
2367 	if (ret < 0)
2368 		return;
2369 
2370 	if (phydev->enable_tx_lpi)
2371 		data |=  MAC_CR_EEE_EN_;
2372 	else
2373 		data &= ~MAC_CR_EEE_EN_;
2374 	lan78xx_write_reg(dev, MAC_CR, data);
2375 
2376 	phy_print_status(phydev);
2377 }
2378 
2379 static int irq_map(struct irq_domain *d, unsigned int irq,
2380 		   irq_hw_number_t hwirq)
2381 {
2382 	struct irq_domain_data *data = d->host_data;
2383 
2384 	irq_set_chip_data(irq, data);
2385 	irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);
2386 	irq_set_noprobe(irq);
2387 
2388 	return 0;
2389 }
2390 
2391 static void irq_unmap(struct irq_domain *d, unsigned int irq)
2392 {
2393 	irq_set_chip_and_handler(irq, NULL, NULL);
2394 	irq_set_chip_data(irq, NULL);
2395 }
2396 
2397 static const struct irq_domain_ops chip_domain_ops = {
2398 	.map	= irq_map,
2399 	.unmap	= irq_unmap,
2400 };
2401 
2402 static void lan78xx_irq_mask(struct irq_data *irqd)
2403 {
2404 	struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
2405 
2406 	data->irqenable &= ~BIT(irqd_to_hwirq(irqd));
2407 }
2408 
2409 static void lan78xx_irq_unmask(struct irq_data *irqd)
2410 {
2411 	struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
2412 
2413 	data->irqenable |= BIT(irqd_to_hwirq(irqd));
2414 }
2415 
2416 static void lan78xx_irq_bus_lock(struct irq_data *irqd)
2417 {
2418 	struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
2419 
2420 	mutex_lock(&data->irq_lock);
2421 }
2422 
2423 static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
2424 {
2425 	struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
2426 	struct lan78xx_net *dev =
2427 			container_of(data, struct lan78xx_net, domain_data);
2428 	u32 buf;
2429 	int ret;
2430 
2431 	/* call register access here because irq_bus_lock & irq_bus_sync_unlock
2432 	 * are only two callbacks executed in non-atomic contex.
2433 	 */
2434 	ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
2435 	if (ret < 0)
2436 		goto irq_bus_sync_unlock;
2437 
2438 	if (buf != data->irqenable)
2439 		ret = lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
2440 
2441 irq_bus_sync_unlock:
2442 	if (ret < 0)
2443 		netdev_err(dev->net, "Failed to sync IRQ enable register: %pe\n",
2444 			   ERR_PTR(ret));
2445 
2446 	mutex_unlock(&data->irq_lock);
2447 }
2448 
2449 static struct irq_chip lan78xx_irqchip = {
2450 	.name			= "lan78xx-irqs",
2451 	.irq_mask		= lan78xx_irq_mask,
2452 	.irq_unmask		= lan78xx_irq_unmask,
2453 	.irq_bus_lock		= lan78xx_irq_bus_lock,
2454 	.irq_bus_sync_unlock	= lan78xx_irq_bus_sync_unlock,
2455 };
2456 
2457 static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
2458 {
2459 	struct device_node *of_node;
2460 	struct irq_domain *irqdomain;
2461 	unsigned int irqmap = 0;
2462 	u32 buf;
2463 	int ret = 0;
2464 
2465 	of_node = dev->udev->dev.parent->of_node;
2466 
2467 	mutex_init(&dev->domain_data.irq_lock);
2468 
2469 	ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
2470 	if (ret < 0)
2471 		return ret;
2472 
2473 	dev->domain_data.irqenable = buf;
2474 
2475 	dev->domain_data.irqchip = &lan78xx_irqchip;
2476 	dev->domain_data.irq_handler = handle_simple_irq;
2477 
2478 	irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,
2479 					  &chip_domain_ops, &dev->domain_data);
2480 	if (irqdomain) {
2481 		/* create mapping for PHY interrupt */
2482 		irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);
2483 		if (!irqmap) {
2484 			irq_domain_remove(irqdomain);
2485 
2486 			irqdomain = NULL;
2487 			ret = -EINVAL;
2488 		}
2489 	} else {
2490 		ret = -EINVAL;
2491 	}
2492 
2493 	dev->domain_data.irqdomain = irqdomain;
2494 	dev->domain_data.phyirq = irqmap;
2495 
2496 	return ret;
2497 }
2498 
2499 static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
2500 {
2501 	if (dev->domain_data.phyirq > 0) {
2502 		irq_dispose_mapping(dev->domain_data.phyirq);
2503 
2504 		if (dev->domain_data.irqdomain)
2505 			irq_domain_remove(dev->domain_data.irqdomain);
2506 	}
2507 	dev->domain_data.phyirq = 0;
2508 	dev->domain_data.irqdomain = NULL;
2509 }
2510 
2511 static struct phy_device *lan7801_phy_init(struct lan78xx_net *dev)
2512 {
2513 	u32 buf;
2514 	int ret;
2515 	struct fixed_phy_status fphy_status = {
2516 		.link = 1,
2517 		.speed = SPEED_1000,
2518 		.duplex = DUPLEX_FULL,
2519 	};
2520 	struct phy_device *phydev;
2521 
2522 	phydev = phy_find_first(dev->mdiobus);
2523 	if (!phydev) {
2524 		netdev_dbg(dev->net, "PHY Not Found!! Registering Fixed PHY\n");
2525 		phydev = fixed_phy_register(PHY_POLL, &fphy_status, NULL);
2526 		if (IS_ERR(phydev)) {
2527 			netdev_err(dev->net, "No PHY/fixed_PHY found\n");
2528 			return NULL;
2529 		}
2530 		netdev_dbg(dev->net, "Registered FIXED PHY\n");
2531 		dev->interface = PHY_INTERFACE_MODE_RGMII;
2532 		ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
2533 					MAC_RGMII_ID_TXC_DELAY_EN_);
2534 		ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2535 		ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2536 		buf |= HW_CFG_CLK125_EN_;
2537 		buf |= HW_CFG_REFCLK25_EN_;
2538 		ret = lan78xx_write_reg(dev, HW_CFG, buf);
2539 	} else {
2540 		if (!phydev->drv) {
2541 			netdev_err(dev->net, "no PHY driver found\n");
2542 			return NULL;
2543 		}
2544 		dev->interface = PHY_INTERFACE_MODE_RGMII_ID;
2545 		/* The PHY driver is responsible to configure proper RGMII
2546 		 * interface delays. Disable RGMII delays on MAC side.
2547 		 */
2548 		lan78xx_write_reg(dev, MAC_RGMII_ID, 0);
2549 
2550 		phydev->is_internal = false;
2551 	}
2552 	return phydev;
2553 }
2554 
2555 static int lan78xx_phy_init(struct lan78xx_net *dev)
2556 {
2557 	__ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
2558 	int ret;
2559 	u32 mii_adv;
2560 	struct phy_device *phydev;
2561 
2562 	switch (dev->chipid) {
2563 	case ID_REV_CHIP_ID_7801_:
2564 		phydev = lan7801_phy_init(dev);
2565 		if (!phydev) {
2566 			netdev_err(dev->net, "lan7801: PHY Init Failed");
2567 			return -EIO;
2568 		}
2569 		break;
2570 
2571 	case ID_REV_CHIP_ID_7800_:
2572 	case ID_REV_CHIP_ID_7850_:
2573 		phydev = phy_find_first(dev->mdiobus);
2574 		if (!phydev) {
2575 			netdev_err(dev->net, "no PHY found\n");
2576 			return -EIO;
2577 		}
2578 		phydev->is_internal = true;
2579 		dev->interface = PHY_INTERFACE_MODE_GMII;
2580 		break;
2581 
2582 	default:
2583 		netdev_err(dev->net, "Unknown CHIP ID found\n");
2584 		return -EIO;
2585 	}
2586 
2587 	/* if phyirq is not set, use polling mode in phylib */
2588 	if (dev->domain_data.phyirq > 0)
2589 		phydev->irq = dev->domain_data.phyirq;
2590 	else
2591 		phydev->irq = PHY_POLL;
2592 	netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2593 
2594 	/* set to AUTOMDIX */
2595 	phydev->mdix = ETH_TP_MDI_AUTO;
2596 
2597 	ret = phy_connect_direct(dev->net, phydev,
2598 				 lan78xx_link_status_change,
2599 				 dev->interface);
2600 	if (ret) {
2601 		netdev_err(dev->net, "can't attach PHY to %s\n",
2602 			   dev->mdiobus->id);
2603 		if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2604 			if (phy_is_pseudo_fixed_link(phydev)) {
2605 				fixed_phy_unregister(phydev);
2606 				phy_device_free(phydev);
2607 			}
2608 		}
2609 		return -EIO;
2610 	}
2611 
2612 	/* MAC doesn't support 1000T Half */
2613 	phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
2614 
2615 	/* support both flow controls */
2616 	dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2617 	linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2618 			   phydev->advertising);
2619 	linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2620 			   phydev->advertising);
2621 	mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2622 	mii_adv_to_linkmode_adv_t(fc, mii_adv);
2623 	linkmode_or(phydev->advertising, fc, phydev->advertising);
2624 
2625 	phy_support_eee(phydev);
2626 
2627 	if (phydev->mdio.dev.of_node) {
2628 		u32 reg;
2629 		int len;
2630 
2631 		len = of_property_count_elems_of_size(phydev->mdio.dev.of_node,
2632 						      "microchip,led-modes",
2633 						      sizeof(u32));
2634 		if (len >= 0) {
2635 			/* Ensure the appropriate LEDs are enabled */
2636 			lan78xx_read_reg(dev, HW_CFG, &reg);
2637 			reg &= ~(HW_CFG_LED0_EN_ |
2638 				 HW_CFG_LED1_EN_ |
2639 				 HW_CFG_LED2_EN_ |
2640 				 HW_CFG_LED3_EN_);
2641 			reg |= (len > 0) * HW_CFG_LED0_EN_ |
2642 				(len > 1) * HW_CFG_LED1_EN_ |
2643 				(len > 2) * HW_CFG_LED2_EN_ |
2644 				(len > 3) * HW_CFG_LED3_EN_;
2645 			lan78xx_write_reg(dev, HW_CFG, reg);
2646 		}
2647 	}
2648 
2649 	genphy_config_aneg(phydev);
2650 
2651 	dev->fc_autoneg = phydev->autoneg;
2652 
2653 	return 0;
2654 }
2655 
2656 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2657 {
2658 	bool rxenabled;
2659 	u32 buf;
2660 	int ret;
2661 
2662 	ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2663 	if (ret < 0)
2664 		return ret;
2665 
2666 	rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2667 
2668 	if (rxenabled) {
2669 		buf &= ~MAC_RX_RXEN_;
2670 		ret = lan78xx_write_reg(dev, MAC_RX, buf);
2671 		if (ret < 0)
2672 			return ret;
2673 	}
2674 
2675 	/* add 4 to size for FCS */
2676 	buf &= ~MAC_RX_MAX_SIZE_MASK_;
2677 	buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2678 
2679 	ret = lan78xx_write_reg(dev, MAC_RX, buf);
2680 	if (ret < 0)
2681 		return ret;
2682 
2683 	if (rxenabled) {
2684 		buf |= MAC_RX_RXEN_;
2685 		ret = lan78xx_write_reg(dev, MAC_RX, buf);
2686 		if (ret < 0)
2687 			return ret;
2688 	}
2689 
2690 	return 0;
2691 }
2692 
2693 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2694 {
2695 	struct sk_buff *skb;
2696 	unsigned long flags;
2697 	int count = 0;
2698 
2699 	spin_lock_irqsave(&q->lock, flags);
2700 	while (!skb_queue_empty(q)) {
2701 		struct skb_data	*entry;
2702 		struct urb *urb;
2703 		int ret;
2704 
2705 		skb_queue_walk(q, skb) {
2706 			entry = (struct skb_data *)skb->cb;
2707 			if (entry->state != unlink_start)
2708 				goto found;
2709 		}
2710 		break;
2711 found:
2712 		entry->state = unlink_start;
2713 		urb = entry->urb;
2714 
2715 		/* Get reference count of the URB to avoid it to be
2716 		 * freed during usb_unlink_urb, which may trigger
2717 		 * use-after-free problem inside usb_unlink_urb since
2718 		 * usb_unlink_urb is always racing with .complete
2719 		 * handler(include defer_bh).
2720 		 */
2721 		usb_get_urb(urb);
2722 		spin_unlock_irqrestore(&q->lock, flags);
2723 		/* during some PM-driven resume scenarios,
2724 		 * these (async) unlinks complete immediately
2725 		 */
2726 		ret = usb_unlink_urb(urb);
2727 		if (ret != -EINPROGRESS && ret != 0)
2728 			netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2729 		else
2730 			count++;
2731 		usb_put_urb(urb);
2732 		spin_lock_irqsave(&q->lock, flags);
2733 	}
2734 	spin_unlock_irqrestore(&q->lock, flags);
2735 	return count;
2736 }
2737 
2738 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2739 {
2740 	struct lan78xx_net *dev = netdev_priv(netdev);
2741 	int max_frame_len = RX_MAX_FRAME_LEN(new_mtu);
2742 	int ret;
2743 
2744 	/* no second zero-length packet read wanted after mtu-sized packets */
2745 	if ((max_frame_len % dev->maxpacket) == 0)
2746 		return -EDOM;
2747 
2748 	ret = usb_autopm_get_interface(dev->intf);
2749 	if (ret < 0)
2750 		return ret;
2751 
2752 	ret = lan78xx_set_rx_max_frame_length(dev, max_frame_len);
2753 	if (ret < 0)
2754 		netdev_err(dev->net, "MTU changed to %d from %d failed with %pe\n",
2755 			   new_mtu, netdev->mtu, ERR_PTR(ret));
2756 	else
2757 		WRITE_ONCE(netdev->mtu, new_mtu);
2758 
2759 	usb_autopm_put_interface(dev->intf);
2760 
2761 	return ret;
2762 }
2763 
2764 static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2765 {
2766 	struct lan78xx_net *dev = netdev_priv(netdev);
2767 	struct sockaddr *addr = p;
2768 	u32 addr_lo, addr_hi;
2769 	int ret;
2770 
2771 	if (netif_running(netdev))
2772 		return -EBUSY;
2773 
2774 	if (!is_valid_ether_addr(addr->sa_data))
2775 		return -EADDRNOTAVAIL;
2776 
2777 	eth_hw_addr_set(netdev, addr->sa_data);
2778 
2779 	addr_lo = netdev->dev_addr[0] |
2780 		  netdev->dev_addr[1] << 8 |
2781 		  netdev->dev_addr[2] << 16 |
2782 		  netdev->dev_addr[3] << 24;
2783 	addr_hi = netdev->dev_addr[4] |
2784 		  netdev->dev_addr[5] << 8;
2785 
2786 	ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2787 	if (ret < 0)
2788 		return ret;
2789 
2790 	ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2791 	if (ret < 0)
2792 		return ret;
2793 
2794 	/* Added to support MAC address changes */
2795 	ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2796 	if (ret < 0)
2797 		return ret;
2798 
2799 	return lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2800 }
2801 
2802 /* Enable or disable Rx checksum offload engine */
2803 static int lan78xx_set_features(struct net_device *netdev,
2804 				netdev_features_t features)
2805 {
2806 	struct lan78xx_net *dev = netdev_priv(netdev);
2807 	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2808 	unsigned long flags;
2809 
2810 	spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2811 
2812 	if (features & NETIF_F_RXCSUM) {
2813 		pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
2814 		pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
2815 	} else {
2816 		pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2817 		pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2818 	}
2819 
2820 	if (features & NETIF_F_HW_VLAN_CTAG_RX)
2821 		pdata->rfe_ctl |= RFE_CTL_VLAN_STRIP_;
2822 	else
2823 		pdata->rfe_ctl &= ~RFE_CTL_VLAN_STRIP_;
2824 
2825 	if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
2826 		pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2827 	else
2828 		pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2829 
2830 	spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2831 
2832 	return lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2833 }
2834 
2835 static void lan78xx_deferred_vlan_write(struct work_struct *param)
2836 {
2837 	struct lan78xx_priv *pdata =
2838 			container_of(param, struct lan78xx_priv, set_vlan);
2839 	struct lan78xx_net *dev = pdata->dev;
2840 
2841 	lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2842 			       DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2843 }
2844 
2845 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2846 				   __be16 proto, u16 vid)
2847 {
2848 	struct lan78xx_net *dev = netdev_priv(netdev);
2849 	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2850 	u16 vid_bit_index;
2851 	u16 vid_dword_index;
2852 
2853 	vid_dword_index = (vid >> 5) & 0x7F;
2854 	vid_bit_index = vid & 0x1F;
2855 
2856 	pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2857 
2858 	/* defer register writes to a sleepable context */
2859 	schedule_work(&pdata->set_vlan);
2860 
2861 	return 0;
2862 }
2863 
2864 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2865 				    __be16 proto, u16 vid)
2866 {
2867 	struct lan78xx_net *dev = netdev_priv(netdev);
2868 	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2869 	u16 vid_bit_index;
2870 	u16 vid_dword_index;
2871 
2872 	vid_dword_index = (vid >> 5) & 0x7F;
2873 	vid_bit_index = vid & 0x1F;
2874 
2875 	pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2876 
2877 	/* defer register writes to a sleepable context */
2878 	schedule_work(&pdata->set_vlan);
2879 
2880 	return 0;
2881 }
2882 
2883 static int lan78xx_init_ltm(struct lan78xx_net *dev)
2884 {
2885 	u32 regs[6] = { 0 };
2886 	int ret;
2887 	u32 buf;
2888 
2889 	ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2890 	if (ret < 0)
2891 		goto init_ltm_failed;
2892 
2893 	if (buf & USB_CFG1_LTM_ENABLE_) {
2894 		u8 temp[2];
2895 		/* Get values from EEPROM first */
2896 		if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2897 			if (temp[0] == 24) {
2898 				ret = lan78xx_read_raw_eeprom(dev,
2899 							      temp[1] * 2,
2900 							      24,
2901 							      (u8 *)regs);
2902 				if (ret < 0)
2903 					return ret;
2904 			}
2905 		} else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2906 			if (temp[0] == 24) {
2907 				ret = lan78xx_read_raw_otp(dev,
2908 							   temp[1] * 2,
2909 							   24,
2910 							   (u8 *)regs);
2911 				if (ret < 0)
2912 					return ret;
2913 			}
2914 		}
2915 	}
2916 
2917 	ret = lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2918 	if (ret < 0)
2919 		goto init_ltm_failed;
2920 
2921 	ret = lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2922 	if (ret < 0)
2923 		goto init_ltm_failed;
2924 
2925 	ret = lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2926 	if (ret < 0)
2927 		goto init_ltm_failed;
2928 
2929 	ret = lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2930 	if (ret < 0)
2931 		goto init_ltm_failed;
2932 
2933 	ret = lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2934 	if (ret < 0)
2935 		goto init_ltm_failed;
2936 
2937 	ret = lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2938 	if (ret < 0)
2939 		goto init_ltm_failed;
2940 
2941 	return 0;
2942 
2943 init_ltm_failed:
2944 	netdev_err(dev->net, "Failed to init LTM with error %pe\n", ERR_PTR(ret));
2945 	return ret;
2946 }
2947 
2948 static int lan78xx_urb_config_init(struct lan78xx_net *dev)
2949 {
2950 	int result = 0;
2951 
2952 	switch (dev->udev->speed) {
2953 	case USB_SPEED_SUPER:
2954 		dev->rx_urb_size = RX_SS_URB_SIZE;
2955 		dev->tx_urb_size = TX_SS_URB_SIZE;
2956 		dev->n_rx_urbs = RX_SS_URB_NUM;
2957 		dev->n_tx_urbs = TX_SS_URB_NUM;
2958 		dev->bulk_in_delay = SS_BULK_IN_DELAY;
2959 		dev->burst_cap = SS_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2960 		break;
2961 	case USB_SPEED_HIGH:
2962 		dev->rx_urb_size = RX_HS_URB_SIZE;
2963 		dev->tx_urb_size = TX_HS_URB_SIZE;
2964 		dev->n_rx_urbs = RX_HS_URB_NUM;
2965 		dev->n_tx_urbs = TX_HS_URB_NUM;
2966 		dev->bulk_in_delay = HS_BULK_IN_DELAY;
2967 		dev->burst_cap = HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2968 		break;
2969 	case USB_SPEED_FULL:
2970 		dev->rx_urb_size = RX_FS_URB_SIZE;
2971 		dev->tx_urb_size = TX_FS_URB_SIZE;
2972 		dev->n_rx_urbs = RX_FS_URB_NUM;
2973 		dev->n_tx_urbs = TX_FS_URB_NUM;
2974 		dev->bulk_in_delay = FS_BULK_IN_DELAY;
2975 		dev->burst_cap = FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2976 		break;
2977 	default:
2978 		netdev_warn(dev->net, "USB bus speed not supported\n");
2979 		result = -EIO;
2980 		break;
2981 	}
2982 
2983 	return result;
2984 }
2985 
2986 static int lan78xx_reset(struct lan78xx_net *dev)
2987 {
2988 	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2989 	unsigned long timeout;
2990 	int ret;
2991 	u32 buf;
2992 	u8 sig;
2993 
2994 	ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2995 	if (ret < 0)
2996 		return ret;
2997 
2998 	buf |= HW_CFG_LRST_;
2999 
3000 	ret = lan78xx_write_reg(dev, HW_CFG, buf);
3001 	if (ret < 0)
3002 		return ret;
3003 
3004 	timeout = jiffies + HZ;
3005 	do {
3006 		mdelay(1);
3007 		ret = lan78xx_read_reg(dev, HW_CFG, &buf);
3008 		if (ret < 0)
3009 			return ret;
3010 
3011 		if (time_after(jiffies, timeout)) {
3012 			netdev_warn(dev->net,
3013 				    "timeout on completion of LiteReset");
3014 			ret = -ETIMEDOUT;
3015 			return ret;
3016 		}
3017 	} while (buf & HW_CFG_LRST_);
3018 
3019 	ret = lan78xx_init_mac_address(dev);
3020 	if (ret < 0)
3021 		return ret;
3022 
3023 	/* save DEVID for later usage */
3024 	ret = lan78xx_read_reg(dev, ID_REV, &buf);
3025 	if (ret < 0)
3026 		return ret;
3027 
3028 	dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
3029 	dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
3030 
3031 	/* Respond to the IN token with a NAK */
3032 	ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
3033 	if (ret < 0)
3034 		return ret;
3035 
3036 	buf |= USB_CFG_BIR_;
3037 
3038 	ret = lan78xx_write_reg(dev, USB_CFG0, buf);
3039 	if (ret < 0)
3040 		return ret;
3041 
3042 	/* Init LTM */
3043 	ret = lan78xx_init_ltm(dev);
3044 	if (ret < 0)
3045 		return ret;
3046 
3047 	ret = lan78xx_write_reg(dev, BURST_CAP, dev->burst_cap);
3048 	if (ret < 0)
3049 		return ret;
3050 
3051 	ret = lan78xx_write_reg(dev, BULK_IN_DLY, dev->bulk_in_delay);
3052 	if (ret < 0)
3053 		return ret;
3054 
3055 	ret = lan78xx_read_reg(dev, HW_CFG, &buf);
3056 	if (ret < 0)
3057 		return ret;
3058 
3059 	buf |= HW_CFG_MEF_;
3060 	buf |= HW_CFG_CLK125_EN_;
3061 	buf |= HW_CFG_REFCLK25_EN_;
3062 
3063 	ret = lan78xx_write_reg(dev, HW_CFG, buf);
3064 	if (ret < 0)
3065 		return ret;
3066 
3067 	ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
3068 	if (ret < 0)
3069 		return ret;
3070 
3071 	buf |= USB_CFG_BCE_;
3072 
3073 	ret = lan78xx_write_reg(dev, USB_CFG0, buf);
3074 	if (ret < 0)
3075 		return ret;
3076 
3077 	/* set FIFO sizes */
3078 	buf = (MAX_RX_FIFO_SIZE - 512) / 512;
3079 
3080 	ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
3081 	if (ret < 0)
3082 		return ret;
3083 
3084 	buf = (MAX_TX_FIFO_SIZE - 512) / 512;
3085 
3086 	ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
3087 	if (ret < 0)
3088 		return ret;
3089 
3090 	ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
3091 	if (ret < 0)
3092 		return ret;
3093 
3094 	ret = lan78xx_write_reg(dev, FLOW, 0);
3095 	if (ret < 0)
3096 		return ret;
3097 
3098 	ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
3099 	if (ret < 0)
3100 		return ret;
3101 
3102 	/* Don't need rfe_ctl_lock during initialisation */
3103 	ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
3104 	if (ret < 0)
3105 		return ret;
3106 
3107 	pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
3108 
3109 	ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
3110 	if (ret < 0)
3111 		return ret;
3112 
3113 	/* Enable or disable checksum offload engines */
3114 	ret = lan78xx_set_features(dev->net, dev->net->features);
3115 	if (ret < 0)
3116 		return ret;
3117 
3118 	lan78xx_set_multicast(dev->net);
3119 
3120 	/* reset PHY */
3121 	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3122 	if (ret < 0)
3123 		return ret;
3124 
3125 	buf |= PMT_CTL_PHY_RST_;
3126 
3127 	ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3128 	if (ret < 0)
3129 		return ret;
3130 
3131 	timeout = jiffies + HZ;
3132 	do {
3133 		mdelay(1);
3134 		ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3135 		if (ret < 0)
3136 			return ret;
3137 
3138 		if (time_after(jiffies, timeout)) {
3139 			netdev_warn(dev->net, "timeout waiting for PHY Reset");
3140 			ret = -ETIMEDOUT;
3141 			return ret;
3142 		}
3143 	} while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
3144 
3145 	ret = lan78xx_read_reg(dev, MAC_CR, &buf);
3146 	if (ret < 0)
3147 		return ret;
3148 
3149 	/* LAN7801 only has RGMII mode */
3150 	if (dev->chipid == ID_REV_CHIP_ID_7801_) {
3151 		buf &= ~MAC_CR_GMII_EN_;
3152 		/* Enable Auto Duplex and Auto speed */
3153 		buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
3154 	}
3155 
3156 	if (dev->chipid == ID_REV_CHIP_ID_7800_ ||
3157 	    dev->chipid == ID_REV_CHIP_ID_7850_) {
3158 		ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
3159 		if (!ret && sig != EEPROM_INDICATOR) {
3160 			/* Implies there is no external eeprom. Set mac speed */
3161 			netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");
3162 			buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
3163 		}
3164 	}
3165 	ret = lan78xx_write_reg(dev, MAC_CR, buf);
3166 	if (ret < 0)
3167 		return ret;
3168 
3169 	ret = lan78xx_set_rx_max_frame_length(dev,
3170 					      RX_MAX_FRAME_LEN(dev->net->mtu));
3171 
3172 	return ret;
3173 }
3174 
3175 static void lan78xx_init_stats(struct lan78xx_net *dev)
3176 {
3177 	u32 *p;
3178 	int i;
3179 
3180 	/* initialize for stats update
3181 	 * some counters are 20bits and some are 32bits
3182 	 */
3183 	p = (u32 *)&dev->stats.rollover_max;
3184 	for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
3185 		p[i] = 0xFFFFF;
3186 
3187 	dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
3188 	dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
3189 	dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
3190 	dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
3191 	dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
3192 	dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
3193 	dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
3194 	dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
3195 	dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
3196 	dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
3197 
3198 	set_bit(EVENT_STAT_UPDATE, &dev->flags);
3199 }
3200 
3201 static int lan78xx_open(struct net_device *net)
3202 {
3203 	struct lan78xx_net *dev = netdev_priv(net);
3204 	int ret;
3205 
3206 	netif_dbg(dev, ifup, dev->net, "open device");
3207 
3208 	ret = usb_autopm_get_interface(dev->intf);
3209 	if (ret < 0)
3210 		return ret;
3211 
3212 	mutex_lock(&dev->dev_mutex);
3213 
3214 	phy_start(net->phydev);
3215 
3216 	netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
3217 
3218 	/* for Link Check */
3219 	if (dev->urb_intr) {
3220 		ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
3221 		if (ret < 0) {
3222 			netif_err(dev, ifup, dev->net,
3223 				  "intr submit %d\n", ret);
3224 			goto done;
3225 		}
3226 	}
3227 
3228 	ret = lan78xx_flush_rx_fifo(dev);
3229 	if (ret < 0)
3230 		goto done;
3231 	ret = lan78xx_flush_tx_fifo(dev);
3232 	if (ret < 0)
3233 		goto done;
3234 
3235 	ret = lan78xx_start_tx_path(dev);
3236 	if (ret < 0)
3237 		goto done;
3238 	ret = lan78xx_start_rx_path(dev);
3239 	if (ret < 0)
3240 		goto done;
3241 
3242 	lan78xx_init_stats(dev);
3243 
3244 	set_bit(EVENT_DEV_OPEN, &dev->flags);
3245 
3246 	netif_start_queue(net);
3247 
3248 	dev->link_on = false;
3249 
3250 	napi_enable(&dev->napi);
3251 
3252 	lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
3253 done:
3254 	mutex_unlock(&dev->dev_mutex);
3255 
3256 	if (ret < 0)
3257 		usb_autopm_put_interface(dev->intf);
3258 
3259 	return ret;
3260 }
3261 
3262 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
3263 {
3264 	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
3265 	DECLARE_WAITQUEUE(wait, current);
3266 	int temp;
3267 
3268 	/* ensure there are no more active urbs */
3269 	add_wait_queue(&unlink_wakeup, &wait);
3270 	set_current_state(TASK_UNINTERRUPTIBLE);
3271 	dev->wait = &unlink_wakeup;
3272 	temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
3273 
3274 	/* maybe wait for deletions to finish. */
3275 	while (!skb_queue_empty(&dev->rxq) ||
3276 	       !skb_queue_empty(&dev->txq)) {
3277 		schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
3278 		set_current_state(TASK_UNINTERRUPTIBLE);
3279 		netif_dbg(dev, ifdown, dev->net,
3280 			  "waited for %d urb completions", temp);
3281 	}
3282 	set_current_state(TASK_RUNNING);
3283 	dev->wait = NULL;
3284 	remove_wait_queue(&unlink_wakeup, &wait);
3285 
3286 	/* empty Rx done, Rx overflow and Tx pend queues
3287 	 */
3288 	while (!skb_queue_empty(&dev->rxq_done)) {
3289 		struct sk_buff *skb = skb_dequeue(&dev->rxq_done);
3290 
3291 		lan78xx_release_rx_buf(dev, skb);
3292 	}
3293 
3294 	skb_queue_purge(&dev->rxq_overflow);
3295 	skb_queue_purge(&dev->txq_pend);
3296 }
3297 
3298 static int lan78xx_stop(struct net_device *net)
3299 {
3300 	struct lan78xx_net *dev = netdev_priv(net);
3301 
3302 	netif_dbg(dev, ifup, dev->net, "stop device");
3303 
3304 	mutex_lock(&dev->dev_mutex);
3305 
3306 	if (timer_pending(&dev->stat_monitor))
3307 		del_timer_sync(&dev->stat_monitor);
3308 
3309 	clear_bit(EVENT_DEV_OPEN, &dev->flags);
3310 	netif_stop_queue(net);
3311 	napi_disable(&dev->napi);
3312 
3313 	lan78xx_terminate_urbs(dev);
3314 
3315 	netif_info(dev, ifdown, dev->net,
3316 		   "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
3317 		   net->stats.rx_packets, net->stats.tx_packets,
3318 		   net->stats.rx_errors, net->stats.tx_errors);
3319 
3320 	/* ignore errors that occur stopping the Tx and Rx data paths */
3321 	lan78xx_stop_tx_path(dev);
3322 	lan78xx_stop_rx_path(dev);
3323 
3324 	if (net->phydev)
3325 		phy_stop(net->phydev);
3326 
3327 	usb_kill_urb(dev->urb_intr);
3328 
3329 	/* deferred work (task, timer, softirq) must also stop.
3330 	 * can't flush_scheduled_work() until we drop rtnl (later),
3331 	 * else workers could deadlock; so make workers a NOP.
3332 	 */
3333 	clear_bit(EVENT_TX_HALT, &dev->flags);
3334 	clear_bit(EVENT_RX_HALT, &dev->flags);
3335 	clear_bit(EVENT_LINK_RESET, &dev->flags);
3336 	clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3337 
3338 	cancel_delayed_work_sync(&dev->wq);
3339 
3340 	usb_autopm_put_interface(dev->intf);
3341 
3342 	mutex_unlock(&dev->dev_mutex);
3343 
3344 	return 0;
3345 }
3346 
3347 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
3348 			       struct sk_buff_head *list, enum skb_state state)
3349 {
3350 	unsigned long flags;
3351 	enum skb_state old_state;
3352 	struct skb_data *entry = (struct skb_data *)skb->cb;
3353 
3354 	spin_lock_irqsave(&list->lock, flags);
3355 	old_state = entry->state;
3356 	entry->state = state;
3357 
3358 	__skb_unlink(skb, list);
3359 	spin_unlock(&list->lock);
3360 	spin_lock(&dev->rxq_done.lock);
3361 
3362 	__skb_queue_tail(&dev->rxq_done, skb);
3363 	if (skb_queue_len(&dev->rxq_done) == 1)
3364 		napi_schedule(&dev->napi);
3365 
3366 	spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
3367 
3368 	return old_state;
3369 }
3370 
3371 static void tx_complete(struct urb *urb)
3372 {
3373 	struct sk_buff *skb = (struct sk_buff *)urb->context;
3374 	struct skb_data *entry = (struct skb_data *)skb->cb;
3375 	struct lan78xx_net *dev = entry->dev;
3376 
3377 	if (urb->status == 0) {
3378 		dev->net->stats.tx_packets += entry->num_of_packet;
3379 		dev->net->stats.tx_bytes += entry->length;
3380 	} else {
3381 		dev->net->stats.tx_errors += entry->num_of_packet;
3382 
3383 		switch (urb->status) {
3384 		case -EPIPE:
3385 			lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3386 			break;
3387 
3388 		/* software-driven interface shutdown */
3389 		case -ECONNRESET:
3390 		case -ESHUTDOWN:
3391 			netif_dbg(dev, tx_err, dev->net,
3392 				  "tx err interface gone %d\n",
3393 				  entry->urb->status);
3394 			break;
3395 
3396 		case -EPROTO:
3397 		case -ETIME:
3398 		case -EILSEQ:
3399 			netif_stop_queue(dev->net);
3400 			netif_dbg(dev, tx_err, dev->net,
3401 				  "tx err queue stopped %d\n",
3402 				  entry->urb->status);
3403 			break;
3404 		default:
3405 			netif_dbg(dev, tx_err, dev->net,
3406 				  "unknown tx err %d\n",
3407 				  entry->urb->status);
3408 			break;
3409 		}
3410 	}
3411 
3412 	usb_autopm_put_interface_async(dev->intf);
3413 
3414 	skb_unlink(skb, &dev->txq);
3415 
3416 	lan78xx_release_tx_buf(dev, skb);
3417 
3418 	/* Re-schedule NAPI if Tx data pending but no URBs in progress.
3419 	 */
3420 	if (skb_queue_empty(&dev->txq) &&
3421 	    !skb_queue_empty(&dev->txq_pend))
3422 		napi_schedule(&dev->napi);
3423 }
3424 
3425 static void lan78xx_queue_skb(struct sk_buff_head *list,
3426 			      struct sk_buff *newsk, enum skb_state state)
3427 {
3428 	struct skb_data *entry = (struct skb_data *)newsk->cb;
3429 
3430 	__skb_queue_tail(list, newsk);
3431 	entry->state = state;
3432 }
3433 
3434 static unsigned int lan78xx_tx_urb_space(struct lan78xx_net *dev)
3435 {
3436 	return skb_queue_len(&dev->txq_free) * dev->tx_urb_size;
3437 }
3438 
3439 static unsigned int lan78xx_tx_pend_data_len(struct lan78xx_net *dev)
3440 {
3441 	return dev->tx_pend_data_len;
3442 }
3443 
3444 static void lan78xx_tx_pend_skb_add(struct lan78xx_net *dev,
3445 				    struct sk_buff *skb,
3446 				    unsigned int *tx_pend_data_len)
3447 {
3448 	unsigned long flags;
3449 
3450 	spin_lock_irqsave(&dev->txq_pend.lock, flags);
3451 
3452 	__skb_queue_tail(&dev->txq_pend, skb);
3453 
3454 	dev->tx_pend_data_len += skb->len;
3455 	*tx_pend_data_len = dev->tx_pend_data_len;
3456 
3457 	spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3458 }
3459 
3460 static void lan78xx_tx_pend_skb_head_add(struct lan78xx_net *dev,
3461 					 struct sk_buff *skb,
3462 					 unsigned int *tx_pend_data_len)
3463 {
3464 	unsigned long flags;
3465 
3466 	spin_lock_irqsave(&dev->txq_pend.lock, flags);
3467 
3468 	__skb_queue_head(&dev->txq_pend, skb);
3469 
3470 	dev->tx_pend_data_len += skb->len;
3471 	*tx_pend_data_len = dev->tx_pend_data_len;
3472 
3473 	spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3474 }
3475 
3476 static void lan78xx_tx_pend_skb_get(struct lan78xx_net *dev,
3477 				    struct sk_buff **skb,
3478 				    unsigned int *tx_pend_data_len)
3479 {
3480 	unsigned long flags;
3481 
3482 	spin_lock_irqsave(&dev->txq_pend.lock, flags);
3483 
3484 	*skb = __skb_dequeue(&dev->txq_pend);
3485 	if (*skb)
3486 		dev->tx_pend_data_len -= (*skb)->len;
3487 	*tx_pend_data_len = dev->tx_pend_data_len;
3488 
3489 	spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3490 }
3491 
3492 static netdev_tx_t
3493 lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
3494 {
3495 	struct lan78xx_net *dev = netdev_priv(net);
3496 	unsigned int tx_pend_data_len;
3497 
3498 	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags))
3499 		schedule_delayed_work(&dev->wq, 0);
3500 
3501 	skb_tx_timestamp(skb);
3502 
3503 	lan78xx_tx_pend_skb_add(dev, skb, &tx_pend_data_len);
3504 
3505 	/* Set up a Tx URB if none is in progress */
3506 
3507 	if (skb_queue_empty(&dev->txq))
3508 		napi_schedule(&dev->napi);
3509 
3510 	/* Stop stack Tx queue if we have enough data to fill
3511 	 * all the free Tx URBs.
3512 	 */
3513 	if (tx_pend_data_len > lan78xx_tx_urb_space(dev)) {
3514 		netif_stop_queue(net);
3515 
3516 		netif_dbg(dev, hw, dev->net, "tx data len: %u, urb space %u",
3517 			  tx_pend_data_len, lan78xx_tx_urb_space(dev));
3518 
3519 		/* Kick off transmission of pending data */
3520 
3521 		if (!skb_queue_empty(&dev->txq_free))
3522 			napi_schedule(&dev->napi);
3523 	}
3524 
3525 	return NETDEV_TX_OK;
3526 }
3527 
3528 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
3529 {
3530 	struct lan78xx_priv *pdata = NULL;
3531 	int ret;
3532 	int i;
3533 
3534 	dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
3535 
3536 	pdata = (struct lan78xx_priv *)(dev->data[0]);
3537 	if (!pdata) {
3538 		netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
3539 		return -ENOMEM;
3540 	}
3541 
3542 	pdata->dev = dev;
3543 
3544 	spin_lock_init(&pdata->rfe_ctl_lock);
3545 	mutex_init(&pdata->dataport_mutex);
3546 
3547 	INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
3548 
3549 	for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
3550 		pdata->vlan_table[i] = 0;
3551 
3552 	INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
3553 
3554 	dev->net->features = 0;
3555 
3556 	if (DEFAULT_TX_CSUM_ENABLE)
3557 		dev->net->features |= NETIF_F_HW_CSUM;
3558 
3559 	if (DEFAULT_RX_CSUM_ENABLE)
3560 		dev->net->features |= NETIF_F_RXCSUM;
3561 
3562 	if (DEFAULT_TSO_CSUM_ENABLE)
3563 		dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
3564 
3565 	if (DEFAULT_VLAN_RX_OFFLOAD)
3566 		dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX;
3567 
3568 	if (DEFAULT_VLAN_FILTER_ENABLE)
3569 		dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
3570 
3571 	dev->net->hw_features = dev->net->features;
3572 
3573 	ret = lan78xx_setup_irq_domain(dev);
3574 	if (ret < 0) {
3575 		netdev_warn(dev->net,
3576 			    "lan78xx_setup_irq_domain() failed : %d", ret);
3577 		goto out1;
3578 	}
3579 
3580 	/* Init all registers */
3581 	ret = lan78xx_reset(dev);
3582 	if (ret) {
3583 		netdev_warn(dev->net, "Registers INIT FAILED....");
3584 		goto out2;
3585 	}
3586 
3587 	ret = lan78xx_mdio_init(dev);
3588 	if (ret) {
3589 		netdev_warn(dev->net, "MDIO INIT FAILED.....");
3590 		goto out2;
3591 	}
3592 
3593 	dev->net->flags |= IFF_MULTICAST;
3594 
3595 	pdata->wol = WAKE_MAGIC;
3596 
3597 	return ret;
3598 
3599 out2:
3600 	lan78xx_remove_irq_domain(dev);
3601 
3602 out1:
3603 	netdev_warn(dev->net, "Bind routine FAILED");
3604 	cancel_work_sync(&pdata->set_multicast);
3605 	cancel_work_sync(&pdata->set_vlan);
3606 	kfree(pdata);
3607 	return ret;
3608 }
3609 
3610 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
3611 {
3612 	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3613 
3614 	lan78xx_remove_irq_domain(dev);
3615 
3616 	lan78xx_remove_mdio(dev);
3617 
3618 	if (pdata) {
3619 		cancel_work_sync(&pdata->set_multicast);
3620 		cancel_work_sync(&pdata->set_vlan);
3621 		netif_dbg(dev, ifdown, dev->net, "free pdata");
3622 		kfree(pdata);
3623 		pdata = NULL;
3624 		dev->data[0] = 0;
3625 	}
3626 }
3627 
3628 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
3629 				    struct sk_buff *skb,
3630 				    u32 rx_cmd_a, u32 rx_cmd_b)
3631 {
3632 	/* HW Checksum offload appears to be flawed if used when not stripping
3633 	 * VLAN headers. Drop back to S/W checksums under these conditions.
3634 	 */
3635 	if (!(dev->net->features & NETIF_F_RXCSUM) ||
3636 	    unlikely(rx_cmd_a & RX_CMD_A_ICSM_) ||
3637 	    ((rx_cmd_a & RX_CMD_A_FVTG_) &&
3638 	     !(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) {
3639 		skb->ip_summed = CHECKSUM_NONE;
3640 	} else {
3641 		skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
3642 		skb->ip_summed = CHECKSUM_COMPLETE;
3643 	}
3644 }
3645 
3646 static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev,
3647 				    struct sk_buff *skb,
3648 				    u32 rx_cmd_a, u32 rx_cmd_b)
3649 {
3650 	if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) &&
3651 	    (rx_cmd_a & RX_CMD_A_FVTG_))
3652 		__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
3653 				       (rx_cmd_b & 0xffff));
3654 }
3655 
3656 static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
3657 {
3658 	dev->net->stats.rx_packets++;
3659 	dev->net->stats.rx_bytes += skb->len;
3660 
3661 	skb->protocol = eth_type_trans(skb, dev->net);
3662 
3663 	netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
3664 		  skb->len + sizeof(struct ethhdr), skb->protocol);
3665 	memset(skb->cb, 0, sizeof(struct skb_data));
3666 
3667 	if (skb_defer_rx_timestamp(skb))
3668 		return;
3669 
3670 	napi_gro_receive(&dev->napi, skb);
3671 }
3672 
3673 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb,
3674 		      int budget, int *work_done)
3675 {
3676 	if (skb->len < RX_SKB_MIN_LEN)
3677 		return 0;
3678 
3679 	/* Extract frames from the URB buffer and pass each one to
3680 	 * the stack in a new NAPI SKB.
3681 	 */
3682 	while (skb->len > 0) {
3683 		u32 rx_cmd_a, rx_cmd_b, align_count, size;
3684 		u16 rx_cmd_c;
3685 		unsigned char *packet;
3686 
3687 		rx_cmd_a = get_unaligned_le32(skb->data);
3688 		skb_pull(skb, sizeof(rx_cmd_a));
3689 
3690 		rx_cmd_b = get_unaligned_le32(skb->data);
3691 		skb_pull(skb, sizeof(rx_cmd_b));
3692 
3693 		rx_cmd_c = get_unaligned_le16(skb->data);
3694 		skb_pull(skb, sizeof(rx_cmd_c));
3695 
3696 		packet = skb->data;
3697 
3698 		/* get the packet length */
3699 		size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
3700 		align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
3701 
3702 		if (unlikely(size > skb->len)) {
3703 			netif_dbg(dev, rx_err, dev->net,
3704 				  "size err rx_cmd_a=0x%08x\n",
3705 				  rx_cmd_a);
3706 			return 0;
3707 		}
3708 
3709 		if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
3710 			netif_dbg(dev, rx_err, dev->net,
3711 				  "Error rx_cmd_a=0x%08x", rx_cmd_a);
3712 		} else {
3713 			u32 frame_len;
3714 			struct sk_buff *skb2;
3715 
3716 			if (unlikely(size < ETH_FCS_LEN)) {
3717 				netif_dbg(dev, rx_err, dev->net,
3718 					  "size err rx_cmd_a=0x%08x\n",
3719 					  rx_cmd_a);
3720 				return 0;
3721 			}
3722 
3723 			frame_len = size - ETH_FCS_LEN;
3724 
3725 			skb2 = napi_alloc_skb(&dev->napi, frame_len);
3726 			if (!skb2)
3727 				return 0;
3728 
3729 			memcpy(skb2->data, packet, frame_len);
3730 
3731 			skb_put(skb2, frame_len);
3732 
3733 			lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3734 			lan78xx_rx_vlan_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3735 
3736 			/* Processing of the URB buffer must complete once
3737 			 * it has started. If the NAPI work budget is exhausted
3738 			 * while frames remain they are added to the overflow
3739 			 * queue for delivery in the next NAPI polling cycle.
3740 			 */
3741 			if (*work_done < budget) {
3742 				lan78xx_skb_return(dev, skb2);
3743 				++(*work_done);
3744 			} else {
3745 				skb_queue_tail(&dev->rxq_overflow, skb2);
3746 			}
3747 		}
3748 
3749 		skb_pull(skb, size);
3750 
3751 		/* skip padding bytes before the next frame starts */
3752 		if (skb->len)
3753 			skb_pull(skb, align_count);
3754 	}
3755 
3756 	return 1;
3757 }
3758 
3759 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb,
3760 			      int budget, int *work_done)
3761 {
3762 	if (!lan78xx_rx(dev, skb, budget, work_done)) {
3763 		netif_dbg(dev, rx_err, dev->net, "drop\n");
3764 		dev->net->stats.rx_errors++;
3765 	}
3766 }
3767 
3768 static void rx_complete(struct urb *urb)
3769 {
3770 	struct sk_buff	*skb = (struct sk_buff *)urb->context;
3771 	struct skb_data	*entry = (struct skb_data *)skb->cb;
3772 	struct lan78xx_net *dev = entry->dev;
3773 	int urb_status = urb->status;
3774 	enum skb_state state;
3775 
3776 	netif_dbg(dev, rx_status, dev->net,
3777 		  "rx done: status %d", urb->status);
3778 
3779 	skb_put(skb, urb->actual_length);
3780 	state = rx_done;
3781 
3782 	if (urb != entry->urb)
3783 		netif_warn(dev, rx_err, dev->net, "URB pointer mismatch");
3784 
3785 	switch (urb_status) {
3786 	case 0:
3787 		if (skb->len < RX_SKB_MIN_LEN) {
3788 			state = rx_cleanup;
3789 			dev->net->stats.rx_errors++;
3790 			dev->net->stats.rx_length_errors++;
3791 			netif_dbg(dev, rx_err, dev->net,
3792 				  "rx length %d\n", skb->len);
3793 		}
3794 		usb_mark_last_busy(dev->udev);
3795 		break;
3796 	case -EPIPE:
3797 		dev->net->stats.rx_errors++;
3798 		lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3799 		fallthrough;
3800 	case -ECONNRESET:				/* async unlink */
3801 	case -ESHUTDOWN:				/* hardware gone */
3802 		netif_dbg(dev, ifdown, dev->net,
3803 			  "rx shutdown, code %d\n", urb_status);
3804 		state = rx_cleanup;
3805 		break;
3806 	case -EPROTO:
3807 	case -ETIME:
3808 	case -EILSEQ:
3809 		dev->net->stats.rx_errors++;
3810 		state = rx_cleanup;
3811 		break;
3812 
3813 	/* data overrun ... flush fifo? */
3814 	case -EOVERFLOW:
3815 		dev->net->stats.rx_over_errors++;
3816 		fallthrough;
3817 
3818 	default:
3819 		state = rx_cleanup;
3820 		dev->net->stats.rx_errors++;
3821 		netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3822 		break;
3823 	}
3824 
3825 	state = defer_bh(dev, skb, &dev->rxq, state);
3826 }
3827 
3828 static int rx_submit(struct lan78xx_net *dev, struct sk_buff *skb, gfp_t flags)
3829 {
3830 	struct skb_data	*entry = (struct skb_data *)skb->cb;
3831 	size_t size = dev->rx_urb_size;
3832 	struct urb *urb = entry->urb;
3833 	unsigned long lockflags;
3834 	int ret = 0;
3835 
3836 	usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3837 			  skb->data, size, rx_complete, skb);
3838 
3839 	spin_lock_irqsave(&dev->rxq.lock, lockflags);
3840 
3841 	if (netif_device_present(dev->net) &&
3842 	    netif_running(dev->net) &&
3843 	    !test_bit(EVENT_RX_HALT, &dev->flags) &&
3844 	    !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3845 		ret = usb_submit_urb(urb, flags);
3846 		switch (ret) {
3847 		case 0:
3848 			lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3849 			break;
3850 		case -EPIPE:
3851 			lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3852 			break;
3853 		case -ENODEV:
3854 		case -ENOENT:
3855 			netif_dbg(dev, ifdown, dev->net, "device gone\n");
3856 			netif_device_detach(dev->net);
3857 			break;
3858 		case -EHOSTUNREACH:
3859 			ret = -ENOLINK;
3860 			napi_schedule(&dev->napi);
3861 			break;
3862 		default:
3863 			netif_dbg(dev, rx_err, dev->net,
3864 				  "rx submit, %d\n", ret);
3865 			napi_schedule(&dev->napi);
3866 			break;
3867 		}
3868 	} else {
3869 		netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3870 		ret = -ENOLINK;
3871 	}
3872 	spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3873 
3874 	if (ret)
3875 		lan78xx_release_rx_buf(dev, skb);
3876 
3877 	return ret;
3878 }
3879 
3880 static void lan78xx_rx_urb_submit_all(struct lan78xx_net *dev)
3881 {
3882 	struct sk_buff *rx_buf;
3883 
3884 	/* Ensure the maximum number of Rx URBs is submitted
3885 	 */
3886 	while ((rx_buf = lan78xx_get_rx_buf(dev)) != NULL) {
3887 		if (rx_submit(dev, rx_buf, GFP_ATOMIC) != 0)
3888 			break;
3889 	}
3890 }
3891 
3892 static void lan78xx_rx_urb_resubmit(struct lan78xx_net *dev,
3893 				    struct sk_buff *rx_buf)
3894 {
3895 	/* reset SKB data pointers */
3896 
3897 	rx_buf->data = rx_buf->head;
3898 	skb_reset_tail_pointer(rx_buf);
3899 	rx_buf->len = 0;
3900 	rx_buf->data_len = 0;
3901 
3902 	rx_submit(dev, rx_buf, GFP_ATOMIC);
3903 }
3904 
3905 static void lan78xx_fill_tx_cmd_words(struct sk_buff *skb, u8 *buffer)
3906 {
3907 	u32 tx_cmd_a;
3908 	u32 tx_cmd_b;
3909 
3910 	tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
3911 
3912 	if (skb->ip_summed == CHECKSUM_PARTIAL)
3913 		tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
3914 
3915 	tx_cmd_b = 0;
3916 	if (skb_is_gso(skb)) {
3917 		u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
3918 
3919 		tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
3920 
3921 		tx_cmd_a |= TX_CMD_A_LSO_;
3922 	}
3923 
3924 	if (skb_vlan_tag_present(skb)) {
3925 		tx_cmd_a |= TX_CMD_A_IVTG_;
3926 		tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
3927 	}
3928 
3929 	put_unaligned_le32(tx_cmd_a, buffer);
3930 	put_unaligned_le32(tx_cmd_b, buffer + 4);
3931 }
3932 
3933 static struct skb_data *lan78xx_tx_buf_fill(struct lan78xx_net *dev,
3934 					    struct sk_buff *tx_buf)
3935 {
3936 	struct skb_data *entry = (struct skb_data *)tx_buf->cb;
3937 	int remain = dev->tx_urb_size;
3938 	u8 *tx_data = tx_buf->data;
3939 	u32 urb_len = 0;
3940 
3941 	entry->num_of_packet = 0;
3942 	entry->length = 0;
3943 
3944 	/* Work through the pending SKBs and copy the data of each SKB into
3945 	 * the URB buffer if there room for all the SKB data.
3946 	 *
3947 	 * There must be at least DST+SRC+TYPE in the SKB (with padding enabled)
3948 	 */
3949 	while (remain >= TX_SKB_MIN_LEN) {
3950 		unsigned int pending_bytes;
3951 		unsigned int align_bytes;
3952 		struct sk_buff *skb;
3953 		unsigned int len;
3954 
3955 		lan78xx_tx_pend_skb_get(dev, &skb, &pending_bytes);
3956 
3957 		if (!skb)
3958 			break;
3959 
3960 		align_bytes = (TX_ALIGNMENT - (urb_len % TX_ALIGNMENT)) %
3961 			      TX_ALIGNMENT;
3962 		len = align_bytes + TX_CMD_LEN + skb->len;
3963 		if (len > remain) {
3964 			lan78xx_tx_pend_skb_head_add(dev, skb, &pending_bytes);
3965 			break;
3966 		}
3967 
3968 		tx_data += align_bytes;
3969 
3970 		lan78xx_fill_tx_cmd_words(skb, tx_data);
3971 		tx_data += TX_CMD_LEN;
3972 
3973 		len = skb->len;
3974 		if (skb_copy_bits(skb, 0, tx_data, len) < 0) {
3975 			struct net_device_stats *stats = &dev->net->stats;
3976 
3977 			stats->tx_dropped++;
3978 			dev_kfree_skb_any(skb);
3979 			tx_data -= TX_CMD_LEN;
3980 			continue;
3981 		}
3982 
3983 		tx_data += len;
3984 		entry->length += len;
3985 		entry->num_of_packet += skb_shinfo(skb)->gso_segs ?: 1;
3986 
3987 		dev_kfree_skb_any(skb);
3988 
3989 		urb_len = (u32)(tx_data - (u8 *)tx_buf->data);
3990 
3991 		remain = dev->tx_urb_size - urb_len;
3992 	}
3993 
3994 	skb_put(tx_buf, urb_len);
3995 
3996 	return entry;
3997 }
3998 
3999 static void lan78xx_tx_bh(struct lan78xx_net *dev)
4000 {
4001 	int ret;
4002 
4003 	/* Start the stack Tx queue if it was stopped
4004 	 */
4005 	netif_tx_lock(dev->net);
4006 	if (netif_queue_stopped(dev->net)) {
4007 		if (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev))
4008 			netif_wake_queue(dev->net);
4009 	}
4010 	netif_tx_unlock(dev->net);
4011 
4012 	/* Go through the Tx pending queue and set up URBs to transfer
4013 	 * the data to the device. Stop if no more pending data or URBs,
4014 	 * or if an error occurs when a URB is submitted.
4015 	 */
4016 	do {
4017 		struct skb_data *entry;
4018 		struct sk_buff *tx_buf;
4019 		unsigned long flags;
4020 
4021 		if (skb_queue_empty(&dev->txq_pend))
4022 			break;
4023 
4024 		tx_buf = lan78xx_get_tx_buf(dev);
4025 		if (!tx_buf)
4026 			break;
4027 
4028 		entry = lan78xx_tx_buf_fill(dev, tx_buf);
4029 
4030 		spin_lock_irqsave(&dev->txq.lock, flags);
4031 		ret = usb_autopm_get_interface_async(dev->intf);
4032 		if (ret < 0) {
4033 			spin_unlock_irqrestore(&dev->txq.lock, flags);
4034 			goto out;
4035 		}
4036 
4037 		usb_fill_bulk_urb(entry->urb, dev->udev, dev->pipe_out,
4038 				  tx_buf->data, tx_buf->len, tx_complete,
4039 				  tx_buf);
4040 
4041 		if (tx_buf->len % dev->maxpacket == 0) {
4042 			/* send USB_ZERO_PACKET */
4043 			entry->urb->transfer_flags |= URB_ZERO_PACKET;
4044 		}
4045 
4046 #ifdef CONFIG_PM
4047 		/* if device is asleep stop outgoing packet processing */
4048 		if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
4049 			usb_anchor_urb(entry->urb, &dev->deferred);
4050 			netif_stop_queue(dev->net);
4051 			spin_unlock_irqrestore(&dev->txq.lock, flags);
4052 			netdev_dbg(dev->net,
4053 				   "Delaying transmission for resumption\n");
4054 			return;
4055 		}
4056 #endif
4057 		ret = usb_submit_urb(entry->urb, GFP_ATOMIC);
4058 		switch (ret) {
4059 		case 0:
4060 			netif_trans_update(dev->net);
4061 			lan78xx_queue_skb(&dev->txq, tx_buf, tx_start);
4062 			break;
4063 		case -EPIPE:
4064 			netif_stop_queue(dev->net);
4065 			lan78xx_defer_kevent(dev, EVENT_TX_HALT);
4066 			usb_autopm_put_interface_async(dev->intf);
4067 			break;
4068 		case -ENODEV:
4069 		case -ENOENT:
4070 			netif_dbg(dev, tx_err, dev->net,
4071 				  "tx submit urb err %d (disconnected?)", ret);
4072 			netif_device_detach(dev->net);
4073 			break;
4074 		default:
4075 			usb_autopm_put_interface_async(dev->intf);
4076 			netif_dbg(dev, tx_err, dev->net,
4077 				  "tx submit urb err %d\n", ret);
4078 			break;
4079 		}
4080 
4081 		spin_unlock_irqrestore(&dev->txq.lock, flags);
4082 
4083 		if (ret) {
4084 			netdev_warn(dev->net, "failed to tx urb %d\n", ret);
4085 out:
4086 			dev->net->stats.tx_dropped += entry->num_of_packet;
4087 			lan78xx_release_tx_buf(dev, tx_buf);
4088 		}
4089 	} while (ret == 0);
4090 }
4091 
4092 static int lan78xx_bh(struct lan78xx_net *dev, int budget)
4093 {
4094 	struct sk_buff_head done;
4095 	struct sk_buff *rx_buf;
4096 	struct skb_data *entry;
4097 	unsigned long flags;
4098 	int work_done = 0;
4099 
4100 	/* Pass frames received in the last NAPI cycle before
4101 	 * working on newly completed URBs.
4102 	 */
4103 	while (!skb_queue_empty(&dev->rxq_overflow)) {
4104 		lan78xx_skb_return(dev, skb_dequeue(&dev->rxq_overflow));
4105 		++work_done;
4106 	}
4107 
4108 	/* Take a snapshot of the done queue and move items to a
4109 	 * temporary queue. Rx URB completions will continue to add
4110 	 * to the done queue.
4111 	 */
4112 	__skb_queue_head_init(&done);
4113 
4114 	spin_lock_irqsave(&dev->rxq_done.lock, flags);
4115 	skb_queue_splice_init(&dev->rxq_done, &done);
4116 	spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
4117 
4118 	/* Extract receive frames from completed URBs and
4119 	 * pass them to the stack. Re-submit each completed URB.
4120 	 */
4121 	while ((work_done < budget) &&
4122 	       (rx_buf = __skb_dequeue(&done))) {
4123 		entry = (struct skb_data *)(rx_buf->cb);
4124 		switch (entry->state) {
4125 		case rx_done:
4126 			rx_process(dev, rx_buf, budget, &work_done);
4127 			break;
4128 		case rx_cleanup:
4129 			break;
4130 		default:
4131 			netdev_dbg(dev->net, "rx buf state %d\n",
4132 				   entry->state);
4133 			break;
4134 		}
4135 
4136 		lan78xx_rx_urb_resubmit(dev, rx_buf);
4137 	}
4138 
4139 	/* If budget was consumed before processing all the URBs put them
4140 	 * back on the front of the done queue. They will be first to be
4141 	 * processed in the next NAPI cycle.
4142 	 */
4143 	spin_lock_irqsave(&dev->rxq_done.lock, flags);
4144 	skb_queue_splice(&done, &dev->rxq_done);
4145 	spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
4146 
4147 	if (netif_device_present(dev->net) && netif_running(dev->net)) {
4148 		/* reset update timer delta */
4149 		if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
4150 			dev->delta = 1;
4151 			mod_timer(&dev->stat_monitor,
4152 				  jiffies + STAT_UPDATE_TIMER);
4153 		}
4154 
4155 		/* Submit all free Rx URBs */
4156 
4157 		if (!test_bit(EVENT_RX_HALT, &dev->flags))
4158 			lan78xx_rx_urb_submit_all(dev);
4159 
4160 		/* Submit new Tx URBs */
4161 
4162 		lan78xx_tx_bh(dev);
4163 	}
4164 
4165 	return work_done;
4166 }
4167 
4168 static int lan78xx_poll(struct napi_struct *napi, int budget)
4169 {
4170 	struct lan78xx_net *dev = container_of(napi, struct lan78xx_net, napi);
4171 	int result = budget;
4172 	int work_done;
4173 
4174 	/* Don't do any work if the device is suspended */
4175 
4176 	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
4177 		napi_complete_done(napi, 0);
4178 		return 0;
4179 	}
4180 
4181 	/* Process completed URBs and submit new URBs */
4182 
4183 	work_done = lan78xx_bh(dev, budget);
4184 
4185 	if (work_done < budget) {
4186 		napi_complete_done(napi, work_done);
4187 
4188 		/* Start a new polling cycle if data was received or
4189 		 * data is waiting to be transmitted.
4190 		 */
4191 		if (!skb_queue_empty(&dev->rxq_done)) {
4192 			napi_schedule(napi);
4193 		} else if (netif_carrier_ok(dev->net)) {
4194 			if (skb_queue_empty(&dev->txq) &&
4195 			    !skb_queue_empty(&dev->txq_pend)) {
4196 				napi_schedule(napi);
4197 			} else {
4198 				netif_tx_lock(dev->net);
4199 				if (netif_queue_stopped(dev->net)) {
4200 					netif_wake_queue(dev->net);
4201 					napi_schedule(napi);
4202 				}
4203 				netif_tx_unlock(dev->net);
4204 			}
4205 		}
4206 		result = work_done;
4207 	}
4208 
4209 	return result;
4210 }
4211 
4212 static void lan78xx_delayedwork(struct work_struct *work)
4213 {
4214 	int status;
4215 	struct lan78xx_net *dev;
4216 
4217 	dev = container_of(work, struct lan78xx_net, wq.work);
4218 
4219 	if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
4220 		return;
4221 
4222 	if (usb_autopm_get_interface(dev->intf) < 0)
4223 		return;
4224 
4225 	if (test_bit(EVENT_TX_HALT, &dev->flags)) {
4226 		unlink_urbs(dev, &dev->txq);
4227 
4228 		status = usb_clear_halt(dev->udev, dev->pipe_out);
4229 		if (status < 0 &&
4230 		    status != -EPIPE &&
4231 		    status != -ESHUTDOWN) {
4232 			if (netif_msg_tx_err(dev))
4233 				netdev_err(dev->net,
4234 					   "can't clear tx halt, status %d\n",
4235 					   status);
4236 		} else {
4237 			clear_bit(EVENT_TX_HALT, &dev->flags);
4238 			if (status != -ESHUTDOWN)
4239 				netif_wake_queue(dev->net);
4240 		}
4241 	}
4242 
4243 	if (test_bit(EVENT_RX_HALT, &dev->flags)) {
4244 		unlink_urbs(dev, &dev->rxq);
4245 		status = usb_clear_halt(dev->udev, dev->pipe_in);
4246 		if (status < 0 &&
4247 		    status != -EPIPE &&
4248 		    status != -ESHUTDOWN) {
4249 			if (netif_msg_rx_err(dev))
4250 				netdev_err(dev->net,
4251 					   "can't clear rx halt, status %d\n",
4252 					   status);
4253 		} else {
4254 			clear_bit(EVENT_RX_HALT, &dev->flags);
4255 			napi_schedule(&dev->napi);
4256 		}
4257 	}
4258 
4259 	if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
4260 		int ret = 0;
4261 
4262 		clear_bit(EVENT_LINK_RESET, &dev->flags);
4263 		if (lan78xx_link_reset(dev) < 0) {
4264 			netdev_info(dev->net, "link reset failed (%d)\n",
4265 				    ret);
4266 		}
4267 	}
4268 
4269 	if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
4270 		lan78xx_update_stats(dev);
4271 
4272 		clear_bit(EVENT_STAT_UPDATE, &dev->flags);
4273 
4274 		mod_timer(&dev->stat_monitor,
4275 			  jiffies + (STAT_UPDATE_TIMER * dev->delta));
4276 
4277 		dev->delta = min((dev->delta * 2), 50);
4278 	}
4279 
4280 	usb_autopm_put_interface(dev->intf);
4281 }
4282 
4283 static void intr_complete(struct urb *urb)
4284 {
4285 	struct lan78xx_net *dev = urb->context;
4286 	int status = urb->status;
4287 
4288 	switch (status) {
4289 	/* success */
4290 	case 0:
4291 		lan78xx_status(dev, urb);
4292 		break;
4293 
4294 	/* software-driven interface shutdown */
4295 	case -ENOENT:			/* urb killed */
4296 	case -ENODEV:			/* hardware gone */
4297 	case -ESHUTDOWN:		/* hardware gone */
4298 		netif_dbg(dev, ifdown, dev->net,
4299 			  "intr shutdown, code %d\n", status);
4300 		return;
4301 
4302 	/* NOTE:  not throttling like RX/TX, since this endpoint
4303 	 * already polls infrequently
4304 	 */
4305 	default:
4306 		netdev_dbg(dev->net, "intr status %d\n", status);
4307 		break;
4308 	}
4309 
4310 	if (!netif_device_present(dev->net) ||
4311 	    !netif_running(dev->net)) {
4312 		netdev_warn(dev->net, "not submitting new status URB");
4313 		return;
4314 	}
4315 
4316 	memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
4317 	status = usb_submit_urb(urb, GFP_ATOMIC);
4318 
4319 	switch (status) {
4320 	case  0:
4321 		break;
4322 	case -ENODEV:
4323 	case -ENOENT:
4324 		netif_dbg(dev, timer, dev->net,
4325 			  "intr resubmit %d (disconnect?)", status);
4326 		netif_device_detach(dev->net);
4327 		break;
4328 	default:
4329 		netif_err(dev, timer, dev->net,
4330 			  "intr resubmit --> %d\n", status);
4331 		break;
4332 	}
4333 }
4334 
4335 static void lan78xx_disconnect(struct usb_interface *intf)
4336 {
4337 	struct lan78xx_net *dev;
4338 	struct usb_device *udev;
4339 	struct net_device *net;
4340 	struct phy_device *phydev;
4341 
4342 	dev = usb_get_intfdata(intf);
4343 	usb_set_intfdata(intf, NULL);
4344 	if (!dev)
4345 		return;
4346 
4347 	netif_napi_del(&dev->napi);
4348 
4349 	udev = interface_to_usbdev(intf);
4350 	net = dev->net;
4351 
4352 	unregister_netdev(net);
4353 
4354 	timer_shutdown_sync(&dev->stat_monitor);
4355 	set_bit(EVENT_DEV_DISCONNECT, &dev->flags);
4356 	cancel_delayed_work_sync(&dev->wq);
4357 
4358 	phydev = net->phydev;
4359 
4360 	phy_disconnect(net->phydev);
4361 
4362 	if (phy_is_pseudo_fixed_link(phydev)) {
4363 		fixed_phy_unregister(phydev);
4364 		phy_device_free(phydev);
4365 	}
4366 
4367 	usb_scuttle_anchored_urbs(&dev->deferred);
4368 
4369 	lan78xx_unbind(dev, intf);
4370 
4371 	lan78xx_free_tx_resources(dev);
4372 	lan78xx_free_rx_resources(dev);
4373 
4374 	usb_kill_urb(dev->urb_intr);
4375 	usb_free_urb(dev->urb_intr);
4376 
4377 	free_netdev(net);
4378 	usb_put_dev(udev);
4379 }
4380 
4381 static void lan78xx_tx_timeout(struct net_device *net, unsigned int txqueue)
4382 {
4383 	struct lan78xx_net *dev = netdev_priv(net);
4384 
4385 	unlink_urbs(dev, &dev->txq);
4386 	napi_schedule(&dev->napi);
4387 }
4388 
4389 static netdev_features_t lan78xx_features_check(struct sk_buff *skb,
4390 						struct net_device *netdev,
4391 						netdev_features_t features)
4392 {
4393 	struct lan78xx_net *dev = netdev_priv(netdev);
4394 
4395 	if (skb->len > LAN78XX_TSO_SIZE(dev))
4396 		features &= ~NETIF_F_GSO_MASK;
4397 
4398 	features = vlan_features_check(skb, features);
4399 	features = vxlan_features_check(skb, features);
4400 
4401 	return features;
4402 }
4403 
4404 static const struct net_device_ops lan78xx_netdev_ops = {
4405 	.ndo_open		= lan78xx_open,
4406 	.ndo_stop		= lan78xx_stop,
4407 	.ndo_start_xmit		= lan78xx_start_xmit,
4408 	.ndo_tx_timeout		= lan78xx_tx_timeout,
4409 	.ndo_change_mtu		= lan78xx_change_mtu,
4410 	.ndo_set_mac_address	= lan78xx_set_mac_addr,
4411 	.ndo_validate_addr	= eth_validate_addr,
4412 	.ndo_eth_ioctl		= phy_do_ioctl_running,
4413 	.ndo_set_rx_mode	= lan78xx_set_multicast,
4414 	.ndo_set_features	= lan78xx_set_features,
4415 	.ndo_vlan_rx_add_vid	= lan78xx_vlan_rx_add_vid,
4416 	.ndo_vlan_rx_kill_vid	= lan78xx_vlan_rx_kill_vid,
4417 	.ndo_features_check	= lan78xx_features_check,
4418 };
4419 
4420 static void lan78xx_stat_monitor(struct timer_list *t)
4421 {
4422 	struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
4423 
4424 	lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
4425 }
4426 
4427 static int lan78xx_probe(struct usb_interface *intf,
4428 			 const struct usb_device_id *id)
4429 {
4430 	struct usb_host_endpoint *ep_blkin, *ep_blkout, *ep_intr;
4431 	struct lan78xx_net *dev;
4432 	struct net_device *netdev;
4433 	struct usb_device *udev;
4434 	int ret;
4435 	unsigned int maxp;
4436 	unsigned int period;
4437 	u8 *buf = NULL;
4438 
4439 	udev = interface_to_usbdev(intf);
4440 	udev = usb_get_dev(udev);
4441 
4442 	netdev = alloc_etherdev(sizeof(struct lan78xx_net));
4443 	if (!netdev) {
4444 		dev_err(&intf->dev, "Error: OOM\n");
4445 		ret = -ENOMEM;
4446 		goto out1;
4447 	}
4448 
4449 	/* netdev_printk() needs this */
4450 	SET_NETDEV_DEV(netdev, &intf->dev);
4451 
4452 	dev = netdev_priv(netdev);
4453 	dev->udev = udev;
4454 	dev->intf = intf;
4455 	dev->net = netdev;
4456 	dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
4457 					| NETIF_MSG_PROBE | NETIF_MSG_LINK);
4458 
4459 	skb_queue_head_init(&dev->rxq);
4460 	skb_queue_head_init(&dev->txq);
4461 	skb_queue_head_init(&dev->rxq_done);
4462 	skb_queue_head_init(&dev->txq_pend);
4463 	skb_queue_head_init(&dev->rxq_overflow);
4464 	mutex_init(&dev->mdiobus_mutex);
4465 	mutex_init(&dev->dev_mutex);
4466 
4467 	ret = lan78xx_urb_config_init(dev);
4468 	if (ret < 0)
4469 		goto out2;
4470 
4471 	ret = lan78xx_alloc_tx_resources(dev);
4472 	if (ret < 0)
4473 		goto out2;
4474 
4475 	ret = lan78xx_alloc_rx_resources(dev);
4476 	if (ret < 0)
4477 		goto out3;
4478 
4479 	/* MTU range: 68 - 9000 */
4480 	netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
4481 
4482 	netif_set_tso_max_size(netdev, LAN78XX_TSO_SIZE(dev));
4483 
4484 	netif_napi_add(netdev, &dev->napi, lan78xx_poll);
4485 
4486 	INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
4487 	init_usb_anchor(&dev->deferred);
4488 
4489 	netdev->netdev_ops = &lan78xx_netdev_ops;
4490 	netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
4491 	netdev->ethtool_ops = &lan78xx_ethtool_ops;
4492 
4493 	dev->delta = 1;
4494 	timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
4495 
4496 	mutex_init(&dev->stats.access_lock);
4497 
4498 	if (intf->cur_altsetting->desc.bNumEndpoints < 3) {
4499 		ret = -ENODEV;
4500 		goto out4;
4501 	}
4502 
4503 	dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
4504 	ep_blkin = usb_pipe_endpoint(udev, dev->pipe_in);
4505 	if (!ep_blkin || !usb_endpoint_is_bulk_in(&ep_blkin->desc)) {
4506 		ret = -ENODEV;
4507 		goto out4;
4508 	}
4509 
4510 	dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
4511 	ep_blkout = usb_pipe_endpoint(udev, dev->pipe_out);
4512 	if (!ep_blkout || !usb_endpoint_is_bulk_out(&ep_blkout->desc)) {
4513 		ret = -ENODEV;
4514 		goto out4;
4515 	}
4516 
4517 	ep_intr = &intf->cur_altsetting->endpoint[2];
4518 	if (!usb_endpoint_is_int_in(&ep_intr->desc)) {
4519 		ret = -ENODEV;
4520 		goto out4;
4521 	}
4522 
4523 	dev->pipe_intr = usb_rcvintpipe(dev->udev,
4524 					usb_endpoint_num(&ep_intr->desc));
4525 
4526 	ret = lan78xx_bind(dev, intf);
4527 	if (ret < 0)
4528 		goto out4;
4529 
4530 	period = ep_intr->desc.bInterval;
4531 	maxp = usb_maxpacket(dev->udev, dev->pipe_intr);
4532 
4533 	dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
4534 	if (!dev->urb_intr) {
4535 		ret = -ENOMEM;
4536 		goto out5;
4537 	}
4538 
4539 	buf = kmalloc(maxp, GFP_KERNEL);
4540 	if (!buf) {
4541 		ret = -ENOMEM;
4542 		goto free_urbs;
4543 	}
4544 
4545 	usb_fill_int_urb(dev->urb_intr, dev->udev,
4546 			 dev->pipe_intr, buf, maxp,
4547 			 intr_complete, dev, period);
4548 	dev->urb_intr->transfer_flags |= URB_FREE_BUFFER;
4549 
4550 	dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out);
4551 
4552 	/* Reject broken descriptors. */
4553 	if (dev->maxpacket == 0) {
4554 		ret = -ENODEV;
4555 		goto free_urbs;
4556 	}
4557 
4558 	/* driver requires remote-wakeup capability during autosuspend. */
4559 	intf->needs_remote_wakeup = 1;
4560 
4561 	ret = lan78xx_phy_init(dev);
4562 	if (ret < 0)
4563 		goto free_urbs;
4564 
4565 	ret = register_netdev(netdev);
4566 	if (ret != 0) {
4567 		netif_err(dev, probe, netdev, "couldn't register the device\n");
4568 		goto out8;
4569 	}
4570 
4571 	usb_set_intfdata(intf, dev);
4572 
4573 	ret = device_set_wakeup_enable(&udev->dev, true);
4574 
4575 	 /* Default delay of 2sec has more overhead than advantage.
4576 	  * Set to 10sec as default.
4577 	  */
4578 	pm_runtime_set_autosuspend_delay(&udev->dev,
4579 					 DEFAULT_AUTOSUSPEND_DELAY);
4580 
4581 	return 0;
4582 
4583 out8:
4584 	phy_disconnect(netdev->phydev);
4585 free_urbs:
4586 	usb_free_urb(dev->urb_intr);
4587 out5:
4588 	lan78xx_unbind(dev, intf);
4589 out4:
4590 	netif_napi_del(&dev->napi);
4591 	lan78xx_free_rx_resources(dev);
4592 out3:
4593 	lan78xx_free_tx_resources(dev);
4594 out2:
4595 	free_netdev(netdev);
4596 out1:
4597 	usb_put_dev(udev);
4598 
4599 	return ret;
4600 }
4601 
4602 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
4603 {
4604 	const u16 crc16poly = 0x8005;
4605 	int i;
4606 	u16 bit, crc, msb;
4607 	u8 data;
4608 
4609 	crc = 0xFFFF;
4610 	for (i = 0; i < len; i++) {
4611 		data = *buf++;
4612 		for (bit = 0; bit < 8; bit++) {
4613 			msb = crc >> 15;
4614 			crc <<= 1;
4615 
4616 			if (msb ^ (u16)(data & 1)) {
4617 				crc ^= crc16poly;
4618 				crc |= (u16)0x0001U;
4619 			}
4620 			data >>= 1;
4621 		}
4622 	}
4623 
4624 	return crc;
4625 }
4626 
4627 static int lan78xx_set_auto_suspend(struct lan78xx_net *dev)
4628 {
4629 	u32 buf;
4630 	int ret;
4631 
4632 	ret = lan78xx_stop_tx_path(dev);
4633 	if (ret < 0)
4634 		return ret;
4635 
4636 	ret = lan78xx_stop_rx_path(dev);
4637 	if (ret < 0)
4638 		return ret;
4639 
4640 	/* auto suspend (selective suspend) */
4641 
4642 	ret = lan78xx_write_reg(dev, WUCSR, 0);
4643 	if (ret < 0)
4644 		return ret;
4645 	ret = lan78xx_write_reg(dev, WUCSR2, 0);
4646 	if (ret < 0)
4647 		return ret;
4648 	ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4649 	if (ret < 0)
4650 		return ret;
4651 
4652 	/* set goodframe wakeup */
4653 
4654 	ret = lan78xx_read_reg(dev, WUCSR, &buf);
4655 	if (ret < 0)
4656 		return ret;
4657 
4658 	buf |= WUCSR_RFE_WAKE_EN_;
4659 	buf |= WUCSR_STORE_WAKE_;
4660 
4661 	ret = lan78xx_write_reg(dev, WUCSR, buf);
4662 	if (ret < 0)
4663 		return ret;
4664 
4665 	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4666 	if (ret < 0)
4667 		return ret;
4668 
4669 	buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4670 	buf |= PMT_CTL_RES_CLR_WKP_STS_;
4671 	buf |= PMT_CTL_PHY_WAKE_EN_;
4672 	buf |= PMT_CTL_WOL_EN_;
4673 	buf &= ~PMT_CTL_SUS_MODE_MASK_;
4674 	buf |= PMT_CTL_SUS_MODE_3_;
4675 
4676 	ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4677 	if (ret < 0)
4678 		return ret;
4679 
4680 	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4681 	if (ret < 0)
4682 		return ret;
4683 
4684 	buf |= PMT_CTL_WUPS_MASK_;
4685 
4686 	ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4687 	if (ret < 0)
4688 		return ret;
4689 
4690 	ret = lan78xx_start_rx_path(dev);
4691 
4692 	return ret;
4693 }
4694 
4695 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
4696 {
4697 	const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
4698 	const u8 ipv6_multicast[3] = { 0x33, 0x33 };
4699 	const u8 arp_type[2] = { 0x08, 0x06 };
4700 	u32 temp_pmt_ctl;
4701 	int mask_index;
4702 	u32 temp_wucsr;
4703 	u32 buf;
4704 	u16 crc;
4705 	int ret;
4706 
4707 	ret = lan78xx_stop_tx_path(dev);
4708 	if (ret < 0)
4709 		return ret;
4710 	ret = lan78xx_stop_rx_path(dev);
4711 	if (ret < 0)
4712 		return ret;
4713 
4714 	ret = lan78xx_write_reg(dev, WUCSR, 0);
4715 	if (ret < 0)
4716 		return ret;
4717 	ret = lan78xx_write_reg(dev, WUCSR2, 0);
4718 	if (ret < 0)
4719 		return ret;
4720 	ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4721 	if (ret < 0)
4722 		return ret;
4723 
4724 	temp_wucsr = 0;
4725 
4726 	temp_pmt_ctl = 0;
4727 
4728 	ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
4729 	if (ret < 0)
4730 		return ret;
4731 
4732 	temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
4733 	temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
4734 
4735 	for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++) {
4736 		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
4737 		if (ret < 0)
4738 			return ret;
4739 	}
4740 
4741 	mask_index = 0;
4742 	if (wol & WAKE_PHY) {
4743 		temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
4744 
4745 		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4746 		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4747 		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4748 	}
4749 	if (wol & WAKE_MAGIC) {
4750 		temp_wucsr |= WUCSR_MPEN_;
4751 
4752 		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4753 		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4754 		temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
4755 	}
4756 	if (wol & WAKE_BCAST) {
4757 		temp_wucsr |= WUCSR_BCST_EN_;
4758 
4759 		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4760 		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4761 		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4762 	}
4763 	if (wol & WAKE_MCAST) {
4764 		temp_wucsr |= WUCSR_WAKE_EN_;
4765 
4766 		/* set WUF_CFG & WUF_MASK for IPv4 Multicast */
4767 		crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
4768 		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4769 					WUF_CFGX_EN_ |
4770 					WUF_CFGX_TYPE_MCAST_ |
4771 					(0 << WUF_CFGX_OFFSET_SHIFT_) |
4772 					(crc & WUF_CFGX_CRC16_MASK_));
4773 		if (ret < 0)
4774 			return ret;
4775 
4776 		ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
4777 		if (ret < 0)
4778 			return ret;
4779 		ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4780 		if (ret < 0)
4781 			return ret;
4782 		ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4783 		if (ret < 0)
4784 			return ret;
4785 		ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4786 		if (ret < 0)
4787 			return ret;
4788 
4789 		mask_index++;
4790 
4791 		/* for IPv6 Multicast */
4792 		crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
4793 		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4794 					WUF_CFGX_EN_ |
4795 					WUF_CFGX_TYPE_MCAST_ |
4796 					(0 << WUF_CFGX_OFFSET_SHIFT_) |
4797 					(crc & WUF_CFGX_CRC16_MASK_));
4798 		if (ret < 0)
4799 			return ret;
4800 
4801 		ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
4802 		if (ret < 0)
4803 			return ret;
4804 		ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4805 		if (ret < 0)
4806 			return ret;
4807 		ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4808 		if (ret < 0)
4809 			return ret;
4810 		ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4811 		if (ret < 0)
4812 			return ret;
4813 
4814 		mask_index++;
4815 
4816 		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4817 		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4818 		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4819 	}
4820 	if (wol & WAKE_UCAST) {
4821 		temp_wucsr |= WUCSR_PFDA_EN_;
4822 
4823 		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4824 		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4825 		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4826 	}
4827 	if (wol & WAKE_ARP) {
4828 		temp_wucsr |= WUCSR_WAKE_EN_;
4829 
4830 		/* set WUF_CFG & WUF_MASK
4831 		 * for packettype (offset 12,13) = ARP (0x0806)
4832 		 */
4833 		crc = lan78xx_wakeframe_crc16(arp_type, 2);
4834 		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4835 					WUF_CFGX_EN_ |
4836 					WUF_CFGX_TYPE_ALL_ |
4837 					(0 << WUF_CFGX_OFFSET_SHIFT_) |
4838 					(crc & WUF_CFGX_CRC16_MASK_));
4839 		if (ret < 0)
4840 			return ret;
4841 
4842 		ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
4843 		if (ret < 0)
4844 			return ret;
4845 		ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4846 		if (ret < 0)
4847 			return ret;
4848 		ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4849 		if (ret < 0)
4850 			return ret;
4851 		ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4852 		if (ret < 0)
4853 			return ret;
4854 
4855 		mask_index++;
4856 
4857 		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4858 		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4859 		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4860 	}
4861 
4862 	ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
4863 	if (ret < 0)
4864 		return ret;
4865 
4866 	/* when multiple WOL bits are set */
4867 	if (hweight_long((unsigned long)wol) > 1) {
4868 		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4869 		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4870 		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4871 	}
4872 	ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
4873 	if (ret < 0)
4874 		return ret;
4875 
4876 	/* clear WUPS */
4877 	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4878 	if (ret < 0)
4879 		return ret;
4880 
4881 	buf |= PMT_CTL_WUPS_MASK_;
4882 
4883 	ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4884 	if (ret < 0)
4885 		return ret;
4886 
4887 	ret = lan78xx_start_rx_path(dev);
4888 
4889 	return ret;
4890 }
4891 
4892 static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
4893 {
4894 	struct lan78xx_net *dev = usb_get_intfdata(intf);
4895 	bool dev_open;
4896 	int ret;
4897 
4898 	mutex_lock(&dev->dev_mutex);
4899 
4900 	netif_dbg(dev, ifdown, dev->net,
4901 		  "suspending: pm event %#x", message.event);
4902 
4903 	dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);
4904 
4905 	if (dev_open) {
4906 		spin_lock_irq(&dev->txq.lock);
4907 		/* don't autosuspend while transmitting */
4908 		if ((skb_queue_len(&dev->txq) ||
4909 		     skb_queue_len(&dev->txq_pend)) &&
4910 		    PMSG_IS_AUTO(message)) {
4911 			spin_unlock_irq(&dev->txq.lock);
4912 			ret = -EBUSY;
4913 			goto out;
4914 		} else {
4915 			set_bit(EVENT_DEV_ASLEEP, &dev->flags);
4916 			spin_unlock_irq(&dev->txq.lock);
4917 		}
4918 
4919 		/* stop RX */
4920 		ret = lan78xx_stop_rx_path(dev);
4921 		if (ret < 0)
4922 			goto out;
4923 
4924 		ret = lan78xx_flush_rx_fifo(dev);
4925 		if (ret < 0)
4926 			goto out;
4927 
4928 		/* stop Tx */
4929 		ret = lan78xx_stop_tx_path(dev);
4930 		if (ret < 0)
4931 			goto out;
4932 
4933 		/* empty out the Rx and Tx queues */
4934 		netif_device_detach(dev->net);
4935 		lan78xx_terminate_urbs(dev);
4936 		usb_kill_urb(dev->urb_intr);
4937 
4938 		/* reattach */
4939 		netif_device_attach(dev->net);
4940 
4941 		del_timer(&dev->stat_monitor);
4942 
4943 		if (PMSG_IS_AUTO(message)) {
4944 			ret = lan78xx_set_auto_suspend(dev);
4945 			if (ret < 0)
4946 				goto out;
4947 		} else {
4948 			struct lan78xx_priv *pdata;
4949 
4950 			pdata = (struct lan78xx_priv *)(dev->data[0]);
4951 			netif_carrier_off(dev->net);
4952 			ret = lan78xx_set_suspend(dev, pdata->wol);
4953 			if (ret < 0)
4954 				goto out;
4955 		}
4956 	} else {
4957 		/* Interface is down; don't allow WOL and PHY
4958 		 * events to wake up the host
4959 		 */
4960 		u32 buf;
4961 
4962 		set_bit(EVENT_DEV_ASLEEP, &dev->flags);
4963 
4964 		ret = lan78xx_write_reg(dev, WUCSR, 0);
4965 		if (ret < 0)
4966 			goto out;
4967 		ret = lan78xx_write_reg(dev, WUCSR2, 0);
4968 		if (ret < 0)
4969 			goto out;
4970 
4971 		ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4972 		if (ret < 0)
4973 			goto out;
4974 
4975 		buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4976 		buf |= PMT_CTL_RES_CLR_WKP_STS_;
4977 		buf &= ~PMT_CTL_SUS_MODE_MASK_;
4978 		buf |= PMT_CTL_SUS_MODE_3_;
4979 
4980 		ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4981 		if (ret < 0)
4982 			goto out;
4983 
4984 		ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4985 		if (ret < 0)
4986 			goto out;
4987 
4988 		buf |= PMT_CTL_WUPS_MASK_;
4989 
4990 		ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4991 		if (ret < 0)
4992 			goto out;
4993 	}
4994 
4995 	ret = 0;
4996 out:
4997 	mutex_unlock(&dev->dev_mutex);
4998 
4999 	return ret;
5000 }
5001 
5002 static bool lan78xx_submit_deferred_urbs(struct lan78xx_net *dev)
5003 {
5004 	bool pipe_halted = false;
5005 	struct urb *urb;
5006 
5007 	while ((urb = usb_get_from_anchor(&dev->deferred))) {
5008 		struct sk_buff *skb = urb->context;
5009 		int ret;
5010 
5011 		if (!netif_device_present(dev->net) ||
5012 		    !netif_carrier_ok(dev->net) ||
5013 		    pipe_halted) {
5014 			lan78xx_release_tx_buf(dev, skb);
5015 			continue;
5016 		}
5017 
5018 		ret = usb_submit_urb(urb, GFP_ATOMIC);
5019 
5020 		if (ret == 0) {
5021 			netif_trans_update(dev->net);
5022 			lan78xx_queue_skb(&dev->txq, skb, tx_start);
5023 		} else {
5024 			if (ret == -EPIPE) {
5025 				netif_stop_queue(dev->net);
5026 				pipe_halted = true;
5027 			} else if (ret == -ENODEV) {
5028 				netif_device_detach(dev->net);
5029 			}
5030 
5031 			lan78xx_release_tx_buf(dev, skb);
5032 		}
5033 	}
5034 
5035 	return pipe_halted;
5036 }
5037 
5038 static int lan78xx_resume(struct usb_interface *intf)
5039 {
5040 	struct lan78xx_net *dev = usb_get_intfdata(intf);
5041 	bool dev_open;
5042 	int ret;
5043 
5044 	mutex_lock(&dev->dev_mutex);
5045 
5046 	netif_dbg(dev, ifup, dev->net, "resuming device");
5047 
5048 	dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);
5049 
5050 	if (dev_open) {
5051 		bool pipe_halted = false;
5052 
5053 		ret = lan78xx_flush_tx_fifo(dev);
5054 		if (ret < 0)
5055 			goto out;
5056 
5057 		if (dev->urb_intr) {
5058 			int ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
5059 
5060 			if (ret < 0) {
5061 				if (ret == -ENODEV)
5062 					netif_device_detach(dev->net);
5063 				netdev_warn(dev->net, "Failed to submit intr URB");
5064 			}
5065 		}
5066 
5067 		spin_lock_irq(&dev->txq.lock);
5068 
5069 		if (netif_device_present(dev->net)) {
5070 			pipe_halted = lan78xx_submit_deferred_urbs(dev);
5071 
5072 			if (pipe_halted)
5073 				lan78xx_defer_kevent(dev, EVENT_TX_HALT);
5074 		}
5075 
5076 		clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
5077 
5078 		spin_unlock_irq(&dev->txq.lock);
5079 
5080 		if (!pipe_halted &&
5081 		    netif_device_present(dev->net) &&
5082 		    (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev)))
5083 			netif_start_queue(dev->net);
5084 
5085 		ret = lan78xx_start_tx_path(dev);
5086 		if (ret < 0)
5087 			goto out;
5088 
5089 		napi_schedule(&dev->napi);
5090 
5091 		if (!timer_pending(&dev->stat_monitor)) {
5092 			dev->delta = 1;
5093 			mod_timer(&dev->stat_monitor,
5094 				  jiffies + STAT_UPDATE_TIMER);
5095 		}
5096 
5097 	} else {
5098 		clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
5099 	}
5100 
5101 	ret = lan78xx_write_reg(dev, WUCSR2, 0);
5102 	if (ret < 0)
5103 		goto out;
5104 	ret = lan78xx_write_reg(dev, WUCSR, 0);
5105 	if (ret < 0)
5106 		goto out;
5107 	ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
5108 	if (ret < 0)
5109 		goto out;
5110 
5111 	ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
5112 					     WUCSR2_ARP_RCD_ |
5113 					     WUCSR2_IPV6_TCPSYN_RCD_ |
5114 					     WUCSR2_IPV4_TCPSYN_RCD_);
5115 	if (ret < 0)
5116 		goto out;
5117 
5118 	ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
5119 					    WUCSR_EEE_RX_WAKE_ |
5120 					    WUCSR_PFDA_FR_ |
5121 					    WUCSR_RFE_WAKE_FR_ |
5122 					    WUCSR_WUFR_ |
5123 					    WUCSR_MPR_ |
5124 					    WUCSR_BCST_FR_);
5125 	if (ret < 0)
5126 		goto out;
5127 
5128 	ret = 0;
5129 out:
5130 	mutex_unlock(&dev->dev_mutex);
5131 
5132 	return ret;
5133 }
5134 
5135 static int lan78xx_reset_resume(struct usb_interface *intf)
5136 {
5137 	struct lan78xx_net *dev = usb_get_intfdata(intf);
5138 	int ret;
5139 
5140 	netif_dbg(dev, ifup, dev->net, "(reset) resuming device");
5141 
5142 	ret = lan78xx_reset(dev);
5143 	if (ret < 0)
5144 		return ret;
5145 
5146 	phy_start(dev->net->phydev);
5147 
5148 	ret = lan78xx_resume(intf);
5149 
5150 	return ret;
5151 }
5152 
5153 static const struct usb_device_id products[] = {
5154 	{
5155 	/* LAN7800 USB Gigabit Ethernet Device */
5156 	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
5157 	},
5158 	{
5159 	/* LAN7850 USB Gigabit Ethernet Device */
5160 	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
5161 	},
5162 	{
5163 	/* LAN7801 USB Gigabit Ethernet Device */
5164 	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
5165 	},
5166 	{
5167 	/* ATM2-AF USB Gigabit Ethernet Device */
5168 	USB_DEVICE(AT29M2AF_USB_VENDOR_ID, AT29M2AF_USB_PRODUCT_ID),
5169 	},
5170 	{},
5171 };
5172 MODULE_DEVICE_TABLE(usb, products);
5173 
5174 static struct usb_driver lan78xx_driver = {
5175 	.name			= DRIVER_NAME,
5176 	.id_table		= products,
5177 	.probe			= lan78xx_probe,
5178 	.disconnect		= lan78xx_disconnect,
5179 	.suspend		= lan78xx_suspend,
5180 	.resume			= lan78xx_resume,
5181 	.reset_resume		= lan78xx_reset_resume,
5182 	.supports_autosuspend	= 1,
5183 	.disable_hub_initiated_lpm = 1,
5184 };
5185 
5186 module_usb_driver(lan78xx_driver);
5187 
5188 MODULE_AUTHOR(DRIVER_AUTHOR);
5189 MODULE_DESCRIPTION(DRIVER_DESC);
5190 MODULE_LICENSE("GPL");
5191