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	napi_schedule(n: &dev->napi);
1505	}
1506
1507	return 0;
1508	}
1509
1510	/* some work can't be done in tasklets, so we use keventd
1511	*
1512	* NOTE: annoying asymmetry: if it's active, schedule_work() fails,
1513	* but tasklet_schedule() doesn't. hope the failure is rare.
1514	*/
1515	static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1516	{
1517	set_bit(nr: work, addr: &dev->flags);
1518	if (!schedule_delayed_work(dwork: &dev->wq, delay: 0))
1519	netdev_err(dev: dev->net, format: "kevent %d may have been dropped\n", work);
1520	}
1521
1522	static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1523	{
1524	u32 intdata;
1525
1526	if (urb->actual_length != 4) {
1527	netdev_warn(dev: dev->net,
1528	format: "unexpected urb length %d", urb->actual_length);
1529	return;
1530	}
1531
1532	intdata = get_unaligned_le32(p: urb->transfer_buffer);
1533
1534	if (intdata & INT_ENP_PHY_INT) {
1535	netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1536	lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1537
1538	if (dev->domain_data.phyirq > 0)
1539	generic_handle_irq_safe(irq: dev->domain_data.phyirq);
1540	} else {
1541	netdev_warn(dev: dev->net,
1542	format: "unexpected interrupt: 0x%08x\n", intdata);
1543	}
1544	}
1545
1546	static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1547	{
1548	return MAX_EEPROM_SIZE;
1549	}
1550
1551	static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1552	struct ethtool_eeprom *ee, u8 *data)
1553	{
1554	struct lan78xx_net *dev = netdev_priv(dev: netdev);
1555	int ret;
1556
1557	ret = usb_autopm_get_interface(intf: dev->intf);
1558	if (ret)
1559	return ret;
1560
1561	ee->magic = LAN78XX_EEPROM_MAGIC;
1562
1563	ret = lan78xx_read_raw_eeprom(dev, offset: ee->offset, length: ee->len, data);
1564
1565	usb_autopm_put_interface(intf: dev->intf);
1566
1567	return ret;
1568	}
1569
1570	static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1571	struct ethtool_eeprom *ee, u8 *data)
1572	{
1573	struct lan78xx_net *dev = netdev_priv(dev: netdev);
1574	int ret;
1575
1576	ret = usb_autopm_get_interface(intf: dev->intf);
1577	if (ret)
1578	return ret;
1579
1580	/* Invalid EEPROM_INDICATOR at offset zero will result in a failure
1581	* to load data from EEPROM
1582	*/
1583	if (ee->magic == LAN78XX_EEPROM_MAGIC)
1584	ret = lan78xx_write_raw_eeprom(dev, offset: ee->offset, length: ee->len, data);
1585	else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1586	(ee->offset == 0) &&
1587	(ee->len == 512) &&
1588	(data[0] == OTP_INDICATOR_1))
1589	ret = lan78xx_write_raw_otp(dev, offset: ee->offset, length: ee->len, data);
1590
1591	usb_autopm_put_interface(intf: dev->intf);
1592
1593	return ret;
1594	}
1595
1596	static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1597	u8 *data)
1598	{
1599	if (stringset == ETH_SS_STATS)
1600	memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1601	}
1602
1603	static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1604	{
1605	if (sset == ETH_SS_STATS)
1606	return ARRAY_SIZE(lan78xx_gstrings);
1607	else
1608	return -EOPNOTSUPP;
1609	}
1610
1611	static void lan78xx_get_stats(struct net_device *netdev,
1612	struct ethtool_stats *stats, u64 *data)
1613	{
1614	struct lan78xx_net *dev = netdev_priv(dev: netdev);
1615
1616	lan78xx_update_stats(dev);
1617
1618	mutex_lock(&dev->stats.access_lock);
1619	memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1620	mutex_unlock(lock: &dev->stats.access_lock);
1621	}
1622
1623	static void lan78xx_get_wol(struct net_device *netdev,
1624	struct ethtool_wolinfo *wol)
1625	{
1626	struct lan78xx_net *dev = netdev_priv(dev: netdev);
1627	int ret;
1628	u32 buf;
1629	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1630
1631	if (usb_autopm_get_interface(intf: dev->intf) < 0)
1632	return;
1633
1634	ret = lan78xx_read_reg(dev, USB_CFG0, data: &buf);
1635	if (unlikely(ret < 0)) {
1636	wol->supported = 0;
1637	wol->wolopts = 0;
1638	} else {
1639	if (buf & USB_CFG_RMT_WKP_) {
1640	wol->supported = WAKE_ALL;
1641	wol->wolopts = pdata->wol;
1642	} else {
1643	wol->supported = 0;
1644	wol->wolopts = 0;
1645	}
1646	}
1647
1648	usb_autopm_put_interface(intf: dev->intf);
1649	}
1650
1651	static int lan78xx_set_wol(struct net_device *netdev,
1652	struct ethtool_wolinfo *wol)
1653	{
1654	struct lan78xx_net *dev = netdev_priv(dev: netdev);
1655	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1656	int ret;
1657
1658	ret = usb_autopm_get_interface(intf: dev->intf);
1659	if (ret < 0)
1660	return ret;
1661
1662	if (wol->wolopts & ~WAKE_ALL)
1663	return -EINVAL;
1664
1665	pdata->wol = wol->wolopts;
1666
1667	device_set_wakeup_enable(dev: &dev->udev->dev, enable: (bool)wol->wolopts);
1668
1669	phy_ethtool_set_wol(phydev: netdev->phydev, wol);
1670
1671	usb_autopm_put_interface(intf: dev->intf);
1672
1673	return ret;
1674	}
1675
1676	static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1677	{
1678	struct lan78xx_net *dev = netdev_priv(dev: net);
1679	struct phy_device *phydev = net->phydev;
1680	int ret;
1681	u32 buf;
1682
1683	ret = usb_autopm_get_interface(intf: dev->intf);
1684	if (ret < 0)
1685	return ret;
1686
1687	ret = phy_ethtool_get_eee(phydev, data: edata);
1688	if (ret < 0)
1689	goto exit;
1690
1691	ret = lan78xx_read_reg(dev, MAC_CR, data: &buf);
1692	if (buf & MAC_CR_EEE_EN_) {
1693	edata->eee_enabled = true;
1694	edata->eee_active = !!(edata->advertised &
1695	edata->lp_advertised);
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_eee *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(p: info->driver, DRIVER_NAME, size: 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	ret = lan78xx_read_raw_eeprom(dev, offset: 0, length: 1, data: &sig);
3040	if (!ret && sig != EEPROM_INDICATOR) {
3041	/* Implies there is no external eeprom. Set mac speed */
3042	netdev_info(dev: dev->net, format: "No External EEPROM. Setting MAC Speed\n");
3043	buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
3044	}
3045	}
3046	ret = lan78xx_write_reg(dev, MAC_CR, data: buf);
3047	if (ret < 0)
3048	return ret;
3049
3050	ret = lan78xx_set_rx_max_frame_length(dev,
3051	RX_MAX_FRAME_LEN(dev->net->mtu));
3052
3053	return ret;
3054	}
3055
3056	static void lan78xx_init_stats(struct lan78xx_net *dev)
3057	{
3058	u32 *p;
3059	int i;
3060
3061	/* initialize for stats update
3062	* some counters are 20bits and some are 32bits
3063	*/
3064	p = (u32 *)&dev->stats.rollover_max;
3065	for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
3066	p[i] = 0xFFFFF;
3067
3068	dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
3069	dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
3070	dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
3071	dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
3072	dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
3073	dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
3074	dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
3075	dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
3076	dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
3077	dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
3078
3079	set_bit(EVENT_STAT_UPDATE, addr: &dev->flags);
3080	}
3081
3082	static int lan78xx_open(struct net_device *net)
3083	{
3084	struct lan78xx_net *dev = netdev_priv(dev: net);
3085	int ret;
3086
3087	netif_dbg(dev, ifup, dev->net, "open device");
3088
3089	ret = usb_autopm_get_interface(intf: dev->intf);
3090	if (ret < 0)
3091	return ret;
3092
3093	mutex_lock(&dev->dev_mutex);
3094
3095	phy_start(phydev: net->phydev);
3096
3097	netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
3098
3099	/* for Link Check */
3100	if (dev->urb_intr) {
3101	ret = usb_submit_urb(urb: dev->urb_intr, GFP_KERNEL);
3102	if (ret < 0) {
3103	netif_err(dev, ifup, dev->net,
3104	"intr submit %d\n", ret);
3105	goto done;
3106	}
3107	}
3108
3109	ret = lan78xx_flush_rx_fifo(dev);
3110	if (ret < 0)
3111	goto done;
3112	ret = lan78xx_flush_tx_fifo(dev);
3113	if (ret < 0)
3114	goto done;
3115
3116	ret = lan78xx_start_tx_path(dev);
3117	if (ret < 0)
3118	goto done;
3119	ret = lan78xx_start_rx_path(dev);
3120	if (ret < 0)
3121	goto done;
3122
3123	lan78xx_init_stats(dev);
3124
3125	set_bit(EVENT_DEV_OPEN, addr: &dev->flags);
3126
3127	netif_start_queue(dev: net);
3128
3129	dev->link_on = false;
3130
3131	napi_enable(n: &dev->napi);
3132
3133	lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
3134	done:
3135	mutex_unlock(lock: &dev->dev_mutex);
3136
3137	usb_autopm_put_interface(intf: dev->intf);
3138
3139	return ret;
3140	}
3141
3142	static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
3143	{
3144	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
3145	DECLARE_WAITQUEUE(wait, current);
3146	int temp;
3147
3148	/* ensure there are no more active urbs */
3149	add_wait_queue(wq_head: &unlink_wakeup, wq_entry: &wait);
3150	set_current_state(TASK_UNINTERRUPTIBLE);
3151	dev->wait = &unlink_wakeup;
3152	temp = unlink_urbs(dev, q: &dev->txq) + unlink_urbs(dev, q: &dev->rxq);
3153
3154	/* maybe wait for deletions to finish. */
3155	while (!skb_queue_empty(list: &dev->rxq) ||
3156	!skb_queue_empty(list: &dev->txq)) {
3157	schedule_timeout(timeout: msecs_to_jiffies(UNLINK_TIMEOUT_MS));
3158	set_current_state(TASK_UNINTERRUPTIBLE);
3159	netif_dbg(dev, ifdown, dev->net,
3160	"waited for %d urb completions", temp);
3161	}
3162	set_current_state(TASK_RUNNING);
3163	dev->wait = NULL;
3164	remove_wait_queue(wq_head: &unlink_wakeup, wq_entry: &wait);
3165
3166	/* empty Rx done, Rx overflow and Tx pend queues
3167	*/
3168	while (!skb_queue_empty(list: &dev->rxq_done)) {
3169	struct sk_buff *skb = skb_dequeue(list: &dev->rxq_done);
3170
3171	lan78xx_release_rx_buf(dev, rx_buf: skb);
3172	}
3173
3174	skb_queue_purge(list: &dev->rxq_overflow);
3175	skb_queue_purge(list: &dev->txq_pend);
3176	}
3177
3178	static int lan78xx_stop(struct net_device *net)
3179	{
3180	struct lan78xx_net *dev = netdev_priv(dev: net);
3181
3182	netif_dbg(dev, ifup, dev->net, "stop device");
3183
3184	mutex_lock(&dev->dev_mutex);
3185
3186	if (timer_pending(timer: &dev->stat_monitor))
3187	del_timer_sync(timer: &dev->stat_monitor);
3188
3189	clear_bit(EVENT_DEV_OPEN, addr: &dev->flags);
3190	netif_stop_queue(dev: net);
3191	napi_disable(n: &dev->napi);
3192
3193	lan78xx_terminate_urbs(dev);
3194
3195	netif_info(dev, ifdown, dev->net,
3196	"stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
3197	net->stats.rx_packets, net->stats.tx_packets,
3198	net->stats.rx_errors, net->stats.tx_errors);
3199
3200	/* ignore errors that occur stopping the Tx and Rx data paths */
3201	lan78xx_stop_tx_path(dev);
3202	lan78xx_stop_rx_path(dev);
3203
3204	if (net->phydev)
3205	phy_stop(phydev: net->phydev);
3206
3207	usb_kill_urb(urb: dev->urb_intr);
3208
3209	/* deferred work (task, timer, softirq) must also stop.
3210	* can't flush_scheduled_work() until we drop rtnl (later),
3211	* else workers could deadlock; so make workers a NOP.
3212	*/
3213	clear_bit(EVENT_TX_HALT, addr: &dev->flags);
3214	clear_bit(EVENT_RX_HALT, addr: &dev->flags);
3215	clear_bit(EVENT_LINK_RESET, addr: &dev->flags);
3216	clear_bit(EVENT_STAT_UPDATE, addr: &dev->flags);
3217
3218	cancel_delayed_work_sync(dwork: &dev->wq);
3219
3220	usb_autopm_put_interface(intf: dev->intf);
3221
3222	mutex_unlock(lock: &dev->dev_mutex);
3223
3224	return 0;
3225	}
3226
3227	static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
3228	struct sk_buff_head *list, enum skb_state state)
3229	{
3230	unsigned long flags;
3231	enum skb_state old_state;
3232	struct skb_data *entry = (struct skb_data *)skb->cb;
3233
3234	spin_lock_irqsave(&list->lock, flags);
3235	old_state = entry->state;
3236	entry->state = state;
3237
3238	__skb_unlink(skb, list);
3239	spin_unlock(lock: &list->lock);
3240	spin_lock(lock: &dev->rxq_done.lock);
3241
3242	__skb_queue_tail(list: &dev->rxq_done, newsk: skb);
3243	if (skb_queue_len(list_: &dev->rxq_done) == 1)
3244	napi_schedule(n: &dev->napi);
3245
3246	spin_unlock_irqrestore(lock: &dev->rxq_done.lock, flags);
3247
3248	return old_state;
3249	}
3250
3251	static void tx_complete(struct urb *urb)
3252	{
3253	struct sk_buff *skb = (struct sk_buff *)urb->context;
3254	struct skb_data *entry = (struct skb_data *)skb->cb;
3255	struct lan78xx_net *dev = entry->dev;
3256
3257	if (urb->status == 0) {
3258	dev->net->stats.tx_packets += entry->num_of_packet;
3259	dev->net->stats.tx_bytes += entry->length;
3260	} else {
3261	dev->net->stats.tx_errors += entry->num_of_packet;
3262
3263	switch (urb->status) {
3264	case -EPIPE:
3265	lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3266	break;
3267
3268	/* software-driven interface shutdown */
3269	case -ECONNRESET:
3270	case -ESHUTDOWN:
3271	netif_dbg(dev, tx_err, dev->net,
3272	"tx err interface gone %d\n",
3273	entry->urb->status);
3274	break;
3275
3276	case -EPROTO:
3277	case -ETIME:
3278	case -EILSEQ:
3279	netif_stop_queue(dev: dev->net);
3280	netif_dbg(dev, tx_err, dev->net,
3281	"tx err queue stopped %d\n",
3282	entry->urb->status);
3283	break;
3284	default:
3285	netif_dbg(dev, tx_err, dev->net,
3286	"unknown tx err %d\n",
3287	entry->urb->status);
3288	break;
3289	}
3290	}
3291
3292	usb_autopm_put_interface_async(intf: dev->intf);
3293
3294	skb_unlink(skb, list: &dev->txq);
3295
3296	lan78xx_release_tx_buf(dev, tx_buf: skb);
3297
3298	/* Re-schedule NAPI if Tx data pending but no URBs in progress.
3299	*/
3300	if (skb_queue_empty(list: &dev->txq) &&
3301	!skb_queue_empty(list: &dev->txq_pend))
3302	napi_schedule(n: &dev->napi);
3303	}
3304
3305	static void lan78xx_queue_skb(struct sk_buff_head *list,
3306	struct sk_buff *newsk, enum skb_state state)
3307	{
3308	struct skb_data *entry = (struct skb_data *)newsk->cb;
3309
3310	__skb_queue_tail(list, newsk);
3311	entry->state = state;
3312	}
3313
3314	static unsigned int lan78xx_tx_urb_space(struct lan78xx_net *dev)
3315	{
3316	return skb_queue_len(list_: &dev->txq_free) * dev->tx_urb_size;
3317	}
3318
3319	static unsigned int lan78xx_tx_pend_data_len(struct lan78xx_net *dev)
3320	{
3321	return dev->tx_pend_data_len;
3322	}
3323
3324	static void lan78xx_tx_pend_skb_add(struct lan78xx_net *dev,
3325	struct sk_buff *skb,
3326	unsigned int *tx_pend_data_len)
3327	{
3328	unsigned long flags;
3329
3330	spin_lock_irqsave(&dev->txq_pend.lock, flags);
3331
3332	__skb_queue_tail(list: &dev->txq_pend, newsk: skb);
3333
3334	dev->tx_pend_data_len += skb->len;
3335	*tx_pend_data_len = dev->tx_pend_data_len;
3336
3337	spin_unlock_irqrestore(lock: &dev->txq_pend.lock, flags);
3338	}
3339
3340	static void lan78xx_tx_pend_skb_head_add(struct lan78xx_net *dev,
3341	struct sk_buff *skb,
3342	unsigned int *tx_pend_data_len)
3343	{
3344	unsigned long flags;
3345
3346	spin_lock_irqsave(&dev->txq_pend.lock, flags);
3347
3348	__skb_queue_head(list: &dev->txq_pend, newsk: skb);
3349
3350	dev->tx_pend_data_len += skb->len;
3351	*tx_pend_data_len = dev->tx_pend_data_len;
3352
3353	spin_unlock_irqrestore(lock: &dev->txq_pend.lock, flags);
3354	}
3355
3356	static void lan78xx_tx_pend_skb_get(struct lan78xx_net *dev,
3357	struct sk_buff **skb,
3358	unsigned int *tx_pend_data_len)
3359	{
3360	unsigned long flags;
3361
3362	spin_lock_irqsave(&dev->txq_pend.lock, flags);
3363
3364	*skb = __skb_dequeue(list: &dev->txq_pend);
3365	if (*skb)
3366	dev->tx_pend_data_len -= (*skb)->len;
3367	*tx_pend_data_len = dev->tx_pend_data_len;
3368
3369	spin_unlock_irqrestore(lock: &dev->txq_pend.lock, flags);
3370	}
3371
3372	static netdev_tx_t
3373	lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
3374	{
3375	struct lan78xx_net *dev = netdev_priv(dev: net);
3376	unsigned int tx_pend_data_len;
3377
3378	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags))
3379	schedule_delayed_work(dwork: &dev->wq, delay: 0);
3380
3381	skb_tx_timestamp(skb);
3382
3383	lan78xx_tx_pend_skb_add(dev, skb, tx_pend_data_len: &tx_pend_data_len);
3384
3385	/* Set up a Tx URB if none is in progress */
3386
3387	if (skb_queue_empty(list: &dev->txq))
3388	napi_schedule(n: &dev->napi);
3389
3390	/* Stop stack Tx queue if we have enough data to fill
3391	* all the free Tx URBs.
3392	*/
3393	if (tx_pend_data_len > lan78xx_tx_urb_space(dev)) {
3394	netif_stop_queue(dev: net);
3395
3396	netif_dbg(dev, hw, dev->net, "tx data len: %u, urb space %u",
3397	tx_pend_data_len, lan78xx_tx_urb_space(dev));
3398
3399	/* Kick off transmission of pending data */
3400
3401	if (!skb_queue_empty(list: &dev->txq_free))
3402	napi_schedule(n: &dev->napi);
3403	}
3404
3405	return NETDEV_TX_OK;
3406	}
3407
3408	static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
3409	{
3410	struct lan78xx_priv *pdata = NULL;
3411	int ret;
3412	int i;
3413
3414	dev->data[0] = (unsigned long)kzalloc(size: sizeof(*pdata), GFP_KERNEL);
3415
3416	pdata = (struct lan78xx_priv *)(dev->data[0]);
3417	if (!pdata) {
3418	netdev_warn(dev: dev->net, format: "Unable to allocate lan78xx_priv");
3419	return -ENOMEM;
3420	}
3421
3422	pdata->dev = dev;
3423
3424	spin_lock_init(&pdata->rfe_ctl_lock);
3425	mutex_init(&pdata->dataport_mutex);
3426
3427	INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
3428
3429	for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
3430	pdata->vlan_table[i] = 0;
3431
3432	INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
3433
3434	dev->net->features = 0;
3435
3436	if (DEFAULT_TX_CSUM_ENABLE)
3437	dev->net->features |= NETIF_F_HW_CSUM;
3438
3439	if (DEFAULT_RX_CSUM_ENABLE)
3440	dev->net->features |= NETIF_F_RXCSUM;
3441
3442	if (DEFAULT_TSO_CSUM_ENABLE)
3443	dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
3444
3445	if (DEFAULT_VLAN_RX_OFFLOAD)
3446	dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX;
3447
3448	if (DEFAULT_VLAN_FILTER_ENABLE)
3449	dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
3450
3451	dev->net->hw_features = dev->net->features;
3452
3453	ret = lan78xx_setup_irq_domain(dev);
3454	if (ret < 0) {
3455	netdev_warn(dev: dev->net,
3456	format: "lan78xx_setup_irq_domain() failed : %d", ret);
3457	goto out1;
3458	}
3459
3460	/* Init all registers */
3461	ret = lan78xx_reset(dev);
3462	if (ret) {
3463	netdev_warn(dev: dev->net, format: "Registers INIT FAILED....");
3464	goto out2;
3465	}
3466
3467	ret = lan78xx_mdio_init(dev);
3468	if (ret) {
3469	netdev_warn(dev: dev->net, format: "MDIO INIT FAILED.....");
3470	goto out2;
3471	}
3472
3473	dev->net->flags |= IFF_MULTICAST;
3474
3475	pdata->wol = WAKE_MAGIC;
3476
3477	return ret;
3478
3479	out2:
3480	lan78xx_remove_irq_domain(dev);
3481
3482	out1:
3483	netdev_warn(dev: dev->net, format: "Bind routine FAILED");
3484	cancel_work_sync(work: &pdata->set_multicast);
3485	cancel_work_sync(work: &pdata->set_vlan);
3486	kfree(objp: pdata);
3487	return ret;
3488	}
3489
3490	static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
3491	{
3492	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3493
3494	lan78xx_remove_irq_domain(dev);
3495
3496	lan78xx_remove_mdio(dev);
3497
3498	if (pdata) {
3499	cancel_work_sync(work: &pdata->set_multicast);
3500	cancel_work_sync(work: &pdata->set_vlan);
3501	netif_dbg(dev, ifdown, dev->net, "free pdata");
3502	kfree(objp: pdata);
3503	pdata = NULL;
3504	dev->data[0] = 0;
3505	}
3506	}
3507
3508	static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
3509	struct sk_buff *skb,
3510	u32 rx_cmd_a, u32 rx_cmd_b)
3511	{
3512	/* HW Checksum offload appears to be flawed if used when not stripping
3513	* VLAN headers. Drop back to S/W checksums under these conditions.
3514	*/
3515	if (!(dev->net->features & NETIF_F_RXCSUM) ||
3516	unlikely(rx_cmd_a & RX_CMD_A_ICSM_) ||
3517	((rx_cmd_a & RX_CMD_A_FVTG_) &&
3518	!(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) {
3519	skb->ip_summed = CHECKSUM_NONE;
3520	} else {
3521	skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
3522	skb->ip_summed = CHECKSUM_COMPLETE;
3523	}
3524	}
3525
3526	static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev,
3527	struct sk_buff *skb,
3528	u32 rx_cmd_a, u32 rx_cmd_b)
3529	{
3530	if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) &&
3531	(rx_cmd_a & RX_CMD_A_FVTG_))
3532	__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
3533	vlan_tci: (rx_cmd_b & 0xffff));
3534	}
3535
3536	static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
3537	{
3538	dev->net->stats.rx_packets++;
3539	dev->net->stats.rx_bytes += skb->len;
3540
3541	skb->protocol = eth_type_trans(skb, dev: dev->net);
3542
3543	netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
3544	skb->len + sizeof(struct ethhdr), skb->protocol);
3545	memset(skb->cb, 0, sizeof(struct skb_data));
3546
3547	if (skb_defer_rx_timestamp(skb))
3548	return;
3549
3550	napi_gro_receive(napi: &dev->napi, skb);
3551	}
3552
3553	static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb,
3554	int budget, int *work_done)
3555	{
3556	if (skb->len < RX_SKB_MIN_LEN)
3557	return 0;
3558
3559	/* Extract frames from the URB buffer and pass each one to
3560	* the stack in a new NAPI SKB.
3561	*/
3562	while (skb->len > 0) {
3563	u32 rx_cmd_a, rx_cmd_b, align_count, size;
3564	u16 rx_cmd_c;
3565	unsigned char *packet;
3566
3567	rx_cmd_a = get_unaligned_le32(p: skb->data);
3568	skb_pull(skb, len: sizeof(rx_cmd_a));
3569
3570	rx_cmd_b = get_unaligned_le32(p: skb->data);
3571	skb_pull(skb, len: sizeof(rx_cmd_b));
3572
3573	rx_cmd_c = get_unaligned_le16(p: skb->data);
3574	skb_pull(skb, len: sizeof(rx_cmd_c));
3575
3576	packet = skb->data;
3577
3578	/* get the packet length */
3579	size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
3580	align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
3581
3582	if (unlikely(size > skb->len)) {
3583	netif_dbg(dev, rx_err, dev->net,
3584	"size err rx_cmd_a=0x%08x\n",
3585	rx_cmd_a);
3586	return 0;
3587	}
3588
3589	if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
3590	netif_dbg(dev, rx_err, dev->net,
3591	"Error rx_cmd_a=0x%08x", rx_cmd_a);
3592	} else {
3593	u32 frame_len;
3594	struct sk_buff *skb2;
3595
3596	if (unlikely(size < ETH_FCS_LEN)) {
3597	netif_dbg(dev, rx_err, dev->net,
3598	"size err rx_cmd_a=0x%08x\n",
3599	rx_cmd_a);
3600	return 0;
3601	}
3602
3603	frame_len = size - ETH_FCS_LEN;
3604
3605	skb2 = napi_alloc_skb(napi: &dev->napi, length: frame_len);
3606	if (!skb2)
3607	return 0;
3608
3609	memcpy(skb2->data, packet, frame_len);
3610
3611	skb_put(skb: skb2, len: frame_len);
3612
3613	lan78xx_rx_csum_offload(dev, skb: skb2, rx_cmd_a, rx_cmd_b);
3614	lan78xx_rx_vlan_offload(dev, skb: skb2, rx_cmd_a, rx_cmd_b);
3615
3616	/* Processing of the URB buffer must complete once
3617	* it has started. If the NAPI work budget is exhausted
3618	* while frames remain they are added to the overflow
3619	* queue for delivery in the next NAPI polling cycle.
3620	*/
3621	if (*work_done < budget) {
3622	lan78xx_skb_return(dev, skb: skb2);
3623	++(*work_done);
3624	} else {
3625	skb_queue_tail(list: &dev->rxq_overflow, newsk: skb2);
3626	}
3627	}
3628
3629	skb_pull(skb, len: size);
3630
3631	/* skip padding bytes before the next frame starts */
3632	if (skb->len)
3633	skb_pull(skb, len: align_count);
3634	}
3635
3636	return 1;
3637	}
3638
3639	static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb,
3640	int budget, int *work_done)
3641	{
3642	if (!lan78xx_rx(dev, skb, budget, work_done)) {
3643	netif_dbg(dev, rx_err, dev->net, "drop\n");
3644	dev->net->stats.rx_errors++;
3645	}
3646	}
3647
3648	static void rx_complete(struct urb *urb)
3649	{
3650	struct sk_buff *skb = (struct sk_buff *)urb->context;
3651	struct skb_data *entry = (struct skb_data *)skb->cb;
3652	struct lan78xx_net *dev = entry->dev;
3653	int urb_status = urb->status;
3654	enum skb_state state;
3655
3656	netif_dbg(dev, rx_status, dev->net,
3657	"rx done: status %d", urb->status);
3658
3659	skb_put(skb, len: urb->actual_length);
3660	state = rx_done;
3661
3662	if (urb != entry->urb)
3663	netif_warn(dev, rx_err, dev->net, "URB pointer mismatch");
3664
3665	switch (urb_status) {
3666	case 0:
3667	if (skb->len < RX_SKB_MIN_LEN) {
3668	state = rx_cleanup;
3669	dev->net->stats.rx_errors++;
3670	dev->net->stats.rx_length_errors++;
3671	netif_dbg(dev, rx_err, dev->net,
3672	"rx length %d\n", skb->len);
3673	}
3674	usb_mark_last_busy(udev: dev->udev);
3675	break;
3676	case -EPIPE:
3677	dev->net->stats.rx_errors++;
3678	lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3679	fallthrough;
3680	case -ECONNRESET: /* async unlink */
3681	case -ESHUTDOWN: /* hardware gone */
3682	netif_dbg(dev, ifdown, dev->net,
3683	"rx shutdown, code %d\n", urb_status);
3684	state = rx_cleanup;
3685	break;
3686	case -EPROTO:
3687	case -ETIME:
3688	case -EILSEQ:
3689	dev->net->stats.rx_errors++;
3690	state = rx_cleanup;
3691	break;
3692
3693	/* data overrun ... flush fifo? */
3694	case -EOVERFLOW:
3695	dev->net->stats.rx_over_errors++;
3696	fallthrough;
3697
3698	default:
3699	state = rx_cleanup;
3700	dev->net->stats.rx_errors++;
3701	netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3702	break;
3703	}
3704
3705	state = defer_bh(dev, skb, list: &dev->rxq, state);
3706	}
3707
3708	static int rx_submit(struct lan78xx_net *dev, struct sk_buff *skb, gfp_t flags)
3709	{
3710	struct skb_data *entry = (struct skb_data *)skb->cb;
3711	size_t size = dev->rx_urb_size;
3712	struct urb *urb = entry->urb;
3713	unsigned long lockflags;
3714	int ret = 0;
3715
3716	usb_fill_bulk_urb(urb, dev: dev->udev, pipe: dev->pipe_in,
3717	transfer_buffer: skb->data, buffer_length: size, complete_fn: rx_complete, context: skb);
3718
3719	spin_lock_irqsave(&dev->rxq.lock, lockflags);
3720
3721	if (netif_device_present(dev: dev->net) &&
3722	netif_running(dev: dev->net) &&
3723	!test_bit(EVENT_RX_HALT, &dev->flags) &&
3724	!test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3725	ret = usb_submit_urb(urb, mem_flags: flags);
3726	switch (ret) {
3727	case 0:
3728	lan78xx_queue_skb(list: &dev->rxq, newsk: skb, state: rx_start);
3729	break;
3730	case -EPIPE:
3731	lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3732	break;
3733	case -ENODEV:
3734	case -ENOENT:
3735	netif_dbg(dev, ifdown, dev->net, "device gone\n");
3736	netif_device_detach(dev: dev->net);
3737	break;
3738	case -EHOSTUNREACH:
3739	ret = -ENOLINK;
3740	napi_schedule(n: &dev->napi);
3741	break;
3742	default:
3743	netif_dbg(dev, rx_err, dev->net,
3744	"rx submit, %d\n", ret);
3745	napi_schedule(n: &dev->napi);
3746	break;
3747	}
3748	} else {
3749	netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3750	ret = -ENOLINK;
3751	}
3752	spin_unlock_irqrestore(lock: &dev->rxq.lock, flags: lockflags);
3753
3754	if (ret)
3755	lan78xx_release_rx_buf(dev, rx_buf: skb);
3756
3757	return ret;
3758	}
3759
3760	static void lan78xx_rx_urb_submit_all(struct lan78xx_net *dev)
3761	{
3762	struct sk_buff *rx_buf;
3763
3764	/* Ensure the maximum number of Rx URBs is submitted
3765	*/
3766	while ((rx_buf = lan78xx_get_rx_buf(dev)) != NULL) {
3767	if (rx_submit(dev, skb: rx_buf, GFP_ATOMIC) != 0)
3768	break;
3769	}
3770	}
3771
3772	static void lan78xx_rx_urb_resubmit(struct lan78xx_net *dev,
3773	struct sk_buff *rx_buf)
3774	{
3775	/* reset SKB data pointers */
3776
3777	rx_buf->data = rx_buf->head;
3778	skb_reset_tail_pointer(skb: rx_buf);
3779	rx_buf->len = 0;
3780	rx_buf->data_len = 0;
3781
3782	rx_submit(dev, skb: rx_buf, GFP_ATOMIC);
3783	}
3784
3785	static void lan78xx_fill_tx_cmd_words(struct sk_buff *skb, u8 *buffer)
3786	{
3787	u32 tx_cmd_a;
3788	u32 tx_cmd_b;
3789
3790	tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
3791
3792	if (skb->ip_summed == CHECKSUM_PARTIAL)
3793	tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
3794
3795	tx_cmd_b = 0;
3796	if (skb_is_gso(skb)) {
3797	u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
3798
3799	tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
3800
3801	tx_cmd_a |= TX_CMD_A_LSO_;
3802	}
3803
3804	if (skb_vlan_tag_present(skb)) {
3805	tx_cmd_a |= TX_CMD_A_IVTG_;
3806	tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
3807	}
3808
3809	put_unaligned_le32(val: tx_cmd_a, p: buffer);
3810	put_unaligned_le32(val: tx_cmd_b, p: buffer + 4);
3811	}
3812
3813	static struct skb_data *lan78xx_tx_buf_fill(struct lan78xx_net *dev,
3814	struct sk_buff *tx_buf)
3815	{
3816	struct skb_data *entry = (struct skb_data *)tx_buf->cb;
3817	int remain = dev->tx_urb_size;
3818	u8 *tx_data = tx_buf->data;
3819	u32 urb_len = 0;
3820
3821	entry->num_of_packet = 0;
3822	entry->length = 0;
3823
3824	/* Work through the pending SKBs and copy the data of each SKB into
3825	* the URB buffer if there room for all the SKB data.
3826	*
3827	* There must be at least DST+SRC+TYPE in the SKB (with padding enabled)
3828	*/
3829	while (remain >= TX_SKB_MIN_LEN) {
3830	unsigned int pending_bytes;
3831	unsigned int align_bytes;
3832	struct sk_buff *skb;
3833	unsigned int len;
3834
3835	lan78xx_tx_pend_skb_get(dev, skb: &skb, tx_pend_data_len: &pending_bytes);
3836
3837	if (!skb)
3838	break;
3839
3840	align_bytes = (TX_ALIGNMENT - (urb_len % TX_ALIGNMENT)) %
3841	TX_ALIGNMENT;
3842	len = align_bytes + TX_CMD_LEN + skb->len;
3843	if (len > remain) {
3844	lan78xx_tx_pend_skb_head_add(dev, skb, tx_pend_data_len: &pending_bytes);
3845	break;
3846	}
3847
3848	tx_data += align_bytes;
3849
3850	lan78xx_fill_tx_cmd_words(skb, buffer: tx_data);
3851	tx_data += TX_CMD_LEN;
3852
3853	len = skb->len;
3854	if (skb_copy_bits(skb, offset: 0, to: tx_data, len) < 0) {
3855	struct net_device_stats *stats = &dev->net->stats;
3856
3857	stats->tx_dropped++;
3858	dev_kfree_skb_any(skb);
3859	tx_data -= TX_CMD_LEN;
3860	continue;
3861	}
3862
3863	tx_data += len;
3864	entry->length += len;
3865	entry->num_of_packet += skb_shinfo(skb)->gso_segs ?: 1;
3866
3867	dev_kfree_skb_any(skb);
3868
3869	urb_len = (u32)(tx_data - (u8 *)tx_buf->data);
3870
3871	remain = dev->tx_urb_size - urb_len;
3872	}
3873
3874	skb_put(skb: tx_buf, len: urb_len);
3875
3876	return entry;
3877	}
3878
3879	static void lan78xx_tx_bh(struct lan78xx_net *dev)
3880	{
3881	int ret;
3882
3883	/* Start the stack Tx queue if it was stopped
3884	*/
3885	netif_tx_lock(dev: dev->net);
3886	if (netif_queue_stopped(dev: dev->net)) {
3887	if (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev))
3888	netif_wake_queue(dev: dev->net);
3889	}
3890	netif_tx_unlock(dev: dev->net);
3891
3892	/* Go through the Tx pending queue and set up URBs to transfer
3893	* the data to the device. Stop if no more pending data or URBs,
3894	* or if an error occurs when a URB is submitted.
3895	*/
3896	do {
3897	struct skb_data *entry;
3898	struct sk_buff *tx_buf;
3899	unsigned long flags;
3900
3901	if (skb_queue_empty(list: &dev->txq_pend))
3902	break;
3903
3904	tx_buf = lan78xx_get_tx_buf(dev);
3905	if (!tx_buf)
3906	break;
3907
3908	entry = lan78xx_tx_buf_fill(dev, tx_buf);
3909
3910	spin_lock_irqsave(&dev->txq.lock, flags);
3911	ret = usb_autopm_get_interface_async(intf: dev->intf);
3912	if (ret < 0) {
3913	spin_unlock_irqrestore(lock: &dev->txq.lock, flags);
3914	goto out;
3915	}
3916
3917	usb_fill_bulk_urb(urb: entry->urb, dev: dev->udev, pipe: dev->pipe_out,
3918	transfer_buffer: tx_buf->data, buffer_length: tx_buf->len, complete_fn: tx_complete,
3919	context: tx_buf);
3920
3921	if (tx_buf->len % dev->maxpacket == 0) {
3922	/* send USB_ZERO_PACKET */
3923	entry->urb->transfer_flags |= URB_ZERO_PACKET;
3924	}
3925
3926	#ifdef CONFIG_PM
3927	/* if device is asleep stop outgoing packet processing */
3928	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3929	usb_anchor_urb(urb: entry->urb, anchor: &dev->deferred);
3930	netif_stop_queue(dev: dev->net);
3931	spin_unlock_irqrestore(lock: &dev->txq.lock, flags);
3932	netdev_dbg(dev->net,
3933	"Delaying transmission for resumption\n");
3934	return;
3935	}
3936	#endif
3937	ret = usb_submit_urb(urb: entry->urb, GFP_ATOMIC);
3938	switch (ret) {
3939	case 0:
3940	netif_trans_update(dev: dev->net);
3941	lan78xx_queue_skb(list: &dev->txq, newsk: tx_buf, state: tx_start);
3942	break;
3943	case -EPIPE:
3944	netif_stop_queue(dev: dev->net);
3945	lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3946	usb_autopm_put_interface_async(intf: dev->intf);
3947	break;
3948	case -ENODEV:
3949	case -ENOENT:
3950	netif_dbg(dev, tx_err, dev->net,
3951	"tx submit urb err %d (disconnected?)", ret);
3952	netif_device_detach(dev: dev->net);
3953	break;
3954	default:
3955	usb_autopm_put_interface_async(intf: dev->intf);
3956	netif_dbg(dev, tx_err, dev->net,
3957	"tx submit urb err %d\n", ret);
3958	break;
3959	}
3960
3961	spin_unlock_irqrestore(lock: &dev->txq.lock, flags);
3962
3963	if (ret) {
3964	netdev_warn(dev: dev->net, format: "failed to tx urb %d\n", ret);
3965	out:
3966	dev->net->stats.tx_dropped += entry->num_of_packet;
3967	lan78xx_release_tx_buf(dev, tx_buf);
3968	}
3969	} while (ret == 0);
3970	}
3971
3972	static int lan78xx_bh(struct lan78xx_net *dev, int budget)
3973	{
3974	struct sk_buff_head done;
3975	struct sk_buff *rx_buf;
3976	struct skb_data *entry;
3977	unsigned long flags;
3978	int work_done = 0;
3979
3980	/* Pass frames received in the last NAPI cycle before
3981	* working on newly completed URBs.
3982	*/
3983	while (!skb_queue_empty(list: &dev->rxq_overflow)) {
3984	lan78xx_skb_return(dev, skb: skb_dequeue(list: &dev->rxq_overflow));
3985	++work_done;
3986	}
3987
3988	/* Take a snapshot of the done queue and move items to a
3989	* temporary queue. Rx URB completions will continue to add
3990	* to the done queue.
3991	*/
3992	__skb_queue_head_init(list: &done);
3993
3994	spin_lock_irqsave(&dev->rxq_done.lock, flags);
3995	skb_queue_splice_init(list: &dev->rxq_done, head: &done);
3996	spin_unlock_irqrestore(lock: &dev->rxq_done.lock, flags);
3997
3998	/* Extract receive frames from completed URBs and
3999	* pass them to the stack. Re-submit each completed URB.
4000	*/
4001	while ((work_done < budget) &&
4002	(rx_buf = __skb_dequeue(list: &done))) {
4003	entry = (struct skb_data *)(rx_buf->cb);
4004	switch (entry->state) {
4005	case rx_done:
4006	rx_process(dev, skb: rx_buf, budget, work_done: &work_done);
4007	break;
4008	case rx_cleanup:
4009	break;
4010	default:
4011	netdev_dbg(dev->net, "rx buf state %d\n",
4012	entry->state);
4013	break;
4014	}
4015
4016	lan78xx_rx_urb_resubmit(dev, rx_buf);
4017	}
4018
4019	/* If budget was consumed before processing all the URBs put them
4020	* back on the front of the done queue. They will be first to be
4021	* processed in the next NAPI cycle.
4022	*/
4023	spin_lock_irqsave(&dev->rxq_done.lock, flags);
4024	skb_queue_splice(list: &done, head: &dev->rxq_done);
4025	spin_unlock_irqrestore(lock: &dev->rxq_done.lock, flags);
4026
4027	if (netif_device_present(dev: dev->net) && netif_running(dev: dev->net)) {
4028	/* reset update timer delta */
4029	if (timer_pending(timer: &dev->stat_monitor) && (dev->delta != 1)) {
4030	dev->delta = 1;
4031	mod_timer(timer: &dev->stat_monitor,
4032	expires: jiffies + STAT_UPDATE_TIMER);
4033	}
4034
4035	/* Submit all free Rx URBs */
4036
4037	if (!test_bit(EVENT_RX_HALT, &dev->flags))
4038	lan78xx_rx_urb_submit_all(dev);
4039
4040	/* Submit new Tx URBs */
4041
4042	lan78xx_tx_bh(dev);
4043	}
4044
4045	return work_done;
4046	}
4047
4048	static int lan78xx_poll(struct napi_struct *napi, int budget)
4049	{
4050	struct lan78xx_net *dev = container_of(napi, struct lan78xx_net, napi);
4051	int result = budget;
4052	int work_done;
4053
4054	/* Don't do any work if the device is suspended */
4055
4056	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
4057	napi_complete_done(n: napi, work_done: 0);
4058	return 0;
4059	}
4060
4061	/* Process completed URBs and submit new URBs */
4062
4063	work_done = lan78xx_bh(dev, budget);
4064
4065	if (work_done < budget) {
4066	napi_complete_done(n: napi, work_done);
4067
4068	/* Start a new polling cycle if data was received or
4069	* data is waiting to be transmitted.
4070	*/
4071	if (!skb_queue_empty(list: &dev->rxq_done)) {
4072	napi_schedule(n: napi);
4073	} else if (netif_carrier_ok(dev: dev->net)) {
4074	if (skb_queue_empty(list: &dev->txq) &&
4075	!skb_queue_empty(list: &dev->txq_pend)) {
4076	napi_schedule(n: napi);
4077	} else {
4078	netif_tx_lock(dev: dev->net);
4079	if (netif_queue_stopped(dev: dev->net)) {
4080	netif_wake_queue(dev: dev->net);
4081	napi_schedule(n: napi);
4082	}
4083	netif_tx_unlock(dev: dev->net);
4084	}
4085	}
4086	result = work_done;
4087	}
4088
4089	return result;
4090	}
4091
4092	static void lan78xx_delayedwork(struct work_struct *work)
4093	{
4094	int status;
4095	struct lan78xx_net *dev;
4096
4097	dev = container_of(work, struct lan78xx_net, wq.work);
4098
4099	if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
4100	return;
4101
4102	if (usb_autopm_get_interface(intf: dev->intf) < 0)
4103	return;
4104
4105	if (test_bit(EVENT_TX_HALT, &dev->flags)) {
4106	unlink_urbs(dev, q: &dev->txq);
4107
4108	status = usb_clear_halt(dev: dev->udev, pipe: dev->pipe_out);
4109	if (status < 0 &&
4110	status != -EPIPE &&
4111	status != -ESHUTDOWN) {
4112	if (netif_msg_tx_err(dev))
4113	netdev_err(dev: dev->net,
4114	format: "can't clear tx halt, status %d\n",
4115	status);
4116	} else {
4117	clear_bit(EVENT_TX_HALT, addr: &dev->flags);
4118	if (status != -ESHUTDOWN)
4119	netif_wake_queue(dev: dev->net);
4120	}
4121	}
4122
4123	if (test_bit(EVENT_RX_HALT, &dev->flags)) {
4124	unlink_urbs(dev, q: &dev->rxq);
4125	status = usb_clear_halt(dev: dev->udev, pipe: dev->pipe_in);
4126	if (status < 0 &&
4127	status != -EPIPE &&
4128	status != -ESHUTDOWN) {
4129	if (netif_msg_rx_err(dev))
4130	netdev_err(dev: dev->net,
4131	format: "can't clear rx halt, status %d\n",
4132	status);
4133	} else {
4134	clear_bit(EVENT_RX_HALT, addr: &dev->flags);
4135	napi_schedule(n: &dev->napi);
4136	}
4137	}
4138
4139	if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
4140	int ret = 0;
4141
4142	clear_bit(EVENT_LINK_RESET, addr: &dev->flags);
4143	if (lan78xx_link_reset(dev) < 0) {
4144	netdev_info(dev: dev->net, format: "link reset failed (%d)\n",
4145	ret);
4146	}
4147	}
4148
4149	if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
4150	lan78xx_update_stats(dev);
4151
4152	clear_bit(EVENT_STAT_UPDATE, addr: &dev->flags);
4153
4154	mod_timer(timer: &dev->stat_monitor,
4155	expires: jiffies + (STAT_UPDATE_TIMER * dev->delta));
4156
4157	dev->delta = min((dev->delta * 2), 50);
4158	}
4159
4160	usb_autopm_put_interface(intf: dev->intf);
4161	}
4162
4163	static void intr_complete(struct urb *urb)
4164	{
4165	struct lan78xx_net *dev = urb->context;
4166	int status = urb->status;
4167
4168	switch (status) {
4169	/* success */
4170	case 0:
4171	lan78xx_status(dev, urb);
4172	break;
4173
4174	/* software-driven interface shutdown */
4175	case -ENOENT: /* urb killed */
4176	case -ENODEV: /* hardware gone */
4177	case -ESHUTDOWN: /* hardware gone */
4178	netif_dbg(dev, ifdown, dev->net,
4179	"intr shutdown, code %d\n", status);
4180	return;
4181
4182	/* NOTE: not throttling like RX/TX, since this endpoint
4183	* already polls infrequently
4184	*/
4185	default:
4186	netdev_dbg(dev->net, "intr status %d\n", status);
4187	break;
4188	}
4189
4190	if (!netif_device_present(dev: dev->net) ||
4191	!netif_running(dev: dev->net)) {
4192	netdev_warn(dev: dev->net, format: "not submitting new status URB");
4193	return;
4194	}
4195
4196	memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
4197	status = usb_submit_urb(urb, GFP_ATOMIC);
4198
4199	switch (status) {
4200	case 0:
4201	break;
4202	case -ENODEV:
4203	case -ENOENT:
4204	netif_dbg(dev, timer, dev->net,
4205	"intr resubmit %d (disconnect?)", status);
4206	netif_device_detach(dev: dev->net);
4207	break;
4208	default:
4209	netif_err(dev, timer, dev->net,
4210	"intr resubmit --> %d\n", status);
4211	break;
4212	}
4213	}
4214
4215	static void lan78xx_disconnect(struct usb_interface *intf)
4216	{
4217	struct lan78xx_net *dev;
4218	struct usb_device *udev;
4219	struct net_device *net;
4220	struct phy_device *phydev;
4221
4222	dev = usb_get_intfdata(intf);
4223	usb_set_intfdata(intf, NULL);
4224	if (!dev)
4225	return;
4226
4227	netif_napi_del(napi: &dev->napi);
4228
4229	udev = interface_to_usbdev(intf);
4230	net = dev->net;
4231
4232	unregister_netdev(dev: net);
4233
4234	timer_shutdown_sync(timer: &dev->stat_monitor);
4235	set_bit(EVENT_DEV_DISCONNECT, addr: &dev->flags);
4236	cancel_delayed_work_sync(dwork: &dev->wq);
4237
4238	phydev = net->phydev;
4239
4240	phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, phy_uid_mask: 0xfffffff0);
4241	phy_unregister_fixup_for_uid(PHY_LAN8835, phy_uid_mask: 0xfffffff0);
4242
4243	phy_disconnect(phydev: net->phydev);
4244
4245	if (phy_is_pseudo_fixed_link(phydev))
4246	fixed_phy_unregister(phydev);
4247
4248	usb_scuttle_anchored_urbs(anchor: &dev->deferred);
4249
4250	lan78xx_unbind(dev, intf);
4251
4252	lan78xx_free_tx_resources(dev);
4253	lan78xx_free_rx_resources(dev);
4254
4255	usb_kill_urb(urb: dev->urb_intr);
4256	usb_free_urb(urb: dev->urb_intr);
4257
4258	free_netdev(dev: net);
4259	usb_put_dev(dev: udev);
4260	}
4261
4262	static void lan78xx_tx_timeout(struct net_device *net, unsigned int txqueue)
4263	{
4264	struct lan78xx_net *dev = netdev_priv(dev: net);
4265
4266	unlink_urbs(dev, q: &dev->txq);
4267	napi_schedule(n: &dev->napi);
4268	}
4269
4270	static netdev_features_t lan78xx_features_check(struct sk_buff *skb,
4271	struct net_device *netdev,
4272	netdev_features_t features)
4273	{
4274	struct lan78xx_net *dev = netdev_priv(dev: netdev);
4275
4276	if (skb->len > LAN78XX_TSO_SIZE(dev))
4277	features &= ~NETIF_F_GSO_MASK;
4278
4279	features = vlan_features_check(skb, features);
4280	features = vxlan_features_check(skb, features);
4281
4282	return features;
4283	}
4284
4285	static const struct net_device_ops lan78xx_netdev_ops = {
4286	.ndo_open = lan78xx_open,
4287	.ndo_stop = lan78xx_stop,
4288	.ndo_start_xmit = lan78xx_start_xmit,
4289	.ndo_tx_timeout = lan78xx_tx_timeout,
4290	.ndo_change_mtu = lan78xx_change_mtu,
4291	.ndo_set_mac_address = lan78xx_set_mac_addr,
4292	.ndo_validate_addr = eth_validate_addr,
4293	.ndo_eth_ioctl = phy_do_ioctl_running,
4294	.ndo_set_rx_mode = lan78xx_set_multicast,
4295	.ndo_set_features = lan78xx_set_features,
4296	.ndo_vlan_rx_add_vid = lan78xx_vlan_rx_add_vid,
4297	.ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid,
4298	.ndo_features_check = lan78xx_features_check,
4299	};
4300
4301	static void lan78xx_stat_monitor(struct timer_list *t)
4302	{
4303	struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
4304
4305	lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
4306	}
4307
4308	static int lan78xx_probe(struct usb_interface *intf,
4309	const struct usb_device_id *id)
4310	{
4311	struct usb_host_endpoint *ep_blkin, *ep_blkout, *ep_intr;
4312	struct lan78xx_net *dev;
4313	struct net_device *netdev;
4314	struct usb_device *udev;
4315	int ret;
4316	unsigned int maxp;
4317	unsigned int period;
4318	u8 *buf = NULL;
4319
4320	udev = interface_to_usbdev(intf);
4321	udev = usb_get_dev(dev: udev);
4322
4323	netdev = alloc_etherdev(sizeof(struct lan78xx_net));
4324	if (!netdev) {
4325	dev_err(&intf->dev, "Error: OOM\n");
4326	ret = -ENOMEM;
4327	goto out1;
4328	}
4329
4330	/* netdev_printk() needs this */
4331	SET_NETDEV_DEV(netdev, &intf->dev);
4332
4333	dev = netdev_priv(dev: netdev);
4334	dev->udev = udev;
4335	dev->intf = intf;
4336	dev->net = netdev;
4337	dev->msg_enable = netif_msg_init(debug_value: msg_level, NETIF_MSG_DRV
4338	| NETIF_MSG_PROBE | NETIF_MSG_LINK);
4339
4340	skb_queue_head_init(list: &dev->rxq);
4341	skb_queue_head_init(list: &dev->txq);
4342	skb_queue_head_init(list: &dev->rxq_done);
4343	skb_queue_head_init(list: &dev->txq_pend);
4344	skb_queue_head_init(list: &dev->rxq_overflow);
4345	mutex_init(&dev->phy_mutex);
4346	mutex_init(&dev->dev_mutex);
4347
4348	ret = lan78xx_urb_config_init(dev);
4349	if (ret < 0)
4350	goto out2;
4351
4352	ret = lan78xx_alloc_tx_resources(dev);
4353	if (ret < 0)
4354	goto out2;
4355
4356	ret = lan78xx_alloc_rx_resources(dev);
4357	if (ret < 0)
4358	goto out3;
4359
4360	/* MTU range: 68 - 9000 */
4361	netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
4362
4363	netif_set_tso_max_size(dev: netdev, LAN78XX_TSO_SIZE(dev));
4364
4365	netif_napi_add(dev: netdev, napi: &dev->napi, poll: lan78xx_poll);
4366
4367	INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
4368	init_usb_anchor(anchor: &dev->deferred);
4369
4370	netdev->netdev_ops = &lan78xx_netdev_ops;
4371	netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
4372	netdev->ethtool_ops = &lan78xx_ethtool_ops;
4373
4374	dev->delta = 1;
4375	timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
4376
4377	mutex_init(&dev->stats.access_lock);
4378
4379	if (intf->cur_altsetting->desc.bNumEndpoints < 3) {
4380	ret = -ENODEV;
4381	goto out4;
4382	}
4383
4384	dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
4385	ep_blkin = usb_pipe_endpoint(dev: udev, pipe: dev->pipe_in);
4386	if (!ep_blkin || !usb_endpoint_is_bulk_in(epd: &ep_blkin->desc)) {
4387	ret = -ENODEV;
4388	goto out4;
4389	}
4390
4391	dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
4392	ep_blkout = usb_pipe_endpoint(dev: udev, pipe: dev->pipe_out);
4393	if (!ep_blkout || !usb_endpoint_is_bulk_out(epd: &ep_blkout->desc)) {
4394	ret = -ENODEV;
4395	goto out4;
4396	}
4397
4398	ep_intr = &intf->cur_altsetting->endpoint[2];
4399	if (!usb_endpoint_is_int_in(epd: &ep_intr->desc)) {
4400	ret = -ENODEV;
4401	goto out4;
4402	}
4403
4404	dev->pipe_intr = usb_rcvintpipe(dev->udev,
4405	usb_endpoint_num(&ep_intr->desc));
4406
4407	ret = lan78xx_bind(dev, intf);
4408	if (ret < 0)
4409	goto out4;
4410
4411	period = ep_intr->desc.bInterval;
4412	maxp = usb_maxpacket(udev: dev->udev, pipe: dev->pipe_intr);
4413	buf = kmalloc(size: maxp, GFP_KERNEL);
4414	if (!buf) {
4415	ret = -ENOMEM;
4416	goto out5;
4417	}
4418
4419	dev->urb_intr = usb_alloc_urb(iso_packets: 0, GFP_KERNEL);
4420	if (!dev->urb_intr) {
4421	ret = -ENOMEM;
4422	goto out6;
4423	} else {
4424	usb_fill_int_urb(urb: dev->urb_intr, dev: dev->udev,
4425	pipe: dev->pipe_intr, transfer_buffer: buf, buffer_length: maxp,
4426	complete_fn: intr_complete, context: dev, interval: period);
4427	dev->urb_intr->transfer_flags |= URB_FREE_BUFFER;
4428	}
4429
4430	dev->maxpacket = usb_maxpacket(udev: dev->udev, pipe: dev->pipe_out);
4431
4432	/* Reject broken descriptors. */
4433	if (dev->maxpacket == 0) {
4434	ret = -ENODEV;
4435	goto out6;
4436	}
4437
4438	/* driver requires remote-wakeup capability during autosuspend. */
4439	intf->needs_remote_wakeup = 1;
4440
4441	ret = lan78xx_phy_init(dev);
4442	if (ret < 0)
4443	goto out7;
4444
4445	ret = register_netdev(dev: netdev);
4446	if (ret != 0) {
4447	netif_err(dev, probe, netdev, "couldn't register the device\n");
4448	goto out8;
4449	}
4450
4451	usb_set_intfdata(intf, data: dev);
4452
4453	ret = device_set_wakeup_enable(dev: &udev->dev, enable: true);
4454
4455	/* Default delay of 2sec has more overhead than advantage.
4456	* Set to 10sec as default.
4457	*/
4458	pm_runtime_set_autosuspend_delay(dev: &udev->dev,
4459	DEFAULT_AUTOSUSPEND_DELAY);
4460
4461	return 0;
4462
4463	out8:
4464	phy_disconnect(phydev: netdev->phydev);
4465	out7:
4466	usb_free_urb(urb: dev->urb_intr);
4467	out6:
4468	kfree(objp: buf);
4469	out5:
4470	lan78xx_unbind(dev, intf);
4471	out4:
4472	netif_napi_del(napi: &dev->napi);
4473	lan78xx_free_rx_resources(dev);
4474	out3:
4475	lan78xx_free_tx_resources(dev);
4476	out2:
4477	free_netdev(dev: netdev);
4478	out1:
4479	usb_put_dev(dev: udev);
4480
4481	return ret;
4482	}
4483
4484	static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
4485	{
4486	const u16 crc16poly = 0x8005;
4487	int i;
4488	u16 bit, crc, msb;
4489	u8 data;
4490
4491	crc = 0xFFFF;
4492	for (i = 0; i < len; i++) {
4493	data = *buf++;
4494	for (bit = 0; bit < 8; bit++) {
4495	msb = crc >> 15;
4496	crc <<= 1;
4497
4498	if (msb ^ (u16)(data & 1)) {
4499	crc ^= crc16poly;
4500	crc |= (u16)0x0001U;
4501	}
4502	data >>= 1;
4503	}
4504	}
4505
4506	return crc;
4507	}
4508
4509	static int lan78xx_set_auto_suspend(struct lan78xx_net *dev)
4510	{
4511	u32 buf;
4512	int ret;
4513
4514	ret = lan78xx_stop_tx_path(dev);
4515	if (ret < 0)
4516	return ret;
4517
4518	ret = lan78xx_stop_rx_path(dev);
4519	if (ret < 0)
4520	return ret;
4521
4522	/* auto suspend (selective suspend) */
4523
4524	ret = lan78xx_write_reg(dev, WUCSR, data: 0);
4525	if (ret < 0)
4526	return ret;
4527	ret = lan78xx_write_reg(dev, WUCSR2, data: 0);
4528	if (ret < 0)
4529	return ret;
4530	ret = lan78xx_write_reg(dev, WK_SRC, data: 0xFFF1FF1FUL);
4531	if (ret < 0)
4532	return ret;
4533
4534	/* set goodframe wakeup */
4535
4536	ret = lan78xx_read_reg(dev, WUCSR, data: &buf);
4537	if (ret < 0)
4538	return ret;
4539
4540	buf |= WUCSR_RFE_WAKE_EN_;
4541	buf |= WUCSR_STORE_WAKE_;
4542
4543	ret = lan78xx_write_reg(dev, WUCSR, data: buf);
4544	if (ret < 0)
4545	return ret;
4546
4547	ret = lan78xx_read_reg(dev, PMT_CTL, data: &buf);
4548	if (ret < 0)
4549	return ret;
4550
4551	buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4552	buf |= PMT_CTL_RES_CLR_WKP_STS_;
4553	buf |= PMT_CTL_PHY_WAKE_EN_;
4554	buf |= PMT_CTL_WOL_EN_;
4555	buf &= ~PMT_CTL_SUS_MODE_MASK_;
4556	buf |= PMT_CTL_SUS_MODE_3_;
4557
4558	ret = lan78xx_write_reg(dev, PMT_CTL, data: buf);
4559	if (ret < 0)
4560	return ret;
4561
4562	ret = lan78xx_read_reg(dev, PMT_CTL, data: &buf);
4563	if (ret < 0)
4564	return ret;
4565
4566	buf |= PMT_CTL_WUPS_MASK_;
4567
4568	ret = lan78xx_write_reg(dev, PMT_CTL, data: buf);
4569	if (ret < 0)
4570	return ret;
4571
4572	ret = lan78xx_start_rx_path(dev);
4573
4574	return ret;
4575	}
4576
4577	static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
4578	{
4579	const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
4580	const u8 ipv6_multicast[3] = { 0x33, 0x33 };
4581	const u8 arp_type[2] = { 0x08, 0x06 };
4582	u32 temp_pmt_ctl;
4583	int mask_index;
4584	u32 temp_wucsr;
4585	u32 buf;
4586	u16 crc;
4587	int ret;
4588
4589	ret = lan78xx_stop_tx_path(dev);
4590	if (ret < 0)
4591	return ret;
4592	ret = lan78xx_stop_rx_path(dev);
4593	if (ret < 0)
4594	return ret;
4595
4596	ret = lan78xx_write_reg(dev, WUCSR, data: 0);
4597	if (ret < 0)
4598	return ret;
4599	ret = lan78xx_write_reg(dev, WUCSR2, data: 0);
4600	if (ret < 0)
4601	return ret;
4602	ret = lan78xx_write_reg(dev, WK_SRC, data: 0xFFF1FF1FUL);
4603	if (ret < 0)
4604	return ret;
4605
4606	temp_wucsr = 0;
4607
4608	temp_pmt_ctl = 0;
4609
4610	ret = lan78xx_read_reg(dev, PMT_CTL, data: &temp_pmt_ctl);
4611	if (ret < 0)
4612	return ret;
4613
4614	temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
4615	temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
4616
4617	for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++) {
4618	ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), data: 0);
4619	if (ret < 0)
4620	return ret;
4621	}
4622
4623	mask_index = 0;
4624	if (wol & WAKE_PHY) {
4625	temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
4626
4627	temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4628	temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4629	temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4630	}
4631	if (wol & WAKE_MAGIC) {
4632	temp_wucsr |= WUCSR_MPEN_;
4633
4634	temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4635	temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4636	temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
4637	}
4638	if (wol & WAKE_BCAST) {
4639	temp_wucsr |= WUCSR_BCST_EN_;
4640
4641	temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4642	temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4643	temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4644	}
4645	if (wol & WAKE_MCAST) {
4646	temp_wucsr |= WUCSR_WAKE_EN_;
4647
4648	/* set WUF_CFG & WUF_MASK for IPv4 Multicast */
4649	crc = lan78xx_wakeframe_crc16(buf: ipv4_multicast, len: 3);
4650	ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4651	WUF_CFGX_EN_ |
4652	WUF_CFGX_TYPE_MCAST_ |
4653	(0 << WUF_CFGX_OFFSET_SHIFT_) |
4654	(crc & WUF_CFGX_CRC16_MASK_));
4655	if (ret < 0)
4656	return ret;
4657
4658	ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), data: 7);
4659	if (ret < 0)
4660	return ret;
4661	ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), data: 0);
4662	if (ret < 0)
4663	return ret;
4664	ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), data: 0);
4665	if (ret < 0)
4666	return ret;
4667	ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), data: 0);
4668	if (ret < 0)
4669	return ret;
4670
4671	mask_index++;
4672
4673	/* for IPv6 Multicast */
4674	crc = lan78xx_wakeframe_crc16(buf: ipv6_multicast, len: 2);
4675	ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4676	WUF_CFGX_EN_ |
4677	WUF_CFGX_TYPE_MCAST_ |
4678	(0 << WUF_CFGX_OFFSET_SHIFT_) |
4679	(crc & WUF_CFGX_CRC16_MASK_));
4680	if (ret < 0)
4681	return ret;
4682
4683	ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), data: 3);
4684	if (ret < 0)
4685	return ret;
4686	ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), data: 0);
4687	if (ret < 0)
4688	return ret;
4689	ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), data: 0);
4690	if (ret < 0)
4691	return ret;
4692	ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), data: 0);
4693	if (ret < 0)
4694	return ret;
4695
4696	mask_index++;
4697
4698	temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4699	temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4700	temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4701	}
4702	if (wol & WAKE_UCAST) {
4703	temp_wucsr |= WUCSR_PFDA_EN_;
4704
4705	temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4706	temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4707	temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4708	}
4709	if (wol & WAKE_ARP) {
4710	temp_wucsr |= WUCSR_WAKE_EN_;
4711
4712	/* set WUF_CFG & WUF_MASK
4713	* for packettype (offset 12,13) = ARP (0x0806)
4714	*/
4715	crc = lan78xx_wakeframe_crc16(buf: arp_type, len: 2);
4716	ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4717	WUF_CFGX_EN_ |
4718	WUF_CFGX_TYPE_ALL_ |
4719	(0 << WUF_CFGX_OFFSET_SHIFT_) |
4720	(crc & WUF_CFGX_CRC16_MASK_));
4721	if (ret < 0)
4722	return ret;
4723
4724	ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), data: 0x3000);
4725	if (ret < 0)
4726	return ret;
4727	ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), data: 0);
4728	if (ret < 0)
4729	return ret;
4730	ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), data: 0);
4731	if (ret < 0)
4732	return ret;
4733	ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), data: 0);
4734	if (ret < 0)
4735	return ret;
4736
4737	mask_index++;
4738
4739	temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4740	temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4741	temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4742	}
4743
4744	ret = lan78xx_write_reg(dev, WUCSR, data: temp_wucsr);
4745	if (ret < 0)
4746	return ret;
4747
4748	/* when multiple WOL bits are set */
4749	if (hweight_long(w: (unsigned long)wol) > 1) {
4750	temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4751	temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4752	temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4753	}
4754	ret = lan78xx_write_reg(dev, PMT_CTL, data: temp_pmt_ctl);
4755	if (ret < 0)
4756	return ret;
4757
4758	/* clear WUPS */
4759	ret = lan78xx_read_reg(dev, PMT_CTL, data: &buf);
4760	if (ret < 0)
4761	return ret;
4762
4763	buf |= PMT_CTL_WUPS_MASK_;
4764
4765	ret = lan78xx_write_reg(dev, PMT_CTL, data: buf);
4766	if (ret < 0)
4767	return ret;
4768
4769	ret = lan78xx_start_rx_path(dev);
4770
4771	return ret;
4772	}
4773
4774	static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
4775	{
4776	struct lan78xx_net *dev = usb_get_intfdata(intf);
4777	bool dev_open;
4778	int ret;
4779
4780	mutex_lock(&dev->dev_mutex);
4781
4782	netif_dbg(dev, ifdown, dev->net,
4783	"suspending: pm event %#x", message.event);
4784
4785	dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);
4786
4787	if (dev_open) {
4788	spin_lock_irq(lock: &dev->txq.lock);
4789	/* don't autosuspend while transmitting */
4790	if ((skb_queue_len(list_: &dev->txq) ||
4791	skb_queue_len(list_: &dev->txq_pend)) &&
4792	PMSG_IS_AUTO(message)) {
4793	spin_unlock_irq(lock: &dev->txq.lock);
4794	ret = -EBUSY;
4795	goto out;
4796	} else {
4797	set_bit(EVENT_DEV_ASLEEP, addr: &dev->flags);
4798	spin_unlock_irq(lock: &dev->txq.lock);
4799	}
4800
4801	/* stop RX */
4802	ret = lan78xx_stop_rx_path(dev);
4803	if (ret < 0)
4804	goto out;
4805
4806	ret = lan78xx_flush_rx_fifo(dev);
4807	if (ret < 0)
4808	goto out;
4809
4810	/* stop Tx */
4811	ret = lan78xx_stop_tx_path(dev);
4812	if (ret < 0)
4813	goto out;
4814
4815	/* empty out the Rx and Tx queues */
4816	netif_device_detach(dev: dev->net);
4817	lan78xx_terminate_urbs(dev);
4818	usb_kill_urb(urb: dev->urb_intr);
4819
4820	/* reattach */
4821	netif_device_attach(dev: dev->net);
4822
4823	del_timer(timer: &dev->stat_monitor);
4824
4825	if (PMSG_IS_AUTO(message)) {
4826	ret = lan78xx_set_auto_suspend(dev);
4827	if (ret < 0)
4828	goto out;
4829	} else {
4830	struct lan78xx_priv *pdata;
4831
4832	pdata = (struct lan78xx_priv *)(dev->data[0]);
4833	netif_carrier_off(dev: dev->net);
4834	ret = lan78xx_set_suspend(dev, wol: pdata->wol);
4835	if (ret < 0)
4836	goto out;
4837	}
4838	} else {
4839	/* Interface is down; don't allow WOL and PHY
4840	* events to wake up the host
4841	*/
4842	u32 buf;
4843
4844	set_bit(EVENT_DEV_ASLEEP, addr: &dev->flags);
4845
4846	ret = lan78xx_write_reg(dev, WUCSR, data: 0);
4847	if (ret < 0)
4848	goto out;
4849	ret = lan78xx_write_reg(dev, WUCSR2, data: 0);
4850	if (ret < 0)
4851	goto out;
4852
4853	ret = lan78xx_read_reg(dev, PMT_CTL, data: &buf);
4854	if (ret < 0)
4855	goto out;
4856
4857	buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4858	buf |= PMT_CTL_RES_CLR_WKP_STS_;
4859	buf &= ~PMT_CTL_SUS_MODE_MASK_;
4860	buf |= PMT_CTL_SUS_MODE_3_;
4861
4862	ret = lan78xx_write_reg(dev, PMT_CTL, data: buf);
4863	if (ret < 0)
4864	goto out;
4865
4866	ret = lan78xx_read_reg(dev, PMT_CTL, data: &buf);
4867	if (ret < 0)
4868	goto out;
4869
4870	buf |= PMT_CTL_WUPS_MASK_;
4871
4872	ret = lan78xx_write_reg(dev, PMT_CTL, data: buf);
4873	if (ret < 0)
4874	goto out;
4875	}
4876
4877	ret = 0;
4878	out:
4879	mutex_unlock(lock: &dev->dev_mutex);
4880
4881	return ret;
4882	}
4883
4884	static bool lan78xx_submit_deferred_urbs(struct lan78xx_net *dev)
4885	{
4886	bool pipe_halted = false;
4887	struct urb *urb;
4888
4889	while ((urb = usb_get_from_anchor(anchor: &dev->deferred))) {
4890	struct sk_buff *skb = urb->context;
4891	int ret;
4892
4893	if (!netif_device_present(dev: dev->net) ||
4894	!netif_carrier_ok(dev: dev->net) ||
4895	pipe_halted) {
4896	lan78xx_release_tx_buf(dev, tx_buf: skb);
4897	continue;
4898	}
4899
4900	ret = usb_submit_urb(urb, GFP_ATOMIC);
4901
4902	if (ret == 0) {
4903	netif_trans_update(dev: dev->net);
4904	lan78xx_queue_skb(list: &dev->txq, newsk: skb, state: tx_start);
4905	} else {
4906	if (ret == -EPIPE) {
4907	netif_stop_queue(dev: dev->net);
4908	pipe_halted = true;
4909	} else if (ret == -ENODEV) {
4910	netif_device_detach(dev: dev->net);
4911	}
4912
4913	lan78xx_release_tx_buf(dev, tx_buf: skb);
4914	}
4915	}
4916
4917	return pipe_halted;
4918	}
4919
4920	static int lan78xx_resume(struct usb_interface *intf)
4921	{
4922	struct lan78xx_net *dev = usb_get_intfdata(intf);
4923	bool dev_open;
4924	int ret;
4925
4926	mutex_lock(&dev->dev_mutex);
4927
4928	netif_dbg(dev, ifup, dev->net, "resuming device");
4929
4930	dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);
4931
4932	if (dev_open) {
4933	bool pipe_halted = false;
4934
4935	ret = lan78xx_flush_tx_fifo(dev);
4936	if (ret < 0)
4937	goto out;
4938
4939	if (dev->urb_intr) {
4940	int ret = usb_submit_urb(urb: dev->urb_intr, GFP_KERNEL);
4941
4942	if (ret < 0) {
4943	if (ret == -ENODEV)
4944	netif_device_detach(dev: dev->net);
4945	netdev_warn(dev: dev->net, format: "Failed to submit intr URB");
4946	}
4947	}
4948
4949	spin_lock_irq(lock: &dev->txq.lock);
4950
4951	if (netif_device_present(dev: dev->net)) {
4952	pipe_halted = lan78xx_submit_deferred_urbs(dev);
4953
4954	if (pipe_halted)
4955	lan78xx_defer_kevent(dev, EVENT_TX_HALT);
4956	}
4957
4958	clear_bit(EVENT_DEV_ASLEEP, addr: &dev->flags);
4959
4960	spin_unlock_irq(lock: &dev->txq.lock);
4961
4962	if (!pipe_halted &&
4963	netif_device_present(dev: dev->net) &&
4964	(lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev)))
4965	netif_start_queue(dev: dev->net);
4966
4967	ret = lan78xx_start_tx_path(dev);
4968	if (ret < 0)
4969	goto out;
4970
4971	napi_schedule(n: &dev->napi);
4972
4973	if (!timer_pending(timer: &dev->stat_monitor)) {
4974	dev->delta = 1;
4975	mod_timer(timer: &dev->stat_monitor,
4976	expires: jiffies + STAT_UPDATE_TIMER);
4977	}
4978
4979	} else {
4980	clear_bit(EVENT_DEV_ASLEEP, addr: &dev->flags);
4981	}
4982
4983	ret = lan78xx_write_reg(dev, WUCSR2, data: 0);
4984	if (ret < 0)
4985	goto out;
4986	ret = lan78xx_write_reg(dev, WUCSR, data: 0);
4987	if (ret < 0)
4988	goto out;
4989	ret = lan78xx_write_reg(dev, WK_SRC, data: 0xFFF1FF1FUL);
4990	if (ret < 0)
4991	goto out;
4992
4993	ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
4994	WUCSR2_ARP_RCD_ |
4995	WUCSR2_IPV6_TCPSYN_RCD_ |
4996	WUCSR2_IPV4_TCPSYN_RCD_);
4997	if (ret < 0)
4998	goto out;
4999
5000	ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
5001	WUCSR_EEE_RX_WAKE_ |
5002	WUCSR_PFDA_FR_ |
5003	WUCSR_RFE_WAKE_FR_ |
5004	WUCSR_WUFR_ |
5005	WUCSR_MPR_ |
5006	WUCSR_BCST_FR_);
5007	if (ret < 0)
5008	goto out;
5009
5010	ret = 0;
5011	out:
5012	mutex_unlock(lock: &dev->dev_mutex);
5013
5014	return ret;
5015	}
5016
5017	static int lan78xx_reset_resume(struct usb_interface *intf)
5018	{
5019	struct lan78xx_net *dev = usb_get_intfdata(intf);
5020	int ret;
5021
5022	netif_dbg(dev, ifup, dev->net, "(reset) resuming device");
5023
5024	ret = lan78xx_reset(dev);
5025	if (ret < 0)
5026	return ret;
5027
5028	phy_start(phydev: dev->net->phydev);
5029
5030	ret = lan78xx_resume(intf);
5031
5032	return ret;
5033	}
5034
5035	static const struct usb_device_id products[] = {
5036	{
5037	/* LAN7800 USB Gigabit Ethernet Device */
5038	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
5039	},
5040	{
5041	/* LAN7850 USB Gigabit Ethernet Device */
5042	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
5043	},
5044	{
5045	/* LAN7801 USB Gigabit Ethernet Device */
5046	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
5047	},
5048	{
5049	/* ATM2-AF USB Gigabit Ethernet Device */
5050	USB_DEVICE(AT29M2AF_USB_VENDOR_ID, AT29M2AF_USB_PRODUCT_ID),
5051	},
5052	{},
5053	};
5054	MODULE_DEVICE_TABLE(usb, products);
5055
5056	static struct usb_driver lan78xx_driver = {
5057	.name = DRIVER_NAME,
5058	.id_table = products,
5059	.probe = lan78xx_probe,
5060	.disconnect = lan78xx_disconnect,
5061	.suspend = lan78xx_suspend,
5062	.resume = lan78xx_resume,
5063	.reset_resume = lan78xx_reset_resume,
5064	.supports_autosuspend = 1,
5065	.disable_hub_initiated_lpm = 1,
5066	};
5067
5068	module_usb_driver(lan78xx_driver);
5069
5070	MODULE_AUTHOR(DRIVER_AUTHOR);
5071	MODULE_DESCRIPTION(DRIVER_DESC);
5072	MODULE_LICENSE("GPL");
5073