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