1 /*
2  * USB Network driver infrastructure
3  * Copyright (C) 2000-2005 by David Brownell
4  * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20 
21 /*
22  * This is a generic "USB networking" framework that works with several
23  * kinds of full and high speed networking devices:  host-to-host cables,
24  * smart usb peripherals, and actual Ethernet adapters.
25  *
26  * These devices usually differ in terms of control protocols (if they
27  * even have one!) and sometimes they define new framing to wrap or batch
28  * Ethernet packets.  Otherwise, they talk to USB pretty much the same,
29  * so interface (un)binding, endpoint I/O queues, fault handling, and other
30  * issues can usefully be addressed by this framework.
31  */
32 
33 // #define	DEBUG			// error path messages, extra info
34 // #define	VERBOSE			// more; success messages
35 
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/netdevice.h>
39 #include <linux/etherdevice.h>
40 #include <linux/ctype.h>
41 #include <linux/ethtool.h>
42 #include <linux/workqueue.h>
43 #include <linux/mii.h>
44 #include <linux/usb.h>
45 #include <linux/usb/usbnet.h>
46 #include <linux/slab.h>
47 #include <linux/kernel.h>
48 #include <linux/pm_runtime.h>
49 
50 #define DRIVER_VERSION		"22-Aug-2005"
51 
52 
53 /*-------------------------------------------------------------------------*/
54 
55 /*
56  * Nineteen USB 1.1 max size bulk transactions per frame (ms), max.
57  * Several dozen bytes of IPv4 data can fit in two such transactions.
58  * One maximum size Ethernet packet takes twenty four of them.
59  * For high speed, each frame comfortably fits almost 36 max size
60  * Ethernet packets (so queues should be bigger).
61  *
62  * REVISIT qlens should be members of 'struct usbnet'; the goal is to
63  * let the USB host controller be busy for 5msec or more before an irq
64  * is required, under load.  Jumbograms change the equation.
65  */
66 #define RX_MAX_QUEUE_MEMORY (60 * 1518)
67 #define	RX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? \
68 			(RX_MAX_QUEUE_MEMORY/(dev)->rx_urb_size) : 4)
69 #define	TX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? \
70 			(RX_MAX_QUEUE_MEMORY/(dev)->hard_mtu) : 4)
71 
72 // reawaken network queue this soon after stopping; else watchdog barks
73 #define TX_TIMEOUT_JIFFIES	(5*HZ)
74 
75 // throttle rx/tx briefly after some faults, so khubd might disconnect()
76 // us (it polls at HZ/4 usually) before we report too many false errors.
77 #define THROTTLE_JIFFIES	(HZ/8)
78 
79 // between wakeups
80 #define UNLINK_TIMEOUT_MS	3
81 
82 /*-------------------------------------------------------------------------*/
83 
84 // randomly generated ethernet address
85 static u8	node_id [ETH_ALEN];
86 
87 static const char driver_name [] = "usbnet";
88 
89 /* use ethtool to change the level for any given device */
90 static int msg_level = -1;
91 module_param (msg_level, int, 0);
92 MODULE_PARM_DESC (msg_level, "Override default message level");
93 
94 /*-------------------------------------------------------------------------*/
95 
96 /* handles CDC Ethernet and many other network "bulk data" interfaces */
usbnet_get_endpoints(struct usbnet * dev,struct usb_interface * intf)97 int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
98 {
99 	int				tmp;
100 	struct usb_host_interface	*alt = NULL;
101 	struct usb_host_endpoint	*in = NULL, *out = NULL;
102 	struct usb_host_endpoint	*status = NULL;
103 
104 	for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
105 		unsigned	ep;
106 
107 		in = out = status = NULL;
108 		alt = intf->altsetting + tmp;
109 
110 		/* take the first altsetting with in-bulk + out-bulk;
111 		 * remember any status endpoint, just in case;
112 		 * ignore other endpoints and altsetttings.
113 		 */
114 		for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
115 			struct usb_host_endpoint	*e;
116 			int				intr = 0;
117 
118 			e = alt->endpoint + ep;
119 			switch (e->desc.bmAttributes) {
120 			case USB_ENDPOINT_XFER_INT:
121 				if (!usb_endpoint_dir_in(&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(&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->udev, alt->desc.bInterfaceNumber,
149 				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 
usbnet_get_ethernet_addr(struct usbnet * dev,int iMACAddress)163 int usbnet_get_ethernet_addr(struct usbnet *dev, int iMACAddress)
164 {
165 	int 		tmp, i;
166 	unsigned char	buf [13];
167 
168 	tmp = usb_string(dev->udev, iMACAddress, buf, sizeof buf);
169 	if (tmp != 12) {
170 		dev_dbg(&dev->udev->dev,
171 			"bad MAC string %d fetch, %d\n", iMACAddress, tmp);
172 		if (tmp >= 0)
173 			tmp = -EINVAL;
174 		return tmp;
175 	}
176 	for (i = tmp = 0; i < 6; i++, tmp += 2)
177 		dev->net->dev_addr [i] =
178 			(hex_to_bin(buf[tmp]) << 4) + hex_to_bin(buf[tmp + 1]);
179 	return 0;
180 }
181 EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr);
182 
183 static void intr_complete (struct urb *urb);
184 
init_status(struct usbnet * dev,struct usb_interface * intf)185 static int init_status (struct usbnet *dev, struct usb_interface *intf)
186 {
187 	char		*buf = NULL;
188 	unsigned	pipe = 0;
189 	unsigned	maxp;
190 	unsigned	period;
191 
192 	if (!dev->driver_info->status)
193 		return 0;
194 
195 	pipe = usb_rcvintpipe (dev->udev,
196 			dev->status->desc.bEndpointAddress
197 				& USB_ENDPOINT_NUMBER_MASK);
198 	maxp = usb_maxpacket (dev->udev, pipe, 0);
199 
200 	/* avoid 1 msec chatter:  min 8 msec poll rate */
201 	period = max ((int) dev->status->desc.bInterval,
202 		(dev->udev->speed == USB_SPEED_HIGH) ? 7 : 3);
203 
204 	buf = kmalloc (maxp, GFP_KERNEL);
205 	if (buf) {
206 		dev->interrupt = usb_alloc_urb (0, GFP_KERNEL);
207 		if (!dev->interrupt) {
208 			kfree (buf);
209 			return -ENOMEM;
210 		} else {
211 			usb_fill_int_urb(dev->interrupt, dev->udev, pipe,
212 				buf, maxp, intr_complete, dev, period);
213 			dev_dbg(&intf->dev,
214 				"status ep%din, %d bytes period %d\n",
215 				usb_pipeendpoint(pipe), maxp, period);
216 		}
217 	}
218 	return 0;
219 }
220 
221 /* Passes this packet up the stack, updating its accounting.
222  * Some link protocols batch packets, so their rx_fixup paths
223  * can return clones as well as just modify the original skb.
224  */
usbnet_skb_return(struct usbnet * dev,struct sk_buff * skb)225 void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
226 {
227 	int	status;
228 
229 	if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
230 		skb_queue_tail(&dev->rxq_pause, skb);
231 		return;
232 	}
233 
234 	skb->protocol = eth_type_trans (skb, dev->net);
235 	dev->net->stats.rx_packets++;
236 	dev->net->stats.rx_bytes += skb->len;
237 
238 	netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
239 		  skb->len + sizeof (struct ethhdr), skb->protocol);
240 	memset (skb->cb, 0, sizeof (struct skb_data));
241 	status = netif_rx (skb);
242 	if (status != NET_RX_SUCCESS)
243 		netif_dbg(dev, rx_err, dev->net,
244 			  "netif_rx status %d\n", status);
245 }
246 EXPORT_SYMBOL_GPL(usbnet_skb_return);
247 
248 
249 /*-------------------------------------------------------------------------
250  *
251  * Network Device Driver (peer link to "Host Device", from USB host)
252  *
253  *-------------------------------------------------------------------------*/
254 
usbnet_change_mtu(struct net_device * net,int new_mtu)255 int usbnet_change_mtu (struct net_device *net, int new_mtu)
256 {
257 	struct usbnet	*dev = netdev_priv(net);
258 	int		ll_mtu = new_mtu + net->hard_header_len;
259 	int		old_hard_mtu = dev->hard_mtu;
260 	int		old_rx_urb_size = dev->rx_urb_size;
261 
262 	if (new_mtu <= 0)
263 		return -EINVAL;
264 	// no second zero-length packet read wanted after mtu-sized packets
265 	if ((ll_mtu % dev->maxpacket) == 0)
266 		return -EDOM;
267 	net->mtu = new_mtu;
268 
269 	dev->hard_mtu = net->mtu + net->hard_header_len;
270 	if (dev->rx_urb_size == old_hard_mtu) {
271 		dev->rx_urb_size = dev->hard_mtu;
272 		if (dev->rx_urb_size > old_rx_urb_size)
273 			usbnet_unlink_rx_urbs(dev);
274 	}
275 
276 	return 0;
277 }
278 EXPORT_SYMBOL_GPL(usbnet_change_mtu);
279 
280 /*-------------------------------------------------------------------------*/
281 
282 /* some LK 2.4 HCDs oopsed if we freed or resubmitted urbs from
283  * completion callbacks.  2.5 should have fixed those bugs...
284  */
285 
defer_bh(struct usbnet * dev,struct sk_buff * skb,struct sk_buff_head * list)286 static void defer_bh(struct usbnet *dev, struct sk_buff *skb, struct sk_buff_head *list)
287 {
288 	unsigned long		flags;
289 
290 	spin_lock_irqsave(&list->lock, flags);
291 	__skb_unlink(skb, list);
292 	spin_unlock(&list->lock);
293 	spin_lock(&dev->done.lock);
294 	__skb_queue_tail(&dev->done, skb);
295 	if (dev->done.qlen == 1)
296 		tasklet_schedule(&dev->bh);
297 	spin_unlock_irqrestore(&dev->done.lock, flags);
298 }
299 
300 /* some work can't be done in tasklets, so we use keventd
301  *
302  * NOTE:  annoying asymmetry:  if it's active, schedule_work() fails,
303  * but tasklet_schedule() doesn't.  hope the failure is rare.
304  */
usbnet_defer_kevent(struct usbnet * dev,int work)305 void usbnet_defer_kevent (struct usbnet *dev, int work)
306 {
307 	set_bit (work, &dev->flags);
308 	if (!schedule_work (&dev->kevent))
309 		netdev_err(dev->net, "kevent %d may have been dropped\n", work);
310 	else
311 		netdev_dbg(dev->net, "kevent %d scheduled\n", work);
312 }
313 EXPORT_SYMBOL_GPL(usbnet_defer_kevent);
314 
315 /*-------------------------------------------------------------------------*/
316 
317 static void rx_complete (struct urb *urb);
318 
rx_submit(struct usbnet * dev,struct urb * urb,gfp_t flags)319 static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
320 {
321 	struct sk_buff		*skb;
322 	struct skb_data		*entry;
323 	int			retval = 0;
324 	unsigned long		lockflags;
325 	size_t			size = dev->rx_urb_size;
326 
327 	if ((skb = alloc_skb (size + NET_IP_ALIGN, flags)) == NULL) {
328 		netif_dbg(dev, rx_err, dev->net, "no rx skb\n");
329 		usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
330 		usb_free_urb (urb);
331 		return -ENOMEM;
332 	}
333 	skb_reserve (skb, NET_IP_ALIGN);
334 
335 	entry = (struct skb_data *) skb->cb;
336 	entry->urb = urb;
337 	entry->dev = dev;
338 	entry->state = rx_start;
339 	entry->length = 0;
340 
341 	usb_fill_bulk_urb (urb, dev->udev, dev->in,
342 		skb->data, size, rx_complete, skb);
343 
344 	spin_lock_irqsave (&dev->rxq.lock, lockflags);
345 
346 	if (netif_running (dev->net) &&
347 	    netif_device_present (dev->net) &&
348 	    !test_bit (EVENT_RX_HALT, &dev->flags) &&
349 	    !test_bit (EVENT_DEV_ASLEEP, &dev->flags)) {
350 		switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {
351 		case -EPIPE:
352 			usbnet_defer_kevent (dev, EVENT_RX_HALT);
353 			break;
354 		case -ENOMEM:
355 			usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
356 			break;
357 		case -ENODEV:
358 			netif_dbg(dev, ifdown, dev->net, "device gone\n");
359 			netif_device_detach (dev->net);
360 			break;
361 		case -EHOSTUNREACH:
362 			retval = -ENOLINK;
363 			break;
364 		default:
365 			netif_dbg(dev, rx_err, dev->net,
366 				  "rx submit, %d\n", retval);
367 			tasklet_schedule (&dev->bh);
368 			break;
369 		case 0:
370 			__skb_queue_tail (&dev->rxq, skb);
371 		}
372 	} else {
373 		netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
374 		retval = -ENOLINK;
375 	}
376 	spin_unlock_irqrestore (&dev->rxq.lock, lockflags);
377 	if (retval) {
378 		dev_kfree_skb_any (skb);
379 		usb_free_urb (urb);
380 	}
381 	return retval;
382 }
383 
384 
385 /*-------------------------------------------------------------------------*/
386 
rx_process(struct usbnet * dev,struct sk_buff * skb)387 static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
388 {
389 	if (dev->driver_info->rx_fixup &&
390 	    !dev->driver_info->rx_fixup (dev, skb)) {
391 		/* With RX_ASSEMBLE, rx_fixup() must update counters */
392 		if (!(dev->driver_info->flags & FLAG_RX_ASSEMBLE))
393 			dev->net->stats.rx_errors++;
394 		goto done;
395 	}
396 	// else network stack removes extra byte if we forced a short packet
397 
398 	if (skb->len) {
399 		/* all data was already cloned from skb inside the driver */
400 		if (dev->driver_info->flags & FLAG_MULTI_PACKET)
401 			dev_kfree_skb_any(skb);
402 		else
403 			usbnet_skb_return(dev, skb);
404 		return;
405 	}
406 
407 	netif_dbg(dev, rx_err, dev->net, "drop\n");
408 	dev->net->stats.rx_errors++;
409 done:
410 	skb_queue_tail(&dev->done, skb);
411 }
412 
413 /*-------------------------------------------------------------------------*/
414 
rx_complete(struct urb * urb)415 static void rx_complete (struct urb *urb)
416 {
417 	struct sk_buff		*skb = (struct sk_buff *) urb->context;
418 	struct skb_data		*entry = (struct skb_data *) skb->cb;
419 	struct usbnet		*dev = entry->dev;
420 	int			urb_status = urb->status;
421 
422 	skb_put (skb, urb->actual_length);
423 	entry->state = rx_done;
424 	entry->urb = NULL;
425 
426 	switch (urb_status) {
427 	/* success */
428 	case 0:
429 		if (skb->len < dev->net->hard_header_len) {
430 			entry->state = rx_cleanup;
431 			dev->net->stats.rx_errors++;
432 			dev->net->stats.rx_length_errors++;
433 			netif_dbg(dev, rx_err, dev->net,
434 				  "rx length %d\n", skb->len);
435 		}
436 		break;
437 
438 	/* stalls need manual reset. this is rare ... except that
439 	 * when going through USB 2.0 TTs, unplug appears this way.
440 	 * we avoid the highspeed version of the ETIMEDOUT/EILSEQ
441 	 * storm, recovering as needed.
442 	 */
443 	case -EPIPE:
444 		dev->net->stats.rx_errors++;
445 		usbnet_defer_kevent (dev, EVENT_RX_HALT);
446 		// FALLTHROUGH
447 
448 	/* software-driven interface shutdown */
449 	case -ECONNRESET:		/* async unlink */
450 	case -ESHUTDOWN:		/* hardware gone */
451 		netif_dbg(dev, ifdown, dev->net,
452 			  "rx shutdown, code %d\n", urb_status);
453 		goto block;
454 
455 	/* we get controller i/o faults during khubd disconnect() delays.
456 	 * throttle down resubmits, to avoid log floods; just temporarily,
457 	 * so we still recover when the fault isn't a khubd delay.
458 	 */
459 	case -EPROTO:
460 	case -ETIME:
461 	case -EILSEQ:
462 		dev->net->stats.rx_errors++;
463 		if (!timer_pending (&dev->delay)) {
464 			mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);
465 			netif_dbg(dev, link, dev->net,
466 				  "rx throttle %d\n", urb_status);
467 		}
468 block:
469 		entry->state = rx_cleanup;
470 		entry->urb = urb;
471 		urb = NULL;
472 		break;
473 
474 	/* data overrun ... flush fifo? */
475 	case -EOVERFLOW:
476 		dev->net->stats.rx_over_errors++;
477 		// FALLTHROUGH
478 
479 	default:
480 		entry->state = rx_cleanup;
481 		dev->net->stats.rx_errors++;
482 		netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
483 		break;
484 	}
485 
486 	defer_bh(dev, skb, &dev->rxq);
487 
488 	if (urb) {
489 		if (netif_running (dev->net) &&
490 		    !test_bit (EVENT_RX_HALT, &dev->flags)) {
491 			rx_submit (dev, urb, GFP_ATOMIC);
492 			return;
493 		}
494 		usb_free_urb (urb);
495 	}
496 	netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
497 }
498 
intr_complete(struct urb * urb)499 static void intr_complete (struct urb *urb)
500 {
501 	struct usbnet	*dev = urb->context;
502 	int		status = urb->status;
503 
504 	switch (status) {
505 	/* success */
506 	case 0:
507 		dev->driver_info->status(dev, urb);
508 		break;
509 
510 	/* software-driven interface shutdown */
511 	case -ENOENT:		/* urb killed */
512 	case -ESHUTDOWN:	/* hardware gone */
513 		netif_dbg(dev, ifdown, dev->net,
514 			  "intr shutdown, code %d\n", status);
515 		return;
516 
517 	/* NOTE:  not throttling like RX/TX, since this endpoint
518 	 * already polls infrequently
519 	 */
520 	default:
521 		netdev_dbg(dev->net, "intr status %d\n", status);
522 		break;
523 	}
524 
525 	if (!netif_running (dev->net))
526 		return;
527 
528 	memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
529 	status = usb_submit_urb (urb, GFP_ATOMIC);
530 	if (status != 0)
531 		netif_err(dev, timer, dev->net,
532 			  "intr resubmit --> %d\n", status);
533 }
534 
535 /*-------------------------------------------------------------------------*/
usbnet_pause_rx(struct usbnet * dev)536 void usbnet_pause_rx(struct usbnet *dev)
537 {
538 	set_bit(EVENT_RX_PAUSED, &dev->flags);
539 
540 	netif_dbg(dev, rx_status, dev->net, "paused rx queue enabled\n");
541 }
542 EXPORT_SYMBOL_GPL(usbnet_pause_rx);
543 
usbnet_resume_rx(struct usbnet * dev)544 void usbnet_resume_rx(struct usbnet *dev)
545 {
546 	struct sk_buff *skb;
547 	int num = 0;
548 
549 	clear_bit(EVENT_RX_PAUSED, &dev->flags);
550 
551 	while ((skb = skb_dequeue(&dev->rxq_pause)) != NULL) {
552 		usbnet_skb_return(dev, skb);
553 		num++;
554 	}
555 
556 	tasklet_schedule(&dev->bh);
557 
558 	netif_dbg(dev, rx_status, dev->net,
559 		  "paused rx queue disabled, %d skbs requeued\n", num);
560 }
561 EXPORT_SYMBOL_GPL(usbnet_resume_rx);
562 
usbnet_purge_paused_rxq(struct usbnet * dev)563 void usbnet_purge_paused_rxq(struct usbnet *dev)
564 {
565 	skb_queue_purge(&dev->rxq_pause);
566 }
567 EXPORT_SYMBOL_GPL(usbnet_purge_paused_rxq);
568 
569 /*-------------------------------------------------------------------------*/
570 
571 // unlink pending rx/tx; completion handlers do all other cleanup
572 
unlink_urbs(struct usbnet * dev,struct sk_buff_head * q)573 static int unlink_urbs (struct usbnet *dev, struct sk_buff_head *q)
574 {
575 	unsigned long		flags;
576 	struct sk_buff		*skb, *skbnext;
577 	int			count = 0;
578 
579 	spin_lock_irqsave (&q->lock, flags);
580 	skb_queue_walk_safe(q, skb, skbnext) {
581 		struct skb_data		*entry;
582 		struct urb		*urb;
583 		int			retval;
584 
585 		entry = (struct skb_data *) skb->cb;
586 		urb = entry->urb;
587 
588 		// during some PM-driven resume scenarios,
589 		// these (async) unlinks complete immediately
590 		retval = usb_unlink_urb (urb);
591 		if (retval != -EINPROGRESS && retval != 0)
592 			netdev_dbg(dev->net, "unlink urb err, %d\n", retval);
593 		else
594 			count++;
595 	}
596 	spin_unlock_irqrestore (&q->lock, flags);
597 	return count;
598 }
599 
600 // Flush all pending rx urbs
601 // minidrivers may need to do this when the MTU changes
602 
usbnet_unlink_rx_urbs(struct usbnet * dev)603 void usbnet_unlink_rx_urbs(struct usbnet *dev)
604 {
605 	if (netif_running(dev->net)) {
606 		(void) unlink_urbs (dev, &dev->rxq);
607 		tasklet_schedule(&dev->bh);
608 	}
609 }
610 EXPORT_SYMBOL_GPL(usbnet_unlink_rx_urbs);
611 
612 /*-------------------------------------------------------------------------*/
613 
614 // precondition: never called in_interrupt
usbnet_terminate_urbs(struct usbnet * dev)615 static void usbnet_terminate_urbs(struct usbnet *dev)
616 {
617 	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
618 	DECLARE_WAITQUEUE(wait, current);
619 	int temp;
620 
621 	/* ensure there are no more active urbs */
622 	add_wait_queue(&unlink_wakeup, &wait);
623 	set_current_state(TASK_UNINTERRUPTIBLE);
624 	dev->wait = &unlink_wakeup;
625 	temp = unlink_urbs(dev, &dev->txq) +
626 		unlink_urbs(dev, &dev->rxq);
627 
628 	/* maybe wait for deletions to finish. */
629 	while (!skb_queue_empty(&dev->rxq)
630 		&& !skb_queue_empty(&dev->txq)
631 		&& !skb_queue_empty(&dev->done)) {
632 			schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
633 			set_current_state(TASK_UNINTERRUPTIBLE);
634 			netif_dbg(dev, ifdown, dev->net,
635 				  "waited for %d urb completions\n", temp);
636 	}
637 	set_current_state(TASK_RUNNING);
638 	dev->wait = NULL;
639 	remove_wait_queue(&unlink_wakeup, &wait);
640 }
641 
usbnet_stop(struct net_device * net)642 int usbnet_stop (struct net_device *net)
643 {
644 	struct usbnet		*dev = netdev_priv(net);
645 	struct driver_info	*info = dev->driver_info;
646 	int			retval;
647 
648 	clear_bit(EVENT_DEV_OPEN, &dev->flags);
649 	netif_stop_queue (net);
650 
651 	netif_info(dev, ifdown, dev->net,
652 		   "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
653 		   net->stats.rx_packets, net->stats.tx_packets,
654 		   net->stats.rx_errors, net->stats.tx_errors);
655 
656 	/* allow minidriver to stop correctly (wireless devices to turn off
657 	 * radio etc) */
658 	if (info->stop) {
659 		retval = info->stop(dev);
660 		if (retval < 0)
661 			netif_info(dev, ifdown, dev->net,
662 				   "stop fail (%d) usbnet usb-%s-%s, %s\n",
663 				   retval,
664 				   dev->udev->bus->bus_name, dev->udev->devpath,
665 				   info->description);
666 	}
667 
668 	if (!(info->flags & FLAG_AVOID_UNLINK_URBS))
669 		usbnet_terminate_urbs(dev);
670 
671 	usb_kill_urb(dev->interrupt);
672 
673 	usbnet_purge_paused_rxq(dev);
674 
675 	/* deferred work (task, timer, softirq) must also stop.
676 	 * can't flush_scheduled_work() until we drop rtnl (later),
677 	 * else workers could deadlock; so make workers a NOP.
678 	 */
679 	dev->flags = 0;
680 	del_timer_sync (&dev->delay);
681 	tasklet_kill (&dev->bh);
682 	if (info->manage_power)
683 		info->manage_power(dev, 0);
684 	else
685 		usb_autopm_put_interface(dev->intf);
686 
687 	return 0;
688 }
689 EXPORT_SYMBOL_GPL(usbnet_stop);
690 
691 /*-------------------------------------------------------------------------*/
692 
693 // posts reads, and enables write queuing
694 
695 // precondition: never called in_interrupt
696 
usbnet_open(struct net_device * net)697 int usbnet_open (struct net_device *net)
698 {
699 	struct usbnet		*dev = netdev_priv(net);
700 	int			retval;
701 	struct driver_info	*info = dev->driver_info;
702 
703 	if ((retval = usb_autopm_get_interface(dev->intf)) < 0) {
704 		netif_info(dev, ifup, dev->net,
705 			   "resumption fail (%d) usbnet usb-%s-%s, %s\n",
706 			   retval,
707 			   dev->udev->bus->bus_name,
708 			   dev->udev->devpath,
709 			   info->description);
710 		goto done_nopm;
711 	}
712 
713 	// put into "known safe" state
714 	if (info->reset && (retval = info->reset (dev)) < 0) {
715 		netif_info(dev, ifup, dev->net,
716 			   "open reset fail (%d) usbnet usb-%s-%s, %s\n",
717 			   retval,
718 			   dev->udev->bus->bus_name,
719 			   dev->udev->devpath,
720 			   info->description);
721 		goto done;
722 	}
723 
724 	// insist peer be connected
725 	if (info->check_connect && (retval = info->check_connect (dev)) < 0) {
726 		netif_dbg(dev, ifup, dev->net, "can't open; %d\n", retval);
727 		goto done;
728 	}
729 
730 	/* start any status interrupt transfer */
731 	if (dev->interrupt) {
732 		retval = usb_submit_urb (dev->interrupt, GFP_KERNEL);
733 		if (retval < 0) {
734 			netif_err(dev, ifup, dev->net,
735 				  "intr submit %d\n", retval);
736 			goto done;
737 		}
738 	}
739 
740 	set_bit(EVENT_DEV_OPEN, &dev->flags);
741 	netif_start_queue (net);
742 	netif_info(dev, ifup, dev->net,
743 		   "open: enable queueing (rx %d, tx %d) mtu %d %s framing\n",
744 		   (int)RX_QLEN(dev), (int)TX_QLEN(dev),
745 		   dev->net->mtu,
746 		   (dev->driver_info->flags & FLAG_FRAMING_NC) ? "NetChip" :
747 		   (dev->driver_info->flags & FLAG_FRAMING_GL) ? "GeneSys" :
748 		   (dev->driver_info->flags & FLAG_FRAMING_Z) ? "Zaurus" :
749 		   (dev->driver_info->flags & FLAG_FRAMING_RN) ? "RNDIS" :
750 		   (dev->driver_info->flags & FLAG_FRAMING_AX) ? "ASIX" :
751 		   "simple");
752 
753 	// delay posting reads until we're fully open
754 	tasklet_schedule (&dev->bh);
755 	if (info->manage_power) {
756 		retval = info->manage_power(dev, 1);
757 		if (retval < 0)
758 			goto done;
759 		usb_autopm_put_interface(dev->intf);
760 	}
761 	return retval;
762 
763 done:
764 	usb_autopm_put_interface(dev->intf);
765 done_nopm:
766 	return retval;
767 }
768 EXPORT_SYMBOL_GPL(usbnet_open);
769 
770 /*-------------------------------------------------------------------------*/
771 
772 /* ethtool methods; minidrivers may need to add some more, but
773  * they'll probably want to use this base set.
774  */
775 
usbnet_get_settings(struct net_device * net,struct ethtool_cmd * cmd)776 int usbnet_get_settings (struct net_device *net, struct ethtool_cmd *cmd)
777 {
778 	struct usbnet *dev = netdev_priv(net);
779 
780 	if (!dev->mii.mdio_read)
781 		return -EOPNOTSUPP;
782 
783 	return mii_ethtool_gset(&dev->mii, cmd);
784 }
785 EXPORT_SYMBOL_GPL(usbnet_get_settings);
786 
usbnet_set_settings(struct net_device * net,struct ethtool_cmd * cmd)787 int usbnet_set_settings (struct net_device *net, struct ethtool_cmd *cmd)
788 {
789 	struct usbnet *dev = netdev_priv(net);
790 	int retval;
791 
792 	if (!dev->mii.mdio_write)
793 		return -EOPNOTSUPP;
794 
795 	retval = mii_ethtool_sset(&dev->mii, cmd);
796 
797 	/* link speed/duplex might have changed */
798 	if (dev->driver_info->link_reset)
799 		dev->driver_info->link_reset(dev);
800 
801 	return retval;
802 
803 }
804 EXPORT_SYMBOL_GPL(usbnet_set_settings);
805 
usbnet_get_link(struct net_device * net)806 u32 usbnet_get_link (struct net_device *net)
807 {
808 	struct usbnet *dev = netdev_priv(net);
809 
810 	/* If a check_connect is defined, return its result */
811 	if (dev->driver_info->check_connect)
812 		return dev->driver_info->check_connect (dev) == 0;
813 
814 	/* if the device has mii operations, use those */
815 	if (dev->mii.mdio_read)
816 		return mii_link_ok(&dev->mii);
817 
818 	/* Otherwise, dtrt for drivers calling netif_carrier_{on,off} */
819 	return ethtool_op_get_link(net);
820 }
821 EXPORT_SYMBOL_GPL(usbnet_get_link);
822 
usbnet_nway_reset(struct net_device * net)823 int usbnet_nway_reset(struct net_device *net)
824 {
825 	struct usbnet *dev = netdev_priv(net);
826 
827 	if (!dev->mii.mdio_write)
828 		return -EOPNOTSUPP;
829 
830 	return mii_nway_restart(&dev->mii);
831 }
832 EXPORT_SYMBOL_GPL(usbnet_nway_reset);
833 
usbnet_get_drvinfo(struct net_device * net,struct ethtool_drvinfo * info)834 void usbnet_get_drvinfo (struct net_device *net, struct ethtool_drvinfo *info)
835 {
836 	struct usbnet *dev = netdev_priv(net);
837 
838 	strncpy (info->driver, dev->driver_name, sizeof info->driver);
839 	strncpy (info->version, DRIVER_VERSION, sizeof info->version);
840 	strncpy (info->fw_version, dev->driver_info->description,
841 		sizeof info->fw_version);
842 	usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info);
843 }
844 EXPORT_SYMBOL_GPL(usbnet_get_drvinfo);
845 
usbnet_get_msglevel(struct net_device * net)846 u32 usbnet_get_msglevel (struct net_device *net)
847 {
848 	struct usbnet *dev = netdev_priv(net);
849 
850 	return dev->msg_enable;
851 }
852 EXPORT_SYMBOL_GPL(usbnet_get_msglevel);
853 
usbnet_set_msglevel(struct net_device * net,u32 level)854 void usbnet_set_msglevel (struct net_device *net, u32 level)
855 {
856 	struct usbnet *dev = netdev_priv(net);
857 
858 	dev->msg_enable = level;
859 }
860 EXPORT_SYMBOL_GPL(usbnet_set_msglevel);
861 
862 /* drivers may override default ethtool_ops in their bind() routine */
863 static const struct ethtool_ops usbnet_ethtool_ops = {
864 	.get_settings		= usbnet_get_settings,
865 	.set_settings		= usbnet_set_settings,
866 	.get_link		= usbnet_get_link,
867 	.nway_reset		= usbnet_nway_reset,
868 	.get_drvinfo		= usbnet_get_drvinfo,
869 	.get_msglevel		= usbnet_get_msglevel,
870 	.set_msglevel		= usbnet_set_msglevel,
871 };
872 
873 /*-------------------------------------------------------------------------*/
874 
875 /* work that cannot be done in interrupt context uses keventd.
876  *
877  * NOTE:  with 2.5 we could do more of this using completion callbacks,
878  * especially now that control transfers can be queued.
879  */
880 static void
kevent(struct work_struct * work)881 kevent (struct work_struct *work)
882 {
883 	struct usbnet		*dev =
884 		container_of(work, struct usbnet, kevent);
885 	int			status;
886 
887 	/* usb_clear_halt() needs a thread context */
888 	if (test_bit (EVENT_TX_HALT, &dev->flags)) {
889 		unlink_urbs (dev, &dev->txq);
890 		status = usb_autopm_get_interface(dev->intf);
891 		if (status < 0)
892 			goto fail_pipe;
893 		status = usb_clear_halt (dev->udev, dev->out);
894 		usb_autopm_put_interface(dev->intf);
895 		if (status < 0 &&
896 		    status != -EPIPE &&
897 		    status != -ESHUTDOWN) {
898 			if (netif_msg_tx_err (dev))
899 fail_pipe:
900 				netdev_err(dev->net, "can't clear tx halt, status %d\n",
901 					   status);
902 		} else {
903 			clear_bit (EVENT_TX_HALT, &dev->flags);
904 			if (status != -ESHUTDOWN)
905 				netif_wake_queue (dev->net);
906 		}
907 	}
908 	if (test_bit (EVENT_RX_HALT, &dev->flags)) {
909 		unlink_urbs (dev, &dev->rxq);
910 		status = usb_autopm_get_interface(dev->intf);
911 		if (status < 0)
912 			goto fail_halt;
913 		status = usb_clear_halt (dev->udev, dev->in);
914 		usb_autopm_put_interface(dev->intf);
915 		if (status < 0 &&
916 		    status != -EPIPE &&
917 		    status != -ESHUTDOWN) {
918 			if (netif_msg_rx_err (dev))
919 fail_halt:
920 				netdev_err(dev->net, "can't clear rx halt, status %d\n",
921 					   status);
922 		} else {
923 			clear_bit (EVENT_RX_HALT, &dev->flags);
924 			tasklet_schedule (&dev->bh);
925 		}
926 	}
927 
928 	/* tasklet could resubmit itself forever if memory is tight */
929 	if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {
930 		struct urb	*urb = NULL;
931 		int resched = 1;
932 
933 		if (netif_running (dev->net))
934 			urb = usb_alloc_urb (0, GFP_KERNEL);
935 		else
936 			clear_bit (EVENT_RX_MEMORY, &dev->flags);
937 		if (urb != NULL) {
938 			clear_bit (EVENT_RX_MEMORY, &dev->flags);
939 			status = usb_autopm_get_interface(dev->intf);
940 			if (status < 0) {
941 				usb_free_urb(urb);
942 				goto fail_lowmem;
943 			}
944 			if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK)
945 				resched = 0;
946 			usb_autopm_put_interface(dev->intf);
947 fail_lowmem:
948 			if (resched)
949 				tasklet_schedule (&dev->bh);
950 		}
951 	}
952 
953 	if (test_bit (EVENT_LINK_RESET, &dev->flags)) {
954 		struct driver_info	*info = dev->driver_info;
955 		int			retval = 0;
956 
957 		clear_bit (EVENT_LINK_RESET, &dev->flags);
958 		status = usb_autopm_get_interface(dev->intf);
959 		if (status < 0)
960 			goto skip_reset;
961 		if(info->link_reset && (retval = info->link_reset(dev)) < 0) {
962 			usb_autopm_put_interface(dev->intf);
963 skip_reset:
964 			netdev_info(dev->net, "link reset failed (%d) usbnet usb-%s-%s, %s\n",
965 				    retval,
966 				    dev->udev->bus->bus_name,
967 				    dev->udev->devpath,
968 				    info->description);
969 		} else {
970 			usb_autopm_put_interface(dev->intf);
971 		}
972 	}
973 
974 	if (dev->flags)
975 		netdev_dbg(dev->net, "kevent done, flags = 0x%lx\n", dev->flags);
976 }
977 
978 /*-------------------------------------------------------------------------*/
979 
tx_complete(struct urb * urb)980 static void tx_complete (struct urb *urb)
981 {
982 	struct sk_buff		*skb = (struct sk_buff *) urb->context;
983 	struct skb_data		*entry = (struct skb_data *) skb->cb;
984 	struct usbnet		*dev = entry->dev;
985 
986 	if (urb->status == 0) {
987 		if (!(dev->driver_info->flags & FLAG_MULTI_PACKET))
988 			dev->net->stats.tx_packets++;
989 		dev->net->stats.tx_bytes += entry->length;
990 	} else {
991 		dev->net->stats.tx_errors++;
992 
993 		switch (urb->status) {
994 		case -EPIPE:
995 			usbnet_defer_kevent (dev, EVENT_TX_HALT);
996 			break;
997 
998 		/* software-driven interface shutdown */
999 		case -ECONNRESET:		// async unlink
1000 		case -ESHUTDOWN:		// hardware gone
1001 			break;
1002 
1003 		// like rx, tx gets controller i/o faults during khubd delays
1004 		// and so it uses the same throttling mechanism.
1005 		case -EPROTO:
1006 		case -ETIME:
1007 		case -EILSEQ:
1008 			usb_mark_last_busy(dev->udev);
1009 			if (!timer_pending (&dev->delay)) {
1010 				mod_timer (&dev->delay,
1011 					jiffies + THROTTLE_JIFFIES);
1012 				netif_dbg(dev, link, dev->net,
1013 					  "tx throttle %d\n", urb->status);
1014 			}
1015 			netif_stop_queue (dev->net);
1016 			break;
1017 		default:
1018 			netif_dbg(dev, tx_err, dev->net,
1019 				  "tx err %d\n", entry->urb->status);
1020 			break;
1021 		}
1022 	}
1023 
1024 	usb_autopm_put_interface_async(dev->intf);
1025 	urb->dev = NULL;
1026 	entry->state = tx_done;
1027 	defer_bh(dev, skb, &dev->txq);
1028 }
1029 
1030 /*-------------------------------------------------------------------------*/
1031 
usbnet_tx_timeout(struct net_device * net)1032 void usbnet_tx_timeout (struct net_device *net)
1033 {
1034 	struct usbnet		*dev = netdev_priv(net);
1035 
1036 	unlink_urbs (dev, &dev->txq);
1037 	tasklet_schedule (&dev->bh);
1038 
1039 	// FIXME: device recovery -- reset?
1040 }
1041 EXPORT_SYMBOL_GPL(usbnet_tx_timeout);
1042 
1043 /*-------------------------------------------------------------------------*/
1044 
usbnet_start_xmit(struct sk_buff * skb,struct net_device * net)1045 netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,
1046 				     struct net_device *net)
1047 {
1048 	struct usbnet		*dev = netdev_priv(net);
1049 	int			length;
1050 	struct urb		*urb = NULL;
1051 	struct skb_data		*entry;
1052 	struct driver_info	*info = dev->driver_info;
1053 	unsigned long		flags;
1054 	int retval;
1055 
1056 	// some devices want funky USB-level framing, for
1057 	// win32 driver (usually) and/or hardware quirks
1058 	if (info->tx_fixup) {
1059 		skb = info->tx_fixup (dev, skb, GFP_ATOMIC);
1060 		if (!skb) {
1061 			if (netif_msg_tx_err(dev)) {
1062 				netif_dbg(dev, tx_err, dev->net, "can't tx_fixup skb\n");
1063 				goto drop;
1064 			} else {
1065 				/* cdc_ncm collected packet; waits for more */
1066 				goto not_drop;
1067 			}
1068 		}
1069 	}
1070 	length = skb->len;
1071 
1072 	if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) {
1073 		netif_dbg(dev, tx_err, dev->net, "no urb\n");
1074 		goto drop;
1075 	}
1076 
1077 	entry = (struct skb_data *) skb->cb;
1078 	entry->urb = urb;
1079 	entry->dev = dev;
1080 	entry->state = tx_start;
1081 	entry->length = length;
1082 
1083 	usb_fill_bulk_urb (urb, dev->udev, dev->out,
1084 			skb->data, skb->len, tx_complete, skb);
1085 
1086 	/* don't assume the hardware handles USB_ZERO_PACKET
1087 	 * NOTE:  strictly conforming cdc-ether devices should expect
1088 	 * the ZLP here, but ignore the one-byte packet.
1089 	 * NOTE2: CDC NCM specification is different from CDC ECM when
1090 	 * handling ZLP/short packets, so cdc_ncm driver will make short
1091 	 * packet itself if needed.
1092 	 */
1093 	if (length % dev->maxpacket == 0) {
1094 		if (!(info->flags & FLAG_SEND_ZLP)) {
1095 			if (!(info->flags & FLAG_MULTI_PACKET)) {
1096 				urb->transfer_buffer_length++;
1097 				if (skb_tailroom(skb)) {
1098 					skb->data[skb->len] = 0;
1099 					__skb_put(skb, 1);
1100 				}
1101 			}
1102 		} else
1103 			urb->transfer_flags |= URB_ZERO_PACKET;
1104 	}
1105 
1106 	spin_lock_irqsave(&dev->txq.lock, flags);
1107 	retval = usb_autopm_get_interface_async(dev->intf);
1108 	if (retval < 0) {
1109 		spin_unlock_irqrestore(&dev->txq.lock, flags);
1110 		goto drop;
1111 	}
1112 
1113 #ifdef CONFIG_PM
1114 	/* if this triggers the device is still a sleep */
1115 	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
1116 		/* transmission will be done in resume */
1117 		usb_anchor_urb(urb, &dev->deferred);
1118 		/* no use to process more packets */
1119 		netif_stop_queue(net);
1120 		spin_unlock_irqrestore(&dev->txq.lock, flags);
1121 		netdev_dbg(dev->net, "Delaying transmission for resumption\n");
1122 		goto deferred;
1123 	}
1124 #endif
1125 
1126 	switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) {
1127 	case -EPIPE:
1128 		netif_stop_queue (net);
1129 		usbnet_defer_kevent (dev, EVENT_TX_HALT);
1130 		usb_autopm_put_interface_async(dev->intf);
1131 		break;
1132 	default:
1133 		usb_autopm_put_interface_async(dev->intf);
1134 		netif_dbg(dev, tx_err, dev->net,
1135 			  "tx: submit urb err %d\n", retval);
1136 		break;
1137 	case 0:
1138 		net->trans_start = jiffies;
1139 		__skb_queue_tail (&dev->txq, skb);
1140 		if (dev->txq.qlen >= TX_QLEN (dev))
1141 			netif_stop_queue (net);
1142 	}
1143 	spin_unlock_irqrestore (&dev->txq.lock, flags);
1144 
1145 	if (retval) {
1146 		netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", retval);
1147 drop:
1148 		dev->net->stats.tx_dropped++;
1149 not_drop:
1150 		if (skb)
1151 			dev_kfree_skb_any (skb);
1152 		usb_free_urb (urb);
1153 	} else
1154 		netif_dbg(dev, tx_queued, dev->net,
1155 			  "> tx, len %d, type 0x%x\n", length, skb->protocol);
1156 #ifdef CONFIG_PM
1157 deferred:
1158 #endif
1159 	return NETDEV_TX_OK;
1160 }
1161 EXPORT_SYMBOL_GPL(usbnet_start_xmit);
1162 
1163 /*-------------------------------------------------------------------------*/
1164 
1165 // tasklet (work deferred from completions, in_irq) or timer
1166 
usbnet_bh(unsigned long param)1167 static void usbnet_bh (unsigned long param)
1168 {
1169 	struct usbnet		*dev = (struct usbnet *) param;
1170 	struct sk_buff		*skb;
1171 	struct skb_data		*entry;
1172 
1173 	while ((skb = skb_dequeue (&dev->done))) {
1174 		entry = (struct skb_data *) skb->cb;
1175 		switch (entry->state) {
1176 		case rx_done:
1177 			entry->state = rx_cleanup;
1178 			rx_process (dev, skb);
1179 			continue;
1180 		case tx_done:
1181 		case rx_cleanup:
1182 			usb_free_urb (entry->urb);
1183 			dev_kfree_skb (skb);
1184 			continue;
1185 		default:
1186 			netdev_dbg(dev->net, "bogus skb state %d\n", entry->state);
1187 		}
1188 	}
1189 
1190 	// waiting for all pending urbs to complete?
1191 	if (dev->wait) {
1192 		if ((dev->txq.qlen + dev->rxq.qlen + dev->done.qlen) == 0) {
1193 			wake_up (dev->wait);
1194 		}
1195 
1196 	// or are we maybe short a few urbs?
1197 	} else if (netif_running (dev->net) &&
1198 		   netif_device_present (dev->net) &&
1199 		   !timer_pending (&dev->delay) &&
1200 		   !test_bit (EVENT_RX_HALT, &dev->flags)) {
1201 		int	temp = dev->rxq.qlen;
1202 		int	qlen = RX_QLEN (dev);
1203 
1204 		if (temp < qlen) {
1205 			struct urb	*urb;
1206 			int		i;
1207 
1208 			// don't refill the queue all at once
1209 			for (i = 0; i < 10 && dev->rxq.qlen < qlen; i++) {
1210 				urb = usb_alloc_urb (0, GFP_ATOMIC);
1211 				if (urb != NULL) {
1212 					if (rx_submit (dev, urb, GFP_ATOMIC) ==
1213 					    -ENOLINK)
1214 						return;
1215 				}
1216 			}
1217 			if (temp != dev->rxq.qlen)
1218 				netif_dbg(dev, link, dev->net,
1219 					  "rxqlen %d --> %d\n",
1220 					  temp, dev->rxq.qlen);
1221 			if (dev->rxq.qlen < qlen)
1222 				tasklet_schedule (&dev->bh);
1223 		}
1224 		if (dev->txq.qlen < TX_QLEN (dev))
1225 			netif_wake_queue (dev->net);
1226 	}
1227 }
1228 
1229 
1230 /*-------------------------------------------------------------------------
1231  *
1232  * USB Device Driver support
1233  *
1234  *-------------------------------------------------------------------------*/
1235 
1236 // precondition: never called in_interrupt
1237 
usbnet_disconnect(struct usb_interface * intf)1238 void usbnet_disconnect (struct usb_interface *intf)
1239 {
1240 	struct usbnet		*dev;
1241 	struct usb_device	*xdev;
1242 	struct net_device	*net;
1243 
1244 	dev = usb_get_intfdata(intf);
1245 	usb_set_intfdata(intf, NULL);
1246 	if (!dev)
1247 		return;
1248 
1249 	xdev = interface_to_usbdev (intf);
1250 
1251 	netif_info(dev, probe, dev->net, "unregister '%s' usb-%s-%s, %s\n",
1252 		   intf->dev.driver->name,
1253 		   xdev->bus->bus_name, xdev->devpath,
1254 		   dev->driver_info->description);
1255 
1256 	net = dev->net;
1257 	unregister_netdev (net);
1258 
1259 	cancel_work_sync(&dev->kevent);
1260 
1261 	if (dev->driver_info->unbind)
1262 		dev->driver_info->unbind (dev, intf);
1263 
1264 	usb_kill_urb(dev->interrupt);
1265 	usb_free_urb(dev->interrupt);
1266 
1267 	free_netdev(net);
1268 	usb_put_dev (xdev);
1269 }
1270 EXPORT_SYMBOL_GPL(usbnet_disconnect);
1271 
1272 static const struct net_device_ops usbnet_netdev_ops = {
1273 	.ndo_open		= usbnet_open,
1274 	.ndo_stop		= usbnet_stop,
1275 	.ndo_start_xmit		= usbnet_start_xmit,
1276 	.ndo_tx_timeout		= usbnet_tx_timeout,
1277 	.ndo_change_mtu		= usbnet_change_mtu,
1278 	.ndo_set_mac_address 	= eth_mac_addr,
1279 	.ndo_validate_addr	= eth_validate_addr,
1280 };
1281 
1282 /*-------------------------------------------------------------------------*/
1283 
1284 // precondition: never called in_interrupt
1285 
1286 static struct device_type wlan_type = {
1287 	.name	= "wlan",
1288 };
1289 
1290 static struct device_type wwan_type = {
1291 	.name	= "wwan",
1292 };
1293 
1294 int
usbnet_probe(struct usb_interface * udev,const struct usb_device_id * prod)1295 usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
1296 {
1297 	struct usbnet			*dev;
1298 	struct net_device		*net;
1299 	struct usb_host_interface	*interface;
1300 	struct driver_info		*info;
1301 	struct usb_device		*xdev;
1302 	int				status;
1303 	const char			*name;
1304 	struct usb_driver 	*driver = to_usb_driver(udev->dev.driver);
1305 
1306 	/* usbnet already took usb runtime pm, so have to enable the feature
1307 	 * for usb interface, otherwise usb_autopm_get_interface may return
1308 	 * failure if USB_SUSPEND(RUNTIME_PM) is enabled.
1309 	 */
1310 	if (!driver->supports_autosuspend) {
1311 		driver->supports_autosuspend = 1;
1312 		pm_runtime_enable(&udev->dev);
1313 	}
1314 
1315 	name = udev->dev.driver->name;
1316 	info = (struct driver_info *) prod->driver_info;
1317 	if (!info) {
1318 		dev_dbg (&udev->dev, "blacklisted by %s\n", name);
1319 		return -ENODEV;
1320 	}
1321 	xdev = interface_to_usbdev (udev);
1322 	interface = udev->cur_altsetting;
1323 
1324 	usb_get_dev (xdev);
1325 
1326 	status = -ENOMEM;
1327 
1328 	// set up our own records
1329 	net = alloc_etherdev(sizeof(*dev));
1330 	if (!net) {
1331 		dbg ("can't kmalloc dev");
1332 		goto out;
1333 	}
1334 
1335 	/* netdev_printk() needs this so do it as early as possible */
1336 	SET_NETDEV_DEV(net, &udev->dev);
1337 
1338 	dev = netdev_priv(net);
1339 	dev->udev = xdev;
1340 	dev->intf = udev;
1341 	dev->driver_info = info;
1342 	dev->driver_name = name;
1343 	dev->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV
1344 				| NETIF_MSG_PROBE | NETIF_MSG_LINK);
1345 	skb_queue_head_init (&dev->rxq);
1346 	skb_queue_head_init (&dev->txq);
1347 	skb_queue_head_init (&dev->done);
1348 	skb_queue_head_init(&dev->rxq_pause);
1349 	dev->bh.func = usbnet_bh;
1350 	dev->bh.data = (unsigned long) dev;
1351 	INIT_WORK (&dev->kevent, kevent);
1352 	init_usb_anchor(&dev->deferred);
1353 	dev->delay.function = usbnet_bh;
1354 	dev->delay.data = (unsigned long) dev;
1355 	init_timer (&dev->delay);
1356 	mutex_init (&dev->phy_mutex);
1357 
1358 	dev->net = net;
1359 	strcpy (net->name, "usb%d");
1360 	memcpy (net->dev_addr, node_id, sizeof node_id);
1361 
1362 	/* rx and tx sides can use different message sizes;
1363 	 * bind() should set rx_urb_size in that case.
1364 	 */
1365 	dev->hard_mtu = net->mtu + net->hard_header_len;
1366 #if 0
1367 // dma_supported() is deeply broken on almost all architectures
1368 	// possible with some EHCI controllers
1369 	if (dma_supported (&udev->dev, DMA_BIT_MASK(64)))
1370 		net->features |= NETIF_F_HIGHDMA;
1371 #endif
1372 
1373 	net->netdev_ops = &usbnet_netdev_ops;
1374 	net->watchdog_timeo = TX_TIMEOUT_JIFFIES;
1375 	net->ethtool_ops = &usbnet_ethtool_ops;
1376 
1377 	// allow device-specific bind/init procedures
1378 	// NOTE net->name still not usable ...
1379 	if (info->bind) {
1380 		status = info->bind (dev, udev);
1381 		if (status < 0)
1382 			goto out1;
1383 
1384 		// heuristic:  "usb%d" for links we know are two-host,
1385 		// else "eth%d" when there's reasonable doubt.  userspace
1386 		// can rename the link if it knows better.
1387 		if ((dev->driver_info->flags & FLAG_ETHER) != 0 &&
1388 		    ((dev->driver_info->flags & FLAG_POINTTOPOINT) == 0 ||
1389 		     (net->dev_addr [0] & 0x02) == 0))
1390 			strcpy (net->name, "eth%d");
1391 		/* WLAN devices should always be named "wlan%d" */
1392 		if ((dev->driver_info->flags & FLAG_WLAN) != 0)
1393 			strcpy(net->name, "wlan%d");
1394 		/* WWAN devices should always be named "wwan%d" */
1395 		if ((dev->driver_info->flags & FLAG_WWAN) != 0)
1396 			strcpy(net->name, "wwan%d");
1397 
1398 		/* maybe the remote can't receive an Ethernet MTU */
1399 		if (net->mtu > (dev->hard_mtu - net->hard_header_len))
1400 			net->mtu = dev->hard_mtu - net->hard_header_len;
1401 	} else if (!info->in || !info->out)
1402 		status = usbnet_get_endpoints (dev, udev);
1403 	else {
1404 		dev->in = usb_rcvbulkpipe (xdev, info->in);
1405 		dev->out = usb_sndbulkpipe (xdev, info->out);
1406 		if (!(info->flags & FLAG_NO_SETINT))
1407 			status = usb_set_interface (xdev,
1408 				interface->desc.bInterfaceNumber,
1409 				interface->desc.bAlternateSetting);
1410 		else
1411 			status = 0;
1412 
1413 	}
1414 	if (status >= 0 && dev->status)
1415 		status = init_status (dev, udev);
1416 	if (status < 0)
1417 		goto out3;
1418 
1419 	if (!dev->rx_urb_size)
1420 		dev->rx_urb_size = dev->hard_mtu;
1421 	dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1);
1422 
1423 	if ((dev->driver_info->flags & FLAG_WLAN) != 0)
1424 		SET_NETDEV_DEVTYPE(net, &wlan_type);
1425 	if ((dev->driver_info->flags & FLAG_WWAN) != 0)
1426 		SET_NETDEV_DEVTYPE(net, &wwan_type);
1427 
1428 	status = register_netdev (net);
1429 	if (status)
1430 		goto out3;
1431 	netif_info(dev, probe, dev->net,
1432 		   "register '%s' at usb-%s-%s, %s, %pM\n",
1433 		   udev->dev.driver->name,
1434 		   xdev->bus->bus_name, xdev->devpath,
1435 		   dev->driver_info->description,
1436 		   net->dev_addr);
1437 
1438 	// ok, it's ready to go.
1439 	usb_set_intfdata (udev, dev);
1440 
1441 	netif_device_attach (net);
1442 
1443 	if (dev->driver_info->flags & FLAG_LINK_INTR)
1444 		netif_carrier_off(net);
1445 
1446 	return 0;
1447 
1448 out3:
1449 	if (info->unbind)
1450 		info->unbind (dev, udev);
1451 out1:
1452 	free_netdev(net);
1453 out:
1454 	usb_put_dev(xdev);
1455 	return status;
1456 }
1457 EXPORT_SYMBOL_GPL(usbnet_probe);
1458 
1459 /*-------------------------------------------------------------------------*/
1460 
1461 /*
1462  * suspend the whole driver as soon as the first interface is suspended
1463  * resume only when the last interface is resumed
1464  */
1465 
usbnet_suspend(struct usb_interface * intf,pm_message_t message)1466 int usbnet_suspend (struct usb_interface *intf, pm_message_t message)
1467 {
1468 	struct usbnet		*dev = usb_get_intfdata(intf);
1469 
1470 	if (!dev->suspend_count++) {
1471 		spin_lock_irq(&dev->txq.lock);
1472 		/* don't autosuspend while transmitting */
1473 		if (dev->txq.qlen && (message.event & PM_EVENT_AUTO)) {
1474 			spin_unlock_irq(&dev->txq.lock);
1475 			return -EBUSY;
1476 		} else {
1477 			set_bit(EVENT_DEV_ASLEEP, &dev->flags);
1478 			spin_unlock_irq(&dev->txq.lock);
1479 		}
1480 		/*
1481 		 * accelerate emptying of the rx and queues, to avoid
1482 		 * having everything error out.
1483 		 */
1484 		netif_device_detach (dev->net);
1485 		usbnet_terminate_urbs(dev);
1486 		usb_kill_urb(dev->interrupt);
1487 
1488 		/*
1489 		 * reattach so runtime management can use and
1490 		 * wake the device
1491 		 */
1492 		netif_device_attach (dev->net);
1493 	}
1494 	return 0;
1495 }
1496 EXPORT_SYMBOL_GPL(usbnet_suspend);
1497 
usbnet_resume(struct usb_interface * intf)1498 int usbnet_resume (struct usb_interface *intf)
1499 {
1500 	struct usbnet		*dev = usb_get_intfdata(intf);
1501 	struct sk_buff          *skb;
1502 	struct urb              *res;
1503 	int                     retval;
1504 
1505 	if (!--dev->suspend_count) {
1506 		/* resume interrupt URBs */
1507 		if (dev->interrupt && test_bit(EVENT_DEV_OPEN, &dev->flags))
1508 			usb_submit_urb(dev->interrupt, GFP_NOIO);
1509 
1510 		spin_lock_irq(&dev->txq.lock);
1511 		while ((res = usb_get_from_anchor(&dev->deferred))) {
1512 
1513 			skb = (struct sk_buff *)res->context;
1514 			retval = usb_submit_urb(res, GFP_ATOMIC);
1515 			if (retval < 0) {
1516 				dev_kfree_skb_any(skb);
1517 				usb_free_urb(res);
1518 				usb_autopm_put_interface_async(dev->intf);
1519 			} else {
1520 				dev->net->trans_start = jiffies;
1521 				__skb_queue_tail(&dev->txq, skb);
1522 			}
1523 		}
1524 
1525 		smp_mb();
1526 		clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
1527 		spin_unlock_irq(&dev->txq.lock);
1528 
1529 		if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
1530 			if (!(dev->txq.qlen >= TX_QLEN(dev)))
1531 				netif_start_queue(dev->net);
1532 			tasklet_schedule (&dev->bh);
1533 		}
1534 	}
1535 	return 0;
1536 }
1537 EXPORT_SYMBOL_GPL(usbnet_resume);
1538 
1539 
1540 /*-------------------------------------------------------------------------*/
1541 
usbnet_init(void)1542 static int __init usbnet_init(void)
1543 {
1544 	/* compiler should optimize this out */
1545 	BUILD_BUG_ON (sizeof (((struct sk_buff *)0)->cb)
1546 			< sizeof (struct skb_data));
1547 
1548 	random_ether_addr(node_id);
1549 	return 0;
1550 }
1551 module_init(usbnet_init);
1552 
usbnet_exit(void)1553 static void __exit usbnet_exit(void)
1554 {
1555 }
1556 module_exit(usbnet_exit);
1557 
1558 MODULE_AUTHOR("David Brownell");
1559 MODULE_DESCRIPTION("USB network driver framework");
1560 MODULE_LICENSE("GPL");
1561