1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* USB Network driver infrastructure
4	* Copyright (C) 2000-2005 by David Brownell
5	* Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
6	*/
7
8	/*
9	* This is a generic "USB networking" framework that works with several
10	* kinds of full and high speed networking devices: host-to-host cables,
11	* smart usb peripherals, and actual Ethernet adapters.
12	*
13	* These devices usually differ in terms of control protocols (if they
14	* even have one!) and sometimes they define new framing to wrap or batch
15	* Ethernet packets. Otherwise, they talk to USB pretty much the same,
16	* so interface (un)binding, endpoint I/O queues, fault handling, and other
17	* issues can usefully be addressed by this framework.
18	*/
19
20	#include <linux/module.h>
21	#include <linux/init.h>
22	#include <linux/netdevice.h>
23	#include <linux/etherdevice.h>
24	#include <linux/ctype.h>
25	#include <linux/ethtool.h>
26	#include <linux/workqueue.h>
27	#include <linux/mii.h>
28	#include <linux/usb.h>
29	#include <linux/usb/usbnet.h>
30	#include <linux/slab.h>
31	#include <linux/kernel.h>
32	#include <linux/pm_runtime.h>
33
34	/*-------------------------------------------------------------------------*/
35
36	/*
37	* Nineteen USB 1.1 max size bulk transactions per frame (ms), max.
38	* Several dozen bytes of IPv4 data can fit in two such transactions.
39	* One maximum size Ethernet packet takes twenty four of them.
40	* For high speed, each frame comfortably fits almost 36 max size
41	* Ethernet packets (so queues should be bigger).
42	*
43	* The goal is to let the USB host controller be busy for 5msec or
44	* more before an irq is required, under load. Jumbograms change
45	* the equation.
46	*/
47	#define MAX_QUEUE_MEMORY (60 * 1518)
48	#define RX_QLEN(dev) ((dev)->rx_qlen)
49	#define TX_QLEN(dev) ((dev)->tx_qlen)
50
51	// reawaken network queue this soon after stopping; else watchdog barks
52	#define TX_TIMEOUT_JIFFIES (5*HZ)
53
54	/* throttle rx/tx briefly after some faults, so hub_wq might disconnect()
55	* us (it polls at HZ/4 usually) before we report too many false errors.
56	*/
57	#define THROTTLE_JIFFIES (HZ/8)
58
59	// between wakeups
60	#define UNLINK_TIMEOUT_MS 3
61
62	/*-------------------------------------------------------------------------*/
63
64	// randomly generated ethernet address
65	static u8 node_id [ETH_ALEN];
66
67	/* use ethtool to change the level for any given device */
68	static int msg_level = -1;
69	module_param (msg_level, int, 0);
70	MODULE_PARM_DESC (msg_level, "Override default message level");
71
72	/*-------------------------------------------------------------------------*/
73
74	static const char * const usbnet_event_names[] = {
75	[EVENT_TX_HALT] = "EVENT_TX_HALT",
76	[EVENT_RX_HALT] = "EVENT_RX_HALT",
77	[EVENT_RX_MEMORY] = "EVENT_RX_MEMORY",
78	[EVENT_STS_SPLIT] = "EVENT_STS_SPLIT",
79	[EVENT_LINK_RESET] = "EVENT_LINK_RESET",
80	[EVENT_RX_PAUSED] = "EVENT_RX_PAUSED",
81	[EVENT_DEV_ASLEEP] = "EVENT_DEV_ASLEEP",
82	[EVENT_DEV_OPEN] = "EVENT_DEV_OPEN",
83	[EVENT_DEVICE_REPORT_IDLE] = "EVENT_DEVICE_REPORT_IDLE",
84	[EVENT_NO_RUNTIME_PM] = "EVENT_NO_RUNTIME_PM",
85	[EVENT_RX_KILL] = "EVENT_RX_KILL",
86	[EVENT_LINK_CHANGE] = "EVENT_LINK_CHANGE",
87	[EVENT_SET_RX_MODE] = "EVENT_SET_RX_MODE",
88	[EVENT_NO_IP_ALIGN] = "EVENT_NO_IP_ALIGN",
89	};
90
91	/* handles CDC Ethernet and many other network "bulk data" interfaces */
92	int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
93	{
94	int tmp;
95	struct usb_host_interface *alt = NULL;
96	struct usb_host_endpoint *in = NULL, *out = NULL;
97	struct usb_host_endpoint *status = NULL;
98
99	for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
100	unsigned ep;
101
102	in = out = status = NULL;
103	alt = intf->altsetting + tmp;
104
105	/* take the first altsetting with in-bulk + out-bulk;
106	* remember any status endpoint, just in case;
107	* ignore other endpoints and altsettings.
108	*/
109	for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
110	struct usb_host_endpoint *e;
111	int intr = 0;
112
113	e = alt->endpoint + ep;
114
115	/* ignore endpoints which cannot transfer data */
116	if (!usb_endpoint_maxp(epd: &e->desc))
117	continue;
118
119	switch (e->desc.bmAttributes) {
120	case USB_ENDPOINT_XFER_INT:
121	if (!usb_endpoint_dir_in(epd: &e->desc))
122	continue;
123	intr = 1;
124	fallthrough;
125	case USB_ENDPOINT_XFER_BULK:
126	break;
127	default:
128	continue;
129	}
130	if (usb_endpoint_dir_in(epd: &e->desc)) {
131	if (!intr && !in)
132	in = e;
133	else if (intr && !status)
134	status = e;
135	} else {
136	if (!out)
137	out = e;
138	}
139	}
140	if (in && out)
141	break;
142	}
143	if (!alt || !in || !out)
144	return -EINVAL;
145
146	if (alt->desc.bAlternateSetting != 0 ||
147	!(dev->driver_info->flags & FLAG_NO_SETINT)) {
148	tmp = usb_set_interface (dev: dev->udev, ifnum: alt->desc.bInterfaceNumber,
149	alternate: alt->desc.bAlternateSetting);
150	if (tmp < 0)
151	return tmp;
152	}
153
154	dev->in = usb_rcvbulkpipe (dev->udev,
155	in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
156	dev->out = usb_sndbulkpipe (dev->udev,
157	out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
158	dev->status = status;
159	return 0;
160	}
161	EXPORT_SYMBOL_GPL(usbnet_get_endpoints);
162
163	int usbnet_get_ethernet_addr(struct usbnet *dev, int iMACAddress)
164	{
165	u8 addr[ETH_ALEN];
166	int tmp = -1, ret;
167	unsigned char buf [13];
168
169	ret = usb_string(dev: dev->udev, index: iMACAddress, buf, size: sizeof buf);
170	if (ret == 12)
171	tmp = hex2bin(dst: addr, src: buf, count: 6);
172	if (tmp < 0) {
173	dev_dbg(&dev->udev->dev,
174	"bad MAC string %d fetch, %d\n", iMACAddress, tmp);
175	if (ret >= 0)
176	ret = -EINVAL;
177	return ret;
178	}
179	eth_hw_addr_set(dev: dev->net, addr);
180	return 0;
181	}
182	EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr);
183
184	static void intr_complete (struct urb *urb)
185	{
186	struct usbnet *dev = urb->context;
187	int status = urb->status;
188
189	switch (status) {
190	/* success */
191	case 0:
192	dev->driver_info->status(dev, urb);
193	break;
194
195	/* software-driven interface shutdown */
196	case -ENOENT: /* urb killed */
197	case -ESHUTDOWN: /* hardware gone */
198	netif_dbg(dev, ifdown, dev->net,
199	"intr shutdown, code %d\n", status);
200	return;
201
202	/* NOTE: not throttling like RX/TX, since this endpoint
203	* already polls infrequently
204	*/
205	default:
206	netdev_dbg(dev->net, "intr status %d\n", status);
207	break;
208	}
209
210	status = usb_submit_urb (urb, GFP_ATOMIC);
211	if (status != 0)
212	netif_err(dev, timer, dev->net,
213	"intr resubmit --> %d\n", status);
214	}
215
216	static int init_status (struct usbnet *dev, struct usb_interface *intf)
217	{
218	char *buf = NULL;
219	unsigned pipe = 0;
220	unsigned maxp;
221	unsigned period;
222
223	if (!dev->driver_info->status)
224	return 0;
225
226	pipe = usb_rcvintpipe (dev->udev,
227	dev->status->desc.bEndpointAddress
228	& USB_ENDPOINT_NUMBER_MASK);
229	maxp = usb_maxpacket(udev: dev->udev, pipe);
230
231	/* avoid 1 msec chatter: min 8 msec poll rate */
232	period = max ((int) dev->status->desc.bInterval,
233	(dev->udev->speed == USB_SPEED_HIGH) ? 7 : 3);
234
235	buf = kmalloc (size: maxp, GFP_KERNEL);
236	if (buf) {
237	dev->interrupt = usb_alloc_urb (iso_packets: 0, GFP_KERNEL);
238	if (!dev->interrupt) {
239	kfree (objp: buf);
240	return -ENOMEM;
241	} else {
242	usb_fill_int_urb(urb: dev->interrupt, dev: dev->udev, pipe,
243	transfer_buffer: buf, buffer_length: maxp, complete_fn: intr_complete, context: dev, interval: period);
244	dev->interrupt->transfer_flags |= URB_FREE_BUFFER;
245	dev_dbg(&intf->dev,
246	"status ep%din, %d bytes period %d\n",
247	usb_pipeendpoint(pipe), maxp, period);
248	}
249	}
250	return 0;
251	}
252
253	/* Submit the interrupt URB if not previously submitted, increasing refcount */
254	int usbnet_status_start(struct usbnet *dev, gfp_t mem_flags)
255	{
256	int ret = 0;
257
258	WARN_ON_ONCE(dev->interrupt == NULL);
259	if (dev->interrupt) {
260	mutex_lock(&dev->interrupt_mutex);
261
262	if (++dev->interrupt_count == 1)
263	ret = usb_submit_urb(urb: dev->interrupt, mem_flags);
264
265	dev_dbg(&dev->udev->dev, "incremented interrupt URB count to %d\n",
266	dev->interrupt_count);
267	mutex_unlock(lock: &dev->interrupt_mutex);
268	}
269	return ret;
270	}
271	EXPORT_SYMBOL_GPL(usbnet_status_start);
272
273	/* For resume; submit interrupt URB if previously submitted */
274	static int __usbnet_status_start_force(struct usbnet *dev, gfp_t mem_flags)
275	{
276	int ret = 0;
277
278	mutex_lock(&dev->interrupt_mutex);
279	if (dev->interrupt_count) {
280	ret = usb_submit_urb(urb: dev->interrupt, mem_flags);
281	dev_dbg(&dev->udev->dev,
282	"submitted interrupt URB for resume\n");
283	}
284	mutex_unlock(lock: &dev->interrupt_mutex);
285	return ret;
286	}
287
288	/* Kill the interrupt URB if all submitters want it killed */
289	void usbnet_status_stop(struct usbnet *dev)
290	{
291	if (dev->interrupt) {
292	mutex_lock(&dev->interrupt_mutex);
293	WARN_ON(dev->interrupt_count == 0);
294
295	if (dev->interrupt_count && --dev->interrupt_count == 0)
296	usb_kill_urb(urb: dev->interrupt);
297
298	dev_dbg(&dev->udev->dev,
299	"decremented interrupt URB count to %d\n",
300	dev->interrupt_count);
301	mutex_unlock(lock: &dev->interrupt_mutex);
302	}
303	}
304	EXPORT_SYMBOL_GPL(usbnet_status_stop);
305
306	/* For suspend; always kill interrupt URB */
307	static void __usbnet_status_stop_force(struct usbnet *dev)
308	{
309	if (dev->interrupt) {
310	mutex_lock(&dev->interrupt_mutex);
311	usb_kill_urb(urb: dev->interrupt);
312	dev_dbg(&dev->udev->dev, "killed interrupt URB for suspend\n");
313	mutex_unlock(lock: &dev->interrupt_mutex);
314	}
315	}
316
317	/* Passes this packet up the stack, updating its accounting.
318	* Some link protocols batch packets, so their rx_fixup paths
319	* can return clones as well as just modify the original skb.
320	*/
321	void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
322	{
323	struct pcpu_sw_netstats *stats64 = this_cpu_ptr(dev->net->tstats);
324	unsigned long flags;
325	int status;
326
327	if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
328	skb_queue_tail(list: &dev->rxq_pause, newsk: skb);
329	return;
330	}
331
332	/* only update if unset to allow minidriver rx_fixup override */
333	if (skb->protocol == 0)
334	skb->protocol = eth_type_trans (skb, dev: dev->net);
335
336	flags = u64_stats_update_begin_irqsave(syncp: &stats64->syncp);
337	u64_stats_inc(p: &stats64->rx_packets);
338	u64_stats_add(p: &stats64->rx_bytes, val: skb->len);
339	u64_stats_update_end_irqrestore(syncp: &stats64->syncp, flags);
340
341	netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
342	skb->len + sizeof (struct ethhdr), skb->protocol);
343	memset (skb->cb, 0, sizeof (struct skb_data));
344
345	if (skb_defer_rx_timestamp(skb))
346	return;
347
348	status = netif_rx (skb);
349	if (status != NET_RX_SUCCESS)
350	netif_dbg(dev, rx_err, dev->net,
351	"netif_rx status %d\n", status);
352	}
353	EXPORT_SYMBOL_GPL(usbnet_skb_return);
354
355	/* must be called if hard_mtu or rx_urb_size changed */
356	void usbnet_update_max_qlen(struct usbnet *dev)
357	{
358	enum usb_device_speed speed = dev->udev->speed;
359
360	if (!dev->rx_urb_size || !dev->hard_mtu)
361	goto insanity;
362	switch (speed) {
363	case USB_SPEED_HIGH:
364	dev->rx_qlen = MAX_QUEUE_MEMORY / dev->rx_urb_size;
365	dev->tx_qlen = MAX_QUEUE_MEMORY / dev->hard_mtu;
366	break;
367	case USB_SPEED_SUPER:
368	case USB_SPEED_SUPER_PLUS:
369	/*
370	* Not take default 5ms qlen for super speed HC to
371	* save memory, and iperf tests show 2.5ms qlen can
372	* work well
373	*/
374	dev->rx_qlen = 5 * MAX_QUEUE_MEMORY / dev->rx_urb_size;
375	dev->tx_qlen = 5 * MAX_QUEUE_MEMORY / dev->hard_mtu;
376	break;
377	default:
378	insanity:
379	dev->rx_qlen = dev->tx_qlen = 4;
380	}
381	}
382	EXPORT_SYMBOL_GPL(usbnet_update_max_qlen);
383
384
385	/*-------------------------------------------------------------------------
386	*
387	* Network Device Driver (peer link to "Host Device", from USB host)
388	*
389	*-------------------------------------------------------------------------*/
390
391	int usbnet_change_mtu (struct net_device *net, int new_mtu)
392	{
393	struct usbnet *dev = netdev_priv(dev: net);
394	int ll_mtu = new_mtu + net->hard_header_len;
395	int old_hard_mtu = dev->hard_mtu;
396	int old_rx_urb_size = dev->rx_urb_size;
397
398	// no second zero-length packet read wanted after mtu-sized packets
399	if ((ll_mtu % dev->maxpacket) == 0)
400	return -EDOM;
401	net->mtu = new_mtu;
402
403	dev->hard_mtu = net->mtu + net->hard_header_len;
404	if (dev->rx_urb_size == old_hard_mtu) {
405	dev->rx_urb_size = dev->hard_mtu;
406	if (dev->rx_urb_size > old_rx_urb_size) {
407	usbnet_pause_rx(dev);
408	usbnet_unlink_rx_urbs(dev);
409	usbnet_resume_rx(dev);
410	}
411	}
412
413	/* max qlen depend on hard_mtu and rx_urb_size */
414	usbnet_update_max_qlen(dev);
415
416	return 0;
417	}
418	EXPORT_SYMBOL_GPL(usbnet_change_mtu);
419
420	/* The caller must hold list->lock */
421	static void __usbnet_queue_skb(struct sk_buff_head *list,
422	struct sk_buff *newsk, enum skb_state state)
423	{
424	struct skb_data *entry = (struct skb_data *) newsk->cb;
425
426	__skb_queue_tail(list, newsk);
427	entry->state = state;
428	}
429
430	/*-------------------------------------------------------------------------*/
431
432	/* some LK 2.4 HCDs oopsed if we freed or resubmitted urbs from
433	* completion callbacks. 2.5 should have fixed those bugs...
434	*/
435
436	static enum skb_state defer_bh(struct usbnet *dev, struct sk_buff *skb,
437	struct sk_buff_head *list, enum skb_state state)
438	{
439	unsigned long flags;
440	enum skb_state old_state;
441	struct skb_data *entry = (struct skb_data *) skb->cb;
442
443	spin_lock_irqsave(&list->lock, flags);
444	old_state = entry->state;
445	entry->state = state;
446	__skb_unlink(skb, list);
447
448	/* defer_bh() is never called with list == &dev->done.
449	* spin_lock_nested() tells lockdep that it is OK to take
450	* dev->done.lock here with list->lock held.
451	*/
452	spin_lock_nested(&dev->done.lock, SINGLE_DEPTH_NESTING);
453
454	__skb_queue_tail(list: &dev->done, newsk: skb);
455	if (dev->done.qlen == 1)
456	tasklet_schedule(t: &dev->bh);
457	spin_unlock(lock: &dev->done.lock);
458	spin_unlock_irqrestore(lock: &list->lock, flags);
459	return old_state;
460	}
461
462	/* some work can't be done in tasklets, so we use keventd
463	*
464	* NOTE: annoying asymmetry: if it's active, schedule_work() fails,
465	* but tasklet_schedule() doesn't. hope the failure is rare.
466	*/
467	void usbnet_defer_kevent (struct usbnet *dev, int work)
468	{
469	set_bit (nr: work, addr: &dev->flags);
470	if (!schedule_work (work: &dev->kevent))
471	netdev_dbg(dev->net, "kevent %s may have been dropped\n", usbnet_event_names[work]);
472	else
473	netdev_dbg(dev->net, "kevent %s scheduled\n", usbnet_event_names[work]);
474	}
475	EXPORT_SYMBOL_GPL(usbnet_defer_kevent);
476
477	/*-------------------------------------------------------------------------*/
478
479	static void rx_complete (struct urb *urb);
480
481	static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
482	{
483	struct sk_buff *skb;
484	struct skb_data *entry;
485	int retval = 0;
486	unsigned long lockflags;
487	size_t size = dev->rx_urb_size;
488
489	/* prevent rx skb allocation when error ratio is high */
490	if (test_bit(EVENT_RX_KILL, &dev->flags)) {
491	usb_free_urb(urb);
492	return -ENOLINK;
493	}
494
495	if (test_bit(EVENT_NO_IP_ALIGN, &dev->flags))
496	skb = __netdev_alloc_skb(dev: dev->net, length: size, gfp_mask: flags);
497	else
498	skb = __netdev_alloc_skb_ip_align(dev: dev->net, length: size, gfp: flags);
499	if (!skb) {
500	netif_dbg(dev, rx_err, dev->net, "no rx skb\n");
501	usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
502	usb_free_urb (urb);
503	return -ENOMEM;
504	}
505
506	entry = (struct skb_data *) skb->cb;
507	entry->urb = urb;
508	entry->dev = dev;
509	entry->length = 0;
510
511	usb_fill_bulk_urb (urb, dev: dev->udev, pipe: dev->in,
512	transfer_buffer: skb->data, buffer_length: size, complete_fn: rx_complete, context: skb);
513
514	spin_lock_irqsave (&dev->rxq.lock, lockflags);
515
516	if (netif_running (dev: dev->net) &&
517	netif_device_present (dev: dev->net) &&
518	test_bit(EVENT_DEV_OPEN, &dev->flags) &&
519	!test_bit (EVENT_RX_HALT, &dev->flags) &&
520	!test_bit (EVENT_DEV_ASLEEP, &dev->flags)) {
521	switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {
522	case -EPIPE:
523	usbnet_defer_kevent (dev, EVENT_RX_HALT);
524	break;
525	case -ENOMEM:
526	usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
527	break;
528	case -ENODEV:
529	netif_dbg(dev, ifdown, dev->net, "device gone\n");
530	netif_device_detach (dev: dev->net);
531	break;
532	case -EHOSTUNREACH:
533	retval = -ENOLINK;
534	break;
535	default:
536	netif_dbg(dev, rx_err, dev->net,
537	"rx submit, %d\n", retval);
538	tasklet_schedule (t: &dev->bh);
539	break;
540	case 0:
541	__usbnet_queue_skb(list: &dev->rxq, newsk: skb, state: rx_start);
542	}
543	} else {
544	netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
545	retval = -ENOLINK;
546	}
547	spin_unlock_irqrestore (lock: &dev->rxq.lock, flags: lockflags);
548	if (retval) {
549	dev_kfree_skb_any (skb);
550	usb_free_urb (urb);
551	}
552	return retval;
553	}
554
555
556	/*-------------------------------------------------------------------------*/
557
558	static inline int rx_process(struct usbnet *dev, struct sk_buff *skb)
559	{
560	if (dev->driver_info->rx_fixup &&
561	!dev->driver_info->rx_fixup (dev, skb)) {
562	/* With RX_ASSEMBLE, rx_fixup() must update counters */
563	if (!(dev->driver_info->flags & FLAG_RX_ASSEMBLE))
564	dev->net->stats.rx_errors++;
565	return -EPROTO;
566	}
567	// else network stack removes extra byte if we forced a short packet
568
569	/* all data was already cloned from skb inside the driver */
570	if (dev->driver_info->flags & FLAG_MULTI_PACKET)
571	return -EALREADY;
572
573	if (skb->len < ETH_HLEN) {
574	dev->net->stats.rx_errors++;
575	dev->net->stats.rx_length_errors++;
576	netif_dbg(dev, rx_err, dev->net, "rx length %d\n", skb->len);
577	return -EPROTO;
578	}
579
580	usbnet_skb_return(dev, skb);
581	return 0;
582	}
583
584	/*-------------------------------------------------------------------------*/
585
586	static void rx_complete (struct urb *urb)
587	{
588	struct sk_buff *skb = (struct sk_buff *) urb->context;
589	struct skb_data *entry = (struct skb_data *) skb->cb;
590	struct usbnet *dev = entry->dev;
591	int urb_status = urb->status;
592	enum skb_state state;
593
594	skb_put (skb, len: urb->actual_length);
595	state = rx_done;
596	entry->urb = NULL;
597
598	switch (urb_status) {
599	/* success */
600	case 0:
601	break;
602
603	/* stalls need manual reset. this is rare ... except that
604	* when going through USB 2.0 TTs, unplug appears this way.
605	* we avoid the highspeed version of the ETIMEDOUT/EILSEQ
606	* storm, recovering as needed.
607	*/
608	case -EPIPE:
609	dev->net->stats.rx_errors++;
610	usbnet_defer_kevent (dev, EVENT_RX_HALT);
611	fallthrough;
612
613	/* software-driven interface shutdown */
614	case -ECONNRESET: /* async unlink */
615	case -ESHUTDOWN: /* hardware gone */
616	netif_dbg(dev, ifdown, dev->net,
617	"rx shutdown, code %d\n", urb_status);
618	goto block;
619
620	/* we get controller i/o faults during hub_wq disconnect() delays.
621	* throttle down resubmits, to avoid log floods; just temporarily,
622	* so we still recover when the fault isn't a hub_wq delay.
623	*/
624	case -EPROTO:
625	case -ETIME:
626	case -EILSEQ:
627	dev->net->stats.rx_errors++;
628	if (!timer_pending (timer: &dev->delay)) {
629	mod_timer (timer: &dev->delay, expires: jiffies + THROTTLE_JIFFIES);
630	netif_dbg(dev, link, dev->net,
631	"rx throttle %d\n", urb_status);
632	}
633	block:
634	state = rx_cleanup;
635	entry->urb = urb;
636	urb = NULL;
637	break;
638
639	/* data overrun ... flush fifo? */
640	case -EOVERFLOW:
641	dev->net->stats.rx_over_errors++;
642	fallthrough;
643
644	default:
645	state = rx_cleanup;
646	dev->net->stats.rx_errors++;
647	netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
648	break;
649	}
650
651	/* stop rx if packet error rate is high */
652	if (++dev->pkt_cnt > 30) {
653	dev->pkt_cnt = 0;
654	dev->pkt_err = 0;
655	} else {
656	if (state == rx_cleanup)
657	dev->pkt_err++;
658	if (dev->pkt_err > 20)
659	set_bit(EVENT_RX_KILL, addr: &dev->flags);
660	}
661
662	state = defer_bh(dev, skb, list: &dev->rxq, state);
663
664	if (urb) {
665	if (netif_running (dev: dev->net) &&
666	!test_bit (EVENT_RX_HALT, &dev->flags) &&
667	state != unlink_start) {
668	rx_submit (dev, urb, GFP_ATOMIC);
669	usb_mark_last_busy(udev: dev->udev);
670	return;
671	}
672	usb_free_urb (urb);
673	}
674	netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
675	}
676
677	/*-------------------------------------------------------------------------*/
678	void usbnet_pause_rx(struct usbnet *dev)
679	{
680	set_bit(EVENT_RX_PAUSED, addr: &dev->flags);
681
682	netif_dbg(dev, rx_status, dev->net, "paused rx queue enabled\n");
683	}
684	EXPORT_SYMBOL_GPL(usbnet_pause_rx);
685
686	void usbnet_resume_rx(struct usbnet *dev)
687	{
688	struct sk_buff *skb;
689	int num = 0;
690
691	clear_bit(EVENT_RX_PAUSED, addr: &dev->flags);
692
693	while ((skb = skb_dequeue(list: &dev->rxq_pause)) != NULL) {
694	usbnet_skb_return(dev, skb);
695	num++;
696	}
697
698	tasklet_schedule(t: &dev->bh);
699
700	netif_dbg(dev, rx_status, dev->net,
701	"paused rx queue disabled, %d skbs requeued\n", num);
702	}
703	EXPORT_SYMBOL_GPL(usbnet_resume_rx);
704
705	void usbnet_purge_paused_rxq(struct usbnet *dev)
706	{
707	skb_queue_purge(list: &dev->rxq_pause);
708	}
709	EXPORT_SYMBOL_GPL(usbnet_purge_paused_rxq);
710
711	/*-------------------------------------------------------------------------*/
712
713	// unlink pending rx/tx; completion handlers do all other cleanup
714
715	static int unlink_urbs (struct usbnet *dev, struct sk_buff_head *q)
716	{
717	unsigned long flags;
718	struct sk_buff *skb;
719	int count = 0;
720
721	spin_lock_irqsave (&q->lock, flags);
722	while (!skb_queue_empty(list: q)) {
723	struct skb_data *entry;
724	struct urb *urb;
725	int retval;
726
727	skb_queue_walk(q, skb) {
728	entry = (struct skb_data *) skb->cb;
729	if (entry->state != unlink_start)
730	goto found;
731	}
732	break;
733	found:
734	entry->state = unlink_start;
735	urb = entry->urb;
736
737	/*
738	* Get reference count of the URB to avoid it to be
739	* freed during usb_unlink_urb, which may trigger
740	* use-after-free problem inside usb_unlink_urb since
741	* usb_unlink_urb is always racing with .complete
742	* handler(include defer_bh).
743	*/
744	usb_get_urb(urb);
745	spin_unlock_irqrestore(lock: &q->lock, flags);
746	// during some PM-driven resume scenarios,
747	// these (async) unlinks complete immediately
748	retval = usb_unlink_urb (urb);
749	if (retval != -EINPROGRESS && retval != 0)
750	netdev_dbg(dev->net, "unlink urb err, %d\n", retval);
751	else
752	count++;
753	usb_put_urb(urb);
754	spin_lock_irqsave(&q->lock, flags);
755	}
756	spin_unlock_irqrestore (lock: &q->lock, flags);
757	return count;
758	}
759
760	// Flush all pending rx urbs
761	// minidrivers may need to do this when the MTU changes
762
763	void usbnet_unlink_rx_urbs(struct usbnet *dev)
764	{
765	if (netif_running(dev: dev->net)) {
766	(void) unlink_urbs (dev, q: &dev->rxq);
767	tasklet_schedule(t: &dev->bh);
768	}
769	}
770	EXPORT_SYMBOL_GPL(usbnet_unlink_rx_urbs);
771
772	/*-------------------------------------------------------------------------*/
773
774	static void wait_skb_queue_empty(struct sk_buff_head *q)
775	{
776	unsigned long flags;
777
778	spin_lock_irqsave(&q->lock, flags);
779	while (!skb_queue_empty(list: q)) {
780	spin_unlock_irqrestore(lock: &q->lock, flags);
781	schedule_timeout(timeout: msecs_to_jiffies(UNLINK_TIMEOUT_MS));
782	set_current_state(TASK_UNINTERRUPTIBLE);
783	spin_lock_irqsave(&q->lock, flags);
784	}
785	spin_unlock_irqrestore(lock: &q->lock, flags);
786	}
787
788	// precondition: never called in_interrupt
789	static void usbnet_terminate_urbs(struct usbnet *dev)
790	{
791	DECLARE_WAITQUEUE(wait, current);
792	int temp;
793
794	/* ensure there are no more active urbs */
795	add_wait_queue(wq_head: &dev->wait, wq_entry: &wait);
796	set_current_state(TASK_UNINTERRUPTIBLE);
797	temp = unlink_urbs(dev, q: &dev->txq) +
798	unlink_urbs(dev, q: &dev->rxq);
799
800	/* maybe wait for deletions to finish. */
801	wait_skb_queue_empty(q: &dev->rxq);
802	wait_skb_queue_empty(q: &dev->txq);
803	wait_skb_queue_empty(q: &dev->done);
804	netif_dbg(dev, ifdown, dev->net,
805	"waited for %d urb completions\n", temp);
806	set_current_state(TASK_RUNNING);
807	remove_wait_queue(wq_head: &dev->wait, wq_entry: &wait);
808	}
809
810	int usbnet_stop (struct net_device *net)
811	{
812	struct usbnet *dev = netdev_priv(dev: net);
813	const struct driver_info *info = dev->driver_info;
814	int retval, pm, mpn;
815
816	clear_bit(EVENT_DEV_OPEN, addr: &dev->flags);
817	netif_stop_queue (dev: net);
818
819	netif_info(dev, ifdown, dev->net,
820	"stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
821	net->stats.rx_packets, net->stats.tx_packets,
822	net->stats.rx_errors, net->stats.tx_errors);
823
824	/* to not race resume */
825	pm = usb_autopm_get_interface(intf: dev->intf);
826	/* allow minidriver to stop correctly (wireless devices to turn off
827	* radio etc) */
828	if (info->stop) {
829	retval = info->stop(dev);
830	if (retval < 0)
831	netif_info(dev, ifdown, dev->net,
832	"stop fail (%d) usbnet usb-%s-%s, %s\n",
833	retval,
834	dev->udev->bus->bus_name, dev->udev->devpath,
835	info->description);
836	}
837
838	if (!(info->flags & FLAG_AVOID_UNLINK_URBS))
839	usbnet_terminate_urbs(dev);
840
841	usbnet_status_stop(dev);
842
843	usbnet_purge_paused_rxq(dev);
844
845	mpn = !test_and_clear_bit(EVENT_NO_RUNTIME_PM, addr: &dev->flags);
846
847	/* deferred work (timer, softirq, task) must also stop */
848	dev->flags = 0;
849	del_timer_sync (timer: &dev->delay);
850	tasklet_kill (t: &dev->bh);
851	cancel_work_sync(work: &dev->kevent);
852	if (!pm)
853	usb_autopm_put_interface(intf: dev->intf);
854
855	if (info->manage_power && mpn)
856	info->manage_power(dev, 0);
857	else
858	usb_autopm_put_interface(intf: dev->intf);
859
860	return 0;
861	}
862	EXPORT_SYMBOL_GPL(usbnet_stop);
863
864	/*-------------------------------------------------------------------------*/
865
866	// posts reads, and enables write queuing
867
868	// precondition: never called in_interrupt
869
870	int usbnet_open (struct net_device *net)
871	{
872	struct usbnet *dev = netdev_priv(dev: net);
873	int retval;
874	const struct driver_info *info = dev->driver_info;
875
876	if ((retval = usb_autopm_get_interface(intf: dev->intf)) < 0) {
877	netif_info(dev, ifup, dev->net,
878	"resumption fail (%d) usbnet usb-%s-%s, %s\n",
879	retval,
880	dev->udev->bus->bus_name,
881	dev->udev->devpath,
882	info->description);
883	goto done_nopm;
884	}
885
886	// put into "known safe" state
887	if (info->reset && (retval = info->reset (dev)) < 0) {
888	netif_info(dev, ifup, dev->net,
889	"open reset fail (%d) usbnet usb-%s-%s, %s\n",
890	retval,
891	dev->udev->bus->bus_name,
892	dev->udev->devpath,
893	info->description);
894	goto done;
895	}
896
897	/* hard_mtu or rx_urb_size may change in reset() */
898	usbnet_update_max_qlen(dev);
899
900	// insist peer be connected
901	if (info->check_connect && (retval = info->check_connect (dev)) < 0) {
902	netif_err(dev, ifup, dev->net, "can't open; %d\n", retval);
903	goto done;
904	}
905
906	/* start any status interrupt transfer */
907	if (dev->interrupt) {
908	retval = usbnet_status_start(dev, GFP_KERNEL);
909	if (retval < 0) {
910	netif_err(dev, ifup, dev->net,
911	"intr submit %d\n", retval);
912	goto done;
913	}
914	}
915
916	set_bit(EVENT_DEV_OPEN, addr: &dev->flags);
917	netif_start_queue (dev: net);
918	netif_info(dev, ifup, dev->net,
919	"open: enable queueing (rx %d, tx %d) mtu %d %s framing\n",
920	(int)RX_QLEN(dev), (int)TX_QLEN(dev),
921	dev->net->mtu,
922	(dev->driver_info->flags & FLAG_FRAMING_NC) ? "NetChip" :
923	(dev->driver_info->flags & FLAG_FRAMING_GL) ? "GeneSys" :
924	(dev->driver_info->flags & FLAG_FRAMING_Z) ? "Zaurus" :
925	(dev->driver_info->flags & FLAG_FRAMING_RN) ? "RNDIS" :
926	(dev->driver_info->flags & FLAG_FRAMING_AX) ? "ASIX" :
927	"simple");
928
929	/* reset rx error state */
930	dev->pkt_cnt = 0;
931	dev->pkt_err = 0;
932	clear_bit(EVENT_RX_KILL, addr: &dev->flags);
933
934	// delay posting reads until we're fully open
935	tasklet_schedule (t: &dev->bh);
936	if (info->manage_power) {
937	retval = info->manage_power(dev, 1);
938	if (retval < 0) {
939	retval = 0;
940	set_bit(EVENT_NO_RUNTIME_PM, addr: &dev->flags);
941	} else {
942	usb_autopm_put_interface(intf: dev->intf);
943	}
944	}
945	return retval;
946	done:
947	usb_autopm_put_interface(intf: dev->intf);
948	done_nopm:
949	return retval;
950	}
951	EXPORT_SYMBOL_GPL(usbnet_open);
952
953	/*-------------------------------------------------------------------------*/
954
955	/* ethtool methods; minidrivers may need to add some more, but
956	* they'll probably want to use this base set.
957	*/
958
959	/* These methods are written on the assumption that the device
960	* uses MII
961	*/
962	int usbnet_get_link_ksettings_mii(struct net_device *net,
963	struct ethtool_link_ksettings *cmd)
964	{
965	struct usbnet *dev = netdev_priv(dev: net);
966
967	if (!dev->mii.mdio_read)
968	return -EOPNOTSUPP;
969
970	mii_ethtool_get_link_ksettings(mii: &dev->mii, cmd);
971
972	return 0;
973	}
974	EXPORT_SYMBOL_GPL(usbnet_get_link_ksettings_mii);
975
976	int usbnet_get_link_ksettings_internal(struct net_device *net,
977	struct ethtool_link_ksettings *cmd)
978	{
979	struct usbnet *dev = netdev_priv(dev: net);
980
981	/* the assumption that speed is equal on tx and rx
982	* is deeply engrained into the networking layer.
983	* For wireless stuff it is not true.
984	* We assume that rx_speed matters more.
985	*/
986	if (dev->rx_speed != SPEED_UNSET)
987	cmd->base.speed = dev->rx_speed / 1000000;
988	else if (dev->tx_speed != SPEED_UNSET)
989	cmd->base.speed = dev->tx_speed / 1000000;
990	else
991	cmd->base.speed = SPEED_UNKNOWN;
992
993	return 0;
994	}
995	EXPORT_SYMBOL_GPL(usbnet_get_link_ksettings_internal);
996
997	int usbnet_set_link_ksettings_mii(struct net_device *net,
998	const struct ethtool_link_ksettings *cmd)
999	{
1000	struct usbnet *dev = netdev_priv(dev: net);
1001	int retval;
1002
1003	if (!dev->mii.mdio_write)
1004	return -EOPNOTSUPP;
1005
1006	retval = mii_ethtool_set_link_ksettings(mii: &dev->mii, cmd);
1007
1008	/* link speed/duplex might have changed */
1009	if (dev->driver_info->link_reset)
1010	dev->driver_info->link_reset(dev);
1011
1012	/* hard_mtu or rx_urb_size may change in link_reset() */
1013	usbnet_update_max_qlen(dev);
1014
1015	return retval;
1016	}
1017	EXPORT_SYMBOL_GPL(usbnet_set_link_ksettings_mii);
1018
1019	u32 usbnet_get_link (struct net_device *net)
1020	{
1021	struct usbnet *dev = netdev_priv(dev: net);
1022
1023	/* If a check_connect is defined, return its result */
1024	if (dev->driver_info->check_connect)
1025	return dev->driver_info->check_connect (dev) == 0;
1026
1027	/* if the device has mii operations, use those */
1028	if (dev->mii.mdio_read)
1029	return mii_link_ok(mii: &dev->mii);
1030
1031	/* Otherwise, dtrt for drivers calling netif_carrier_{on,off} */
1032	return ethtool_op_get_link(dev: net);
1033	}
1034	EXPORT_SYMBOL_GPL(usbnet_get_link);
1035
1036	int usbnet_nway_reset(struct net_device *net)
1037	{
1038	struct usbnet *dev = netdev_priv(dev: net);
1039
1040	if (!dev->mii.mdio_write)
1041	return -EOPNOTSUPP;
1042
1043	return mii_nway_restart(mii: &dev->mii);
1044	}
1045	EXPORT_SYMBOL_GPL(usbnet_nway_reset);
1046
1047	void usbnet_get_drvinfo (struct net_device *net, struct ethtool_drvinfo *info)
1048	{
1049	struct usbnet *dev = netdev_priv(dev: net);
1050
1051	strscpy(p: info->driver, q: dev->driver_name, size: sizeof(info->driver));
1052	strscpy(p: info->fw_version, q: dev->driver_info->description,
1053	size: sizeof(info->fw_version));
1054	usb_make_path (dev: dev->udev, buf: info->bus_info, size: sizeof info->bus_info);
1055	}
1056	EXPORT_SYMBOL_GPL(usbnet_get_drvinfo);
1057
1058	u32 usbnet_get_msglevel (struct net_device *net)
1059	{
1060	struct usbnet *dev = netdev_priv(dev: net);
1061
1062	return dev->msg_enable;
1063	}
1064	EXPORT_SYMBOL_GPL(usbnet_get_msglevel);
1065
1066	void usbnet_set_msglevel (struct net_device *net, u32 level)
1067	{
1068	struct usbnet *dev = netdev_priv(dev: net);
1069
1070	dev->msg_enable = level;
1071	}
1072	EXPORT_SYMBOL_GPL(usbnet_set_msglevel);
1073
1074	/* drivers may override default ethtool_ops in their bind() routine */
1075	static const struct ethtool_ops usbnet_ethtool_ops = {
1076	.get_link = usbnet_get_link,
1077	.nway_reset = usbnet_nway_reset,
1078	.get_drvinfo = usbnet_get_drvinfo,
1079	.get_msglevel = usbnet_get_msglevel,
1080	.set_msglevel = usbnet_set_msglevel,
1081	.get_ts_info = ethtool_op_get_ts_info,
1082	.get_link_ksettings = usbnet_get_link_ksettings_mii,
1083	.set_link_ksettings = usbnet_set_link_ksettings_mii,
1084	};
1085
1086	/*-------------------------------------------------------------------------*/
1087
1088	static void __handle_link_change(struct usbnet *dev)
1089	{
1090	if (!test_bit(EVENT_DEV_OPEN, &dev->flags))
1091	return;
1092
1093	if (!netif_carrier_ok(dev: dev->net)) {
1094	/* kill URBs for reading packets to save bus bandwidth */
1095	unlink_urbs(dev, q: &dev->rxq);
1096
1097	/*
1098	* tx_timeout will unlink URBs for sending packets and
1099	* tx queue is stopped by netcore after link becomes off
1100	*/
1101	} else {
1102	/* submitting URBs for reading packets */
1103	tasklet_schedule(t: &dev->bh);
1104	}
1105
1106	/* hard_mtu or rx_urb_size may change during link change */
1107	usbnet_update_max_qlen(dev);
1108
1109	clear_bit(EVENT_LINK_CHANGE, addr: &dev->flags);
1110	}
1111
1112	void usbnet_set_rx_mode(struct net_device *net)
1113	{
1114	struct usbnet *dev = netdev_priv(dev: net);
1115
1116	usbnet_defer_kevent(dev, EVENT_SET_RX_MODE);
1117	}
1118	EXPORT_SYMBOL_GPL(usbnet_set_rx_mode);
1119
1120	static void __handle_set_rx_mode(struct usbnet *dev)
1121	{
1122	if (dev->driver_info->set_rx_mode)
1123	(dev->driver_info->set_rx_mode)(dev);
1124
1125	clear_bit(EVENT_SET_RX_MODE, addr: &dev->flags);
1126	}
1127
1128	/* work that cannot be done in interrupt context uses keventd.
1129	*
1130	* NOTE: with 2.5 we could do more of this using completion callbacks,
1131	* especially now that control transfers can be queued.
1132	*/
1133	static void
1134	usbnet_deferred_kevent (struct work_struct *work)
1135	{
1136	struct usbnet *dev =
1137	container_of(work, struct usbnet, kevent);
1138	int status;
1139
1140	/* usb_clear_halt() needs a thread context */
1141	if (test_bit (EVENT_TX_HALT, &dev->flags)) {
1142	unlink_urbs (dev, q: &dev->txq);
1143	status = usb_autopm_get_interface(intf: dev->intf);
1144	if (status < 0)
1145	goto fail_pipe;
1146	status = usb_clear_halt (dev: dev->udev, pipe: dev->out);
1147	usb_autopm_put_interface(intf: dev->intf);
1148	if (status < 0 &&
1149	status != -EPIPE &&
1150	status != -ESHUTDOWN) {
1151	if (netif_msg_tx_err (dev))
1152	fail_pipe:
1153	netdev_err(dev: dev->net, format: "can't clear tx halt, status %d\n",
1154	status);
1155	} else {
1156	clear_bit (EVENT_TX_HALT, addr: &dev->flags);
1157	if (status != -ESHUTDOWN)
1158	netif_wake_queue (dev: dev->net);
1159	}
1160	}
1161	if (test_bit (EVENT_RX_HALT, &dev->flags)) {
1162	unlink_urbs (dev, q: &dev->rxq);
1163	status = usb_autopm_get_interface(intf: dev->intf);
1164	if (status < 0)
1165	goto fail_halt;
1166	status = usb_clear_halt (dev: dev->udev, pipe: dev->in);
1167	usb_autopm_put_interface(intf: dev->intf);
1168	if (status < 0 &&
1169	status != -EPIPE &&
1170	status != -ESHUTDOWN) {
1171	if (netif_msg_rx_err (dev))
1172	fail_halt:
1173	netdev_err(dev: dev->net, format: "can't clear rx halt, status %d\n",
1174	status);
1175	} else {
1176	clear_bit (EVENT_RX_HALT, addr: &dev->flags);
1177	tasklet_schedule (t: &dev->bh);
1178	}
1179	}
1180
1181	/* tasklet could resubmit itself forever if memory is tight */
1182	if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {
1183	struct urb *urb = NULL;
1184	int resched = 1;
1185
1186	if (netif_running (dev: dev->net))
1187	urb = usb_alloc_urb (iso_packets: 0, GFP_KERNEL);
1188	else
1189	clear_bit (EVENT_RX_MEMORY, addr: &dev->flags);
1190	if (urb != NULL) {
1191	clear_bit (EVENT_RX_MEMORY, addr: &dev->flags);
1192	status = usb_autopm_get_interface(intf: dev->intf);
1193	if (status < 0) {
1194	usb_free_urb(urb);
1195	goto fail_lowmem;
1196	}
1197	if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK)
1198	resched = 0;
1199	usb_autopm_put_interface(intf: dev->intf);
1200	fail_lowmem:
1201	if (resched)
1202	tasklet_schedule (t: &dev->bh);
1203	}
1204	}
1205
1206	if (test_bit (EVENT_LINK_RESET, &dev->flags)) {
1207	const struct driver_info *info = dev->driver_info;
1208	int retval = 0;
1209
1210	clear_bit (EVENT_LINK_RESET, addr: &dev->flags);
1211	status = usb_autopm_get_interface(intf: dev->intf);
1212	if (status < 0)
1213	goto skip_reset;
1214	if(info->link_reset && (retval = info->link_reset(dev)) < 0) {
1215	usb_autopm_put_interface(intf: dev->intf);
1216	skip_reset:
1217	netdev_info(dev: dev->net, format: "link reset failed (%d) usbnet usb-%s-%s, %s\n",
1218	retval,
1219	dev->udev->bus->bus_name,
1220	dev->udev->devpath,
1221	info->description);
1222	} else {
1223	usb_autopm_put_interface(intf: dev->intf);
1224	}
1225
1226	/* handle link change from link resetting */
1227	__handle_link_change(dev);
1228	}
1229
1230	if (test_bit (EVENT_LINK_CHANGE, &dev->flags))
1231	__handle_link_change(dev);
1232
1233	if (test_bit (EVENT_SET_RX_MODE, &dev->flags))
1234	__handle_set_rx_mode(dev);
1235
1236
1237	if (dev->flags)
1238	netdev_dbg(dev->net, "kevent done, flags = 0x%lx\n", dev->flags);
1239	}
1240
1241	/*-------------------------------------------------------------------------*/
1242
1243	static void tx_complete (struct urb *urb)
1244	{
1245	struct sk_buff *skb = (struct sk_buff *) urb->context;
1246	struct skb_data *entry = (struct skb_data *) skb->cb;
1247	struct usbnet *dev = entry->dev;
1248
1249	if (urb->status == 0) {
1250	struct pcpu_sw_netstats *stats64 = this_cpu_ptr(dev->net->tstats);
1251	unsigned long flags;
1252
1253	flags = u64_stats_update_begin_irqsave(syncp: &stats64->syncp);
1254	u64_stats_add(p: &stats64->tx_packets, val: entry->packets);
1255	u64_stats_add(p: &stats64->tx_bytes, val: entry->length);
1256	u64_stats_update_end_irqrestore(syncp: &stats64->syncp, flags);
1257	} else {
1258	dev->net->stats.tx_errors++;
1259
1260	switch (urb->status) {
1261	case -EPIPE:
1262	usbnet_defer_kevent (dev, EVENT_TX_HALT);
1263	break;
1264
1265	/* software-driven interface shutdown */
1266	case -ECONNRESET: // async unlink
1267	case -ESHUTDOWN: // hardware gone
1268	break;
1269
1270	/* like rx, tx gets controller i/o faults during hub_wq
1271	* delays and so it uses the same throttling mechanism.
1272	*/
1273	case -EPROTO:
1274	case -ETIME:
1275	case -EILSEQ:
1276	usb_mark_last_busy(udev: dev->udev);
1277	if (!timer_pending (timer: &dev->delay)) {
1278	mod_timer (timer: &dev->delay,
1279	expires: jiffies + THROTTLE_JIFFIES);
1280	netif_dbg(dev, link, dev->net,
1281	"tx throttle %d\n", urb->status);
1282	}
1283	netif_stop_queue (dev: dev->net);
1284	break;
1285	default:
1286	netif_dbg(dev, tx_err, dev->net,
1287	"tx err %d\n", entry->urb->status);
1288	break;
1289	}
1290	}
1291
1292	usb_autopm_put_interface_async(intf: dev->intf);
1293	(void) defer_bh(dev, skb, list: &dev->txq, state: tx_done);
1294	}
1295
1296	/*-------------------------------------------------------------------------*/
1297
1298	void usbnet_tx_timeout (struct net_device *net, unsigned int txqueue)
1299	{
1300	struct usbnet *dev = netdev_priv(dev: net);
1301
1302	unlink_urbs (dev, q: &dev->txq);
1303	tasklet_schedule (t: &dev->bh);
1304	/* this needs to be handled individually because the generic layer
1305	* doesn't know what is sufficient and could not restore private
1306	* information if a remedy of an unconditional reset were used.
1307	*/
1308	if (dev->driver_info->recover)
1309	(dev->driver_info->recover)(dev);
1310	}
1311	EXPORT_SYMBOL_GPL(usbnet_tx_timeout);
1312
1313	/*-------------------------------------------------------------------------*/
1314
1315	static int build_dma_sg(const struct sk_buff *skb, struct urb *urb)
1316	{
1317	unsigned num_sgs, total_len = 0;
1318	int i, s = 0;
1319
1320	num_sgs = skb_shinfo(skb)->nr_frags + 1;
1321	if (num_sgs == 1)
1322	return 0;
1323
1324	/* reserve one for zero packet */
1325	urb->sg = kmalloc_array(n: num_sgs + 1, size: sizeof(struct scatterlist),
1326	GFP_ATOMIC);
1327	if (!urb->sg)
1328	return -ENOMEM;
1329
1330	urb->num_sgs = num_sgs;
1331	sg_init_table(urb->sg, urb->num_sgs + 1);
1332
1333	sg_set_buf(sg: &urb->sg[s++], buf: skb->data, buflen: skb_headlen(skb));
1334	total_len += skb_headlen(skb);
1335
1336	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1337	skb_frag_t *f = &skb_shinfo(skb)->frags[i];
1338
1339	total_len += skb_frag_size(frag: f);
1340	sg_set_page(sg: &urb->sg[i + s], page: skb_frag_page(frag: f), len: skb_frag_size(frag: f),
1341	offset: skb_frag_off(frag: f));
1342	}
1343	urb->transfer_buffer_length = total_len;
1344
1345	return 1;
1346	}
1347
1348	netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
1349	struct net_device *net)
1350	{
1351	struct usbnet *dev = netdev_priv(dev: net);
1352	unsigned int length;
1353	struct urb *urb = NULL;
1354	struct skb_data *entry;
1355	const struct driver_info *info = dev->driver_info;
1356	unsigned long flags;
1357	int retval;
1358
1359	if (skb)
1360	skb_tx_timestamp(skb);
1361
1362	// some devices want funky USB-level framing, for
1363	// win32 driver (usually) and/or hardware quirks
1364	if (info->tx_fixup) {
1365	skb = info->tx_fixup (dev, skb, GFP_ATOMIC);
1366	if (!skb) {
1367	/* packet collected; minidriver waiting for more */
1368	if (info->flags & FLAG_MULTI_PACKET)
1369	goto not_drop;
1370	netif_dbg(dev, tx_err, dev->net, "can't tx_fixup skb\n");
1371	goto drop;
1372	}
1373	}
1374
1375	if (!(urb = usb_alloc_urb (iso_packets: 0, GFP_ATOMIC))) {
1376	netif_dbg(dev, tx_err, dev->net, "no urb\n");
1377	goto drop;
1378	}
1379
1380	entry = (struct skb_data *) skb->cb;
1381	entry->urb = urb;
1382	entry->dev = dev;
1383
1384	usb_fill_bulk_urb (urb, dev: dev->udev, pipe: dev->out,
1385	transfer_buffer: skb->data, buffer_length: skb->len, complete_fn: tx_complete, context: skb);
1386	if (dev->can_dma_sg) {
1387	if (build_dma_sg(skb, urb) < 0)
1388	goto drop;
1389	}
1390	length = urb->transfer_buffer_length;
1391
1392	/* don't assume the hardware handles USB_ZERO_PACKET
1393	* NOTE: strictly conforming cdc-ether devices should expect
1394	* the ZLP here, but ignore the one-byte packet.
1395	* NOTE2: CDC NCM specification is different from CDC ECM when
1396	* handling ZLP/short packets, so cdc_ncm driver will make short
1397	* packet itself if needed.
1398	*/
1399	if (length % dev->maxpacket == 0) {
1400	if (!(info->flags & FLAG_SEND_ZLP)) {
1401	if (!(info->flags & FLAG_MULTI_PACKET)) {
1402	length++;
1403	if (skb_tailroom(skb) && !urb->num_sgs) {
1404	skb->data[skb->len] = 0;
1405	__skb_put(skb, len: 1);
1406	} else if (urb->num_sgs)
1407	sg_set_buf(sg: &urb->sg[urb->num_sgs++],
1408	buf: dev->padding_pkt, buflen: 1);
1409	}
1410	} else
1411	urb->transfer_flags |= URB_ZERO_PACKET;
1412	}
1413	urb->transfer_buffer_length = length;
1414
1415	if (info->flags & FLAG_MULTI_PACKET) {
1416	/* Driver has set number of packets and a length delta.
1417	* Calculate the complete length and ensure that it's
1418	* positive.
1419	*/
1420	entry->length += length;
1421	if (WARN_ON_ONCE(entry->length <= 0))
1422	entry->length = length;
1423	} else {
1424	usbnet_set_skb_tx_stats(skb, packets: 1, bytes_delta: length);
1425	}
1426
1427	spin_lock_irqsave(&dev->txq.lock, flags);
1428	retval = usb_autopm_get_interface_async(intf: dev->intf);
1429	if (retval < 0) {
1430	spin_unlock_irqrestore(lock: &dev->txq.lock, flags);
1431	goto drop;
1432	}
1433	if (netif_queue_stopped(dev: net)) {
1434	usb_autopm_put_interface_async(intf: dev->intf);
1435	spin_unlock_irqrestore(lock: &dev->txq.lock, flags);
1436	goto drop;
1437	}
1438
1439	#ifdef CONFIG_PM
1440	/* if this triggers the device is still a sleep */
1441	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
1442	/* transmission will be done in resume */
1443	usb_anchor_urb(urb, anchor: &dev->deferred);
1444	/* no use to process more packets */
1445	netif_stop_queue(dev: net);
1446	usb_put_urb(urb);
1447	spin_unlock_irqrestore(lock: &dev->txq.lock, flags);
1448	netdev_dbg(dev->net, "Delaying transmission for resumption\n");
1449	goto deferred;
1450	}
1451	#endif
1452
1453	switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) {
1454	case -EPIPE:
1455	netif_stop_queue (dev: net);
1456	usbnet_defer_kevent (dev, EVENT_TX_HALT);
1457	usb_autopm_put_interface_async(intf: dev->intf);
1458	break;
1459	default:
1460	usb_autopm_put_interface_async(intf: dev->intf);
1461	netif_dbg(dev, tx_err, dev->net,
1462	"tx: submit urb err %d\n", retval);
1463	break;
1464	case 0:
1465	netif_trans_update(dev: net);
1466	__usbnet_queue_skb(list: &dev->txq, newsk: skb, state: tx_start);
1467	if (dev->txq.qlen >= TX_QLEN (dev))
1468	netif_stop_queue (dev: net);
1469	}
1470	spin_unlock_irqrestore (lock: &dev->txq.lock, flags);
1471
1472	if (retval) {
1473	netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", retval);
1474	drop:
1475	dev->net->stats.tx_dropped++;
1476	not_drop:
1477	if (skb)
1478	dev_kfree_skb_any (skb);
1479	if (urb) {
1480	kfree(objp: urb->sg);
1481	usb_free_urb(urb);
1482	}
1483	} else
1484	netif_dbg(dev, tx_queued, dev->net,
1485	"> tx, len %u, type 0x%x\n", length, skb->protocol);
1486	#ifdef CONFIG_PM
1487	deferred:
1488	#endif
1489	return NETDEV_TX_OK;
1490	}
1491	EXPORT_SYMBOL_GPL(usbnet_start_xmit);
1492
1493	static int rx_alloc_submit(struct usbnet *dev, gfp_t flags)
1494	{
1495	struct urb *urb;
1496	int i;
1497	int ret = 0;
1498
1499	/* don't refill the queue all at once */
1500	for (i = 0; i < 10 && dev->rxq.qlen < RX_QLEN(dev); i++) {
1501	urb = usb_alloc_urb(iso_packets: 0, mem_flags: flags);
1502	if (urb != NULL) {
1503	ret = rx_submit(dev, urb, flags);
1504	if (ret)
1505	goto err;
1506	} else {
1507	ret = -ENOMEM;
1508	goto err;
1509	}
1510	}
1511	err:
1512	return ret;
1513	}
1514
1515	static inline void usb_free_skb(struct sk_buff *skb)
1516	{
1517	struct skb_data *entry = (struct skb_data *)skb->cb;
1518
1519	usb_free_urb(urb: entry->urb);
1520	dev_kfree_skb(skb);
1521	}
1522
1523	/*-------------------------------------------------------------------------*/
1524
1525	// tasklet (work deferred from completions, in_irq) or timer
1526
1527	static void usbnet_bh (struct timer_list *t)
1528	{
1529	struct usbnet *dev = from_timer(dev, t, delay);
1530	struct sk_buff *skb;
1531	struct skb_data *entry;
1532
1533	while ((skb = skb_dequeue (list: &dev->done))) {
1534	entry = (struct skb_data *) skb->cb;
1535	switch (entry->state) {
1536	case rx_done:
1537	if (rx_process(dev, skb))
1538	usb_free_skb(skb);
1539	continue;
1540	case tx_done:
1541	kfree(objp: entry->urb->sg);
1542	fallthrough;
1543	case rx_cleanup:
1544	usb_free_skb(skb);
1545	continue;
1546	default:
1547	netdev_dbg(dev->net, "bogus skb state %d\n", entry->state);
1548	}
1549	}
1550
1551	/* restart RX again after disabling due to high error rate */
1552	clear_bit(EVENT_RX_KILL, addr: &dev->flags);
1553
1554	/* waiting for all pending urbs to complete?
1555	* only then can we forgo submitting anew
1556	*/
1557	if (waitqueue_active(wq_head: &dev->wait)) {
1558	if (dev->txq.qlen + dev->rxq.qlen + dev->done.qlen == 0)
1559	wake_up_all(&dev->wait);
1560
1561	// or are we maybe short a few urbs?
1562	} else if (netif_running (dev: dev->net) &&
1563	netif_device_present (dev: dev->net) &&
1564	netif_carrier_ok(dev: dev->net) &&
1565	!timer_pending(timer: &dev->delay) &&
1566	!test_bit(EVENT_RX_PAUSED, &dev->flags) &&
1567	!test_bit(EVENT_RX_HALT, &dev->flags)) {
1568	int temp = dev->rxq.qlen;
1569
1570	if (temp < RX_QLEN(dev)) {
1571	if (rx_alloc_submit(dev, GFP_ATOMIC) == -ENOLINK)
1572	return;
1573	if (temp != dev->rxq.qlen)
1574	netif_dbg(dev, link, dev->net,
1575	"rxqlen %d --> %d\n",
1576	temp, dev->rxq.qlen);
1577	if (dev->rxq.qlen < RX_QLEN(dev))
1578	tasklet_schedule (t: &dev->bh);
1579	}
1580	if (dev->txq.qlen < TX_QLEN (dev))
1581	netif_wake_queue (dev: dev->net);
1582	}
1583	}
1584
1585	static void usbnet_bh_tasklet(struct tasklet_struct *t)
1586	{
1587	struct usbnet *dev = from_tasklet(dev, t, bh);
1588
1589	usbnet_bh(t: &dev->delay);
1590	}
1591
1592
1593	/*-------------------------------------------------------------------------
1594	*
1595	* USB Device Driver support
1596	*
1597	*-------------------------------------------------------------------------*/
1598
1599	// precondition: never called in_interrupt
1600
1601	void usbnet_disconnect (struct usb_interface *intf)
1602	{
1603	struct usbnet *dev;
1604	struct usb_device *xdev;
1605	struct net_device *net;
1606	struct urb *urb;
1607
1608	dev = usb_get_intfdata(intf);
1609	usb_set_intfdata(intf, NULL);
1610	if (!dev)
1611	return;
1612
1613	xdev = interface_to_usbdev (intf);
1614
1615	netif_info(dev, probe, dev->net, "unregister '%s' usb-%s-%s, %s\n",
1616	intf->dev.driver->name,
1617	xdev->bus->bus_name, xdev->devpath,
1618	dev->driver_info->description);
1619
1620	net = dev->net;
1621	unregister_netdev (dev: net);
1622
1623	while ((urb = usb_get_from_anchor(anchor: &dev->deferred))) {
1624	dev_kfree_skb(urb->context);
1625	kfree(objp: urb->sg);
1626	usb_free_urb(urb);
1627	}
1628
1629	if (dev->driver_info->unbind)
1630	dev->driver_info->unbind(dev, intf);
1631
1632	usb_kill_urb(urb: dev->interrupt);
1633	usb_free_urb(urb: dev->interrupt);
1634	kfree(objp: dev->padding_pkt);
1635
1636	free_percpu(pdata: net->tstats);
1637	free_netdev(dev: net);
1638	}
1639	EXPORT_SYMBOL_GPL(usbnet_disconnect);
1640
1641	static const struct net_device_ops usbnet_netdev_ops = {
1642	.ndo_open = usbnet_open,
1643	.ndo_stop = usbnet_stop,
1644	.ndo_start_xmit = usbnet_start_xmit,
1645	.ndo_tx_timeout = usbnet_tx_timeout,
1646	.ndo_set_rx_mode = usbnet_set_rx_mode,
1647	.ndo_change_mtu = usbnet_change_mtu,
1648	.ndo_get_stats64 = dev_get_tstats64,
1649	.ndo_set_mac_address = eth_mac_addr,
1650	.ndo_validate_addr = eth_validate_addr,
1651	};
1652
1653	/*-------------------------------------------------------------------------*/
1654
1655	// precondition: never called in_interrupt
1656
1657	static struct device_type wlan_type = {
1658	.name = "wlan",
1659	};
1660
1661	static struct device_type wwan_type = {
1662	.name = "wwan",
1663	};
1664
1665	int
1666	usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
1667	{
1668	struct usbnet *dev;
1669	struct net_device *net;
1670	struct usb_host_interface *interface;
1671	const struct driver_info *info;
1672	struct usb_device *xdev;
1673	int status;
1674	const char *name;
1675	struct usb_driver *driver = to_usb_driver(udev->dev.driver);
1676
1677	/* usbnet already took usb runtime pm, so have to enable the feature
1678	* for usb interface, otherwise usb_autopm_get_interface may return
1679	* failure if RUNTIME_PM is enabled.
1680	*/
1681	if (!driver->supports_autosuspend) {
1682	driver->supports_autosuspend = 1;
1683	pm_runtime_enable(dev: &udev->dev);
1684	}
1685
1686	name = udev->dev.driver->name;
1687	info = (const struct driver_info *) prod->driver_info;
1688	if (!info) {
1689	dev_dbg (&udev->dev, "blacklisted by %s\n", name);
1690	return -ENODEV;
1691	}
1692	xdev = interface_to_usbdev (udev);
1693	interface = udev->cur_altsetting;
1694
1695	status = -ENOMEM;
1696
1697	// set up our own records
1698	net = alloc_etherdev(sizeof(*dev));
1699	if (!net)
1700	goto out;
1701
1702	/* netdev_printk() needs this so do it as early as possible */
1703	SET_NETDEV_DEV(net, &udev->dev);
1704
1705	dev = netdev_priv(dev: net);
1706	dev->udev = xdev;
1707	dev->intf = udev;
1708	dev->driver_info = info;
1709	dev->driver_name = name;
1710	dev->rx_speed = SPEED_UNSET;
1711	dev->tx_speed = SPEED_UNSET;
1712
1713	net->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1714	if (!net->tstats)
1715	goto out0;
1716
1717	dev->msg_enable = netif_msg_init (debug_value: msg_level, NETIF_MSG_DRV
1718	| NETIF_MSG_PROBE | NETIF_MSG_LINK);
1719	init_waitqueue_head(&dev->wait);
1720	skb_queue_head_init (list: &dev->rxq);
1721	skb_queue_head_init (list: &dev->txq);
1722	skb_queue_head_init (list: &dev->done);
1723	skb_queue_head_init(list: &dev->rxq_pause);
1724	tasklet_setup(t: &dev->bh, callback: usbnet_bh_tasklet);
1725	INIT_WORK (&dev->kevent, usbnet_deferred_kevent);
1726	init_usb_anchor(anchor: &dev->deferred);
1727	timer_setup(&dev->delay, usbnet_bh, 0);
1728	mutex_init (&dev->phy_mutex);
1729	mutex_init(&dev->interrupt_mutex);
1730	dev->interrupt_count = 0;
1731
1732	dev->net = net;
1733	strscpy(p: net->name, q: "usb%d", size: sizeof(net->name));
1734	eth_hw_addr_set(dev: net, addr: node_id);
1735
1736	/* rx and tx sides can use different message sizes;
1737	* bind() should set rx_urb_size in that case.
1738	*/
1739	dev->hard_mtu = net->mtu + net->hard_header_len;
1740	net->min_mtu = 0;
1741	net->max_mtu = ETH_MAX_MTU;
1742
1743	net->netdev_ops = &usbnet_netdev_ops;
1744	net->watchdog_timeo = TX_TIMEOUT_JIFFIES;
1745	net->ethtool_ops = &usbnet_ethtool_ops;
1746
1747	// allow device-specific bind/init procedures
1748	// NOTE net->name still not usable ...
1749	if (info->bind) {
1750	status = info->bind (dev, udev);
1751	if (status < 0)
1752	goto out1;
1753
1754	// heuristic: "usb%d" for links we know are two-host,
1755	// else "eth%d" when there's reasonable doubt. userspace
1756	// can rename the link if it knows better.
1757	if ((dev->driver_info->flags & FLAG_ETHER) != 0 &&
1758	((dev->driver_info->flags & FLAG_POINTTOPOINT) == 0 ||
1759	(net->dev_addr [0] & 0x02) == 0))
1760	strscpy(p: net->name, q: "eth%d", size: sizeof(net->name));
1761	/* WLAN devices should always be named "wlan%d" */
1762	if ((dev->driver_info->flags & FLAG_WLAN) != 0)
1763	strscpy(p: net->name, q: "wlan%d", size: sizeof(net->name));
1764	/* WWAN devices should always be named "wwan%d" */
1765	if ((dev->driver_info->flags & FLAG_WWAN) != 0)
1766	strscpy(p: net->name, q: "wwan%d", size: sizeof(net->name));
1767
1768	/* devices that cannot do ARP */
1769	if ((dev->driver_info->flags & FLAG_NOARP) != 0)
1770	net->flags |= IFF_NOARP;
1771
1772	/* maybe the remote can't receive an Ethernet MTU */
1773	if (net->mtu > (dev->hard_mtu - net->hard_header_len))
1774	net->mtu = dev->hard_mtu - net->hard_header_len;
1775	} else if (!info->in || !info->out)
1776	status = usbnet_get_endpoints (dev, udev);
1777	else {
1778	u8 ep_addrs[3] = {
1779	info->in + USB_DIR_IN, info->out + USB_DIR_OUT, 0
1780	};
1781
1782	dev->in = usb_rcvbulkpipe (xdev, info->in);
1783	dev->out = usb_sndbulkpipe (xdev, info->out);
1784	if (!(info->flags & FLAG_NO_SETINT))
1785	status = usb_set_interface (dev: xdev,
1786	ifnum: interface->desc.bInterfaceNumber,
1787	alternate: interface->desc.bAlternateSetting);
1788	else
1789	status = 0;
1790
1791	if (status == 0 && !usb_check_bulk_endpoints(intf: udev, ep_addrs))
1792	status = -EINVAL;
1793	}
1794	if (status >= 0 && dev->status)
1795	status = init_status (dev, intf: udev);
1796	if (status < 0)
1797	goto out3;
1798
1799	if (!dev->rx_urb_size)
1800	dev->rx_urb_size = dev->hard_mtu;
1801	dev->maxpacket = usb_maxpacket(udev: dev->udev, pipe: dev->out);
1802	if (dev->maxpacket == 0) {
1803	/* that is a broken device */
1804	status = -ENODEV;
1805	goto out4;
1806	}
1807
1808	/* let userspace know we have a random address */
1809	if (ether_addr_equal(addr1: net->dev_addr, addr2: node_id))
1810	net->addr_assign_type = NET_ADDR_RANDOM;
1811
1812	if ((dev->driver_info->flags & FLAG_WLAN) != 0)
1813	SET_NETDEV_DEVTYPE(net, &wlan_type);
1814	if ((dev->driver_info->flags & FLAG_WWAN) != 0)
1815	SET_NETDEV_DEVTYPE(net, &wwan_type);
1816
1817	/* initialize max rx_qlen and tx_qlen */
1818	usbnet_update_max_qlen(dev);
1819
1820	if (dev->can_dma_sg && !(info->flags & FLAG_SEND_ZLP) &&
1821	!(info->flags & FLAG_MULTI_PACKET)) {
1822	dev->padding_pkt = kzalloc(size: 1, GFP_KERNEL);
1823	if (!dev->padding_pkt) {
1824	status = -ENOMEM;
1825	goto out4;
1826	}
1827	}
1828
1829	status = register_netdev (dev: net);
1830	if (status)
1831	goto out5;
1832	netif_info(dev, probe, dev->net,
1833	"register '%s' at usb-%s-%s, %s, %pM\n",
1834	udev->dev.driver->name,
1835	xdev->bus->bus_name, xdev->devpath,
1836	dev->driver_info->description,
1837	net->dev_addr);
1838
1839	// ok, it's ready to go.
1840	usb_set_intfdata (intf: udev, data: dev);
1841
1842	netif_device_attach (dev: net);
1843
1844	if (dev->driver_info->flags & FLAG_LINK_INTR)
1845	usbnet_link_change(dev, 0, 0);
1846
1847	return 0;
1848
1849	out5:
1850	kfree(objp: dev->padding_pkt);
1851	out4:
1852	usb_free_urb(urb: dev->interrupt);
1853	out3:
1854	if (info->unbind)
1855	info->unbind (dev, udev);
1856	out1:
1857	/* subdrivers must undo all they did in bind() if they
1858	* fail it, but we may fail later and a deferred kevent
1859	* may trigger an error resubmitting itself and, worse,
1860	* schedule a timer. So we kill it all just in case.
1861	*/
1862	cancel_work_sync(work: &dev->kevent);
1863	del_timer_sync(timer: &dev->delay);
1864	free_percpu(pdata: net->tstats);
1865	out0:
1866	free_netdev(dev: net);
1867	out:
1868	return status;
1869	}
1870	EXPORT_SYMBOL_GPL(usbnet_probe);
1871
1872	/*-------------------------------------------------------------------------*/
1873
1874	/*
1875	* suspend the whole driver as soon as the first interface is suspended
1876	* resume only when the last interface is resumed
1877	*/
1878
1879	int usbnet_suspend (struct usb_interface *intf, pm_message_t message)
1880	{
1881	struct usbnet *dev = usb_get_intfdata(intf);
1882
1883	if (!dev->suspend_count++) {
1884	spin_lock_irq(lock: &dev->txq.lock);
1885	/* don't autosuspend while transmitting */
1886	if (dev->txq.qlen && PMSG_IS_AUTO(message)) {
1887	dev->suspend_count--;
1888	spin_unlock_irq(lock: &dev->txq.lock);
1889	return -EBUSY;
1890	} else {
1891	set_bit(EVENT_DEV_ASLEEP, addr: &dev->flags);
1892	spin_unlock_irq(lock: &dev->txq.lock);
1893	}
1894	/*
1895	* accelerate emptying of the rx and queues, to avoid
1896	* having everything error out.
1897	*/
1898	netif_device_detach (dev: dev->net);
1899	usbnet_terminate_urbs(dev);
1900	__usbnet_status_stop_force(dev);
1901
1902	/*
1903	* reattach so runtime management can use and
1904	* wake the device
1905	*/
1906	netif_device_attach (dev: dev->net);
1907	}
1908	return 0;
1909	}
1910	EXPORT_SYMBOL_GPL(usbnet_suspend);
1911
1912	int usbnet_resume (struct usb_interface *intf)
1913	{
1914	struct usbnet *dev = usb_get_intfdata(intf);
1915	struct sk_buff *skb;
1916	struct urb *res;
1917	int retval;
1918
1919	if (!--dev->suspend_count) {
1920	/* resume interrupt URB if it was previously submitted */
1921	__usbnet_status_start_force(dev, GFP_NOIO);
1922
1923	spin_lock_irq(lock: &dev->txq.lock);
1924	while ((res = usb_get_from_anchor(anchor: &dev->deferred))) {
1925
1926	skb = (struct sk_buff *)res->context;
1927	retval = usb_submit_urb(urb: res, GFP_ATOMIC);
1928	if (retval < 0) {
1929	dev_kfree_skb_any(skb);
1930	kfree(objp: res->sg);
1931	usb_free_urb(urb: res);
1932	usb_autopm_put_interface_async(intf: dev->intf);
1933	} else {
1934	netif_trans_update(dev: dev->net);
1935	__skb_queue_tail(list: &dev->txq, newsk: skb);
1936	}
1937	}
1938
1939	smp_mb();
1940	clear_bit(EVENT_DEV_ASLEEP, addr: &dev->flags);
1941	spin_unlock_irq(lock: &dev->txq.lock);
1942
1943	if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
1944	/* handle remote wakeup ASAP
1945	* we cannot race against stop
1946	*/
1947	if (netif_device_present(dev: dev->net) &&
1948	!timer_pending(timer: &dev->delay) &&
1949	!test_bit(EVENT_RX_HALT, &dev->flags))
1950	rx_alloc_submit(dev, GFP_NOIO);
1951
1952	if (!(dev->txq.qlen >= TX_QLEN(dev)))
1953	netif_tx_wake_all_queues(dev: dev->net);
1954	tasklet_schedule (t: &dev->bh);
1955	}
1956	}
1957
1958	if (test_and_clear_bit(EVENT_DEVICE_REPORT_IDLE, addr: &dev->flags))
1959	usb_autopm_get_interface_no_resume(intf);
1960
1961	return 0;
1962	}
1963	EXPORT_SYMBOL_GPL(usbnet_resume);
1964
1965	/*
1966	* Either a subdriver implements manage_power, then it is assumed to always
1967	* be ready to be suspended or it reports the readiness to be suspended
1968	* explicitly
1969	*/
1970	void usbnet_device_suggests_idle(struct usbnet *dev)
1971	{
1972	if (!test_and_set_bit(EVENT_DEVICE_REPORT_IDLE, addr: &dev->flags)) {
1973	dev->intf->needs_remote_wakeup = 1;
1974	usb_autopm_put_interface_async(intf: dev->intf);
1975	}
1976	}
1977	EXPORT_SYMBOL(usbnet_device_suggests_idle);
1978
1979	/*
1980	* For devices that can do without special commands
1981	*/
1982	int usbnet_manage_power(struct usbnet *dev, int on)
1983	{
1984	dev->intf->needs_remote_wakeup = on;
1985	return 0;
1986	}
1987	EXPORT_SYMBOL(usbnet_manage_power);
1988
1989	void usbnet_link_change(struct usbnet *dev, bool link, bool need_reset)
1990	{
1991	/* update link after link is reseted */
1992	if (link && !need_reset)
1993	netif_carrier_on(dev: dev->net);
1994	else
1995	netif_carrier_off(dev: dev->net);
1996
1997	if (need_reset && link)
1998	usbnet_defer_kevent(dev, EVENT_LINK_RESET);
1999	else
2000	usbnet_defer_kevent(dev, EVENT_LINK_CHANGE);
2001	}
2002	EXPORT_SYMBOL(usbnet_link_change);
2003
2004	/*-------------------------------------------------------------------------*/
2005	static int __usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
2006	u16 value, u16 index, void *data, u16 size)
2007	{
2008	void *buf = NULL;
2009	int err = -ENOMEM;
2010
2011	netdev_dbg(dev->net, "usbnet_read_cmd cmd=0x%02x reqtype=%02x"
2012	" value=0x%04x index=0x%04x size=%d\n",
2013	cmd, reqtype, value, index, size);
2014
2015	if (size) {
2016	buf = kmalloc(size, GFP_NOIO);
2017	if (!buf)
2018	goto out;
2019	}
2020
2021	err = usb_control_msg(dev: dev->udev, usb_rcvctrlpipe(dev->udev, 0),
2022	request: cmd, requesttype: reqtype, value, index, data: buf, size,
2023	USB_CTRL_GET_TIMEOUT);
2024	if (err > 0 && err <= size) {
2025	if (data)
2026	memcpy(data, buf, err);
2027	else
2028	netdev_dbg(dev->net,
2029	"Huh? Data requested but thrown away.\n");
2030	}
2031	kfree(objp: buf);
2032	out:
2033	return err;
2034	}
2035
2036	static int __usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
2037	u16 value, u16 index, const void *data,
2038	u16 size)
2039	{
2040	void *buf = NULL;
2041	int err = -ENOMEM;
2042
2043	netdev_dbg(dev->net, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
2044	" value=0x%04x index=0x%04x size=%d\n",
2045	cmd, reqtype, value, index, size);
2046
2047	if (data) {
2048	buf = kmemdup(p: data, size, GFP_NOIO);
2049	if (!buf)
2050	goto out;
2051	} else {
2052	if (size) {
2053	WARN_ON_ONCE(1);
2054	err = -EINVAL;
2055	goto out;
2056	}
2057	}
2058
2059	err = usb_control_msg(dev: dev->udev, usb_sndctrlpipe(dev->udev, 0),
2060	request: cmd, requesttype: reqtype, value, index, data: buf, size,
2061	USB_CTRL_SET_TIMEOUT);
2062	kfree(objp: buf);
2063
2064	out:
2065	return err;
2066	}
2067
2068	/*
2069	* The function can't be called inside suspend/resume callback,
2070	* otherwise deadlock will be caused.
2071	*/
2072	int usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
2073	u16 value, u16 index, void *data, u16 size)
2074	{
2075	int ret;
2076
2077	if (usb_autopm_get_interface(intf: dev->intf) < 0)
2078	return -ENODEV;
2079	ret = __usbnet_read_cmd(dev, cmd, reqtype, value, index,
2080	data, size);
2081	usb_autopm_put_interface(intf: dev->intf);
2082	return ret;
2083	}
2084	EXPORT_SYMBOL_GPL(usbnet_read_cmd);
2085
2086	/*
2087	* The function can't be called inside suspend/resume callback,
2088	* otherwise deadlock will be caused.
2089	*/
2090	int usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
2091	u16 value, u16 index, const void *data, u16 size)
2092	{
2093	int ret;
2094
2095	if (usb_autopm_get_interface(intf: dev->intf) < 0)
2096	return -ENODEV;
2097	ret = __usbnet_write_cmd(dev, cmd, reqtype, value, index,
2098	data, size);
2099	usb_autopm_put_interface(intf: dev->intf);
2100	return ret;
2101	}
2102	EXPORT_SYMBOL_GPL(usbnet_write_cmd);
2103
2104	/*
2105	* The function can be called inside suspend/resume callback safely
2106	* and should only be called by suspend/resume callback generally.
2107	*/
2108	int usbnet_read_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype,
2109	u16 value, u16 index, void *data, u16 size)
2110	{
2111	return __usbnet_read_cmd(dev, cmd, reqtype, value, index,
2112	data, size);
2113	}
2114	EXPORT_SYMBOL_GPL(usbnet_read_cmd_nopm);
2115
2116	/*
2117	* The function can be called inside suspend/resume callback safely
2118	* and should only be called by suspend/resume callback generally.
2119	*/
2120	int usbnet_write_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype,
2121	u16 value, u16 index, const void *data,
2122	u16 size)
2123	{
2124	return __usbnet_write_cmd(dev, cmd, reqtype, value, index,
2125	data, size);
2126	}
2127	EXPORT_SYMBOL_GPL(usbnet_write_cmd_nopm);
2128
2129	static void usbnet_async_cmd_cb(struct urb *urb)
2130	{
2131	struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
2132	int status = urb->status;
2133
2134	if (status < 0)
2135	dev_dbg(&urb->dev->dev, "%s failed with %d",
2136	__func__, status);
2137
2138	kfree(objp: req);
2139	usb_free_urb(urb);
2140	}
2141
2142	/*
2143	* The caller must make sure that device can't be put into suspend
2144	* state until the control URB completes.
2145	*/
2146	int usbnet_write_cmd_async(struct usbnet *dev, u8 cmd, u8 reqtype,
2147	u16 value, u16 index, const void *data, u16 size)
2148	{
2149	struct usb_ctrlrequest *req;
2150	struct urb *urb;
2151	int err = -ENOMEM;
2152	void *buf = NULL;
2153
2154	netdev_dbg(dev->net, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
2155	" value=0x%04x index=0x%04x size=%d\n",
2156	cmd, reqtype, value, index, size);
2157
2158	urb = usb_alloc_urb(iso_packets: 0, GFP_ATOMIC);
2159	if (!urb)
2160	goto fail;
2161
2162	if (data) {
2163	buf = kmemdup(p: data, size, GFP_ATOMIC);
2164	if (!buf) {
2165	netdev_err(dev: dev->net, format: "Error allocating buffer"
2166	" in %s!\n", __func__);
2167	goto fail_free_urb;
2168	}
2169	}
2170
2171	req = kmalloc(size: sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
2172	if (!req)
2173	goto fail_free_buf;
2174
2175	req->bRequestType = reqtype;
2176	req->bRequest = cmd;
2177	req->wValue = cpu_to_le16(value);
2178	req->wIndex = cpu_to_le16(index);
2179	req->wLength = cpu_to_le16(size);
2180
2181	usb_fill_control_urb(urb, dev: dev->udev,
2182	usb_sndctrlpipe(dev->udev, 0),
2183	setup_packet: (void *)req, transfer_buffer: buf, buffer_length: size,
2184	complete_fn: usbnet_async_cmd_cb, context: req);
2185	urb->transfer_flags |= URB_FREE_BUFFER;
2186
2187	err = usb_submit_urb(urb, GFP_ATOMIC);
2188	if (err < 0) {
2189	netdev_err(dev: dev->net, format: "Error submitting the control"
2190	" message: status=%d\n", err);
2191	goto fail_free_all;
2192	}
2193	return 0;
2194
2195	fail_free_all:
2196	kfree(objp: req);
2197	fail_free_buf:
2198	kfree(objp: buf);
2199	/*
2200	* avoid a double free
2201	* needed because the flag can be set only
2202	* after filling the URB
2203	*/
2204	urb->transfer_flags = 0;
2205	fail_free_urb:
2206	usb_free_urb(urb);
2207	fail:
2208	return err;
2209
2210	}
2211	EXPORT_SYMBOL_GPL(usbnet_write_cmd_async);
2212	/*-------------------------------------------------------------------------*/
2213
2214	static int __init usbnet_init(void)
2215	{
2216	/* Compiler should optimize this out. */
2217	BUILD_BUG_ON(
2218	sizeof_field(struct sk_buff, cb) < sizeof(struct skb_data));
2219
2220	eth_random_addr(addr: node_id);
2221	return 0;
2222	}
2223	module_init(usbnet_init);
2224
2225	static void __exit usbnet_exit(void)
2226	{
2227	}
2228	module_exit(usbnet_exit);
2229
2230	MODULE_AUTHOR("David Brownell");
2231	MODULE_DESCRIPTION("USB network driver framework");
2232	MODULE_LICENSE("GPL");
2233