2 * USB Network driver infrastructure
3 * Copyright (C) 2000-2005 by David Brownell
4 * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
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.
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.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21 * This is a generic "USB networking" framework that works with several
22 * kinds of full and high speed networking devices: host-to-host cables,
23 * smart usb peripherals, and actual Ethernet adapters.
25 * These devices usually differ in terms of control protocols (if they
26 * even have one!) and sometimes they define new framing to wrap or batch
27 * Ethernet packets. Otherwise, they talk to USB pretty much the same,
28 * so interface (un)binding, endpoint I/O queues, fault handling, and other
29 * issues can usefully be addressed by this framework.
32 // #define DEBUG // error path messages, extra info
33 // #define VERBOSE // more; success messages
35 #include <linux/module.h>
36 #include <linux/init.h>
37 #include <linux/netdevice.h>
38 #include <linux/etherdevice.h>
39 #include <linux/ctype.h>
40 #include <linux/ethtool.h>
41 #include <linux/workqueue.h>
42 #include <linux/mii.h>
43 #include <linux/usb.h>
44 #include <linux/usb/usbnet.h>
45 #include <linux/slab.h>
46 #include <linux/kernel.h>
47 #include <linux/pm_runtime.h>
49 #define DRIVER_VERSION "22-Aug-2005"
52 /*-------------------------------------------------------------------------*/
55 * Nineteen USB 1.1 max size bulk transactions per frame (ms), max.
56 * Several dozen bytes of IPv4 data can fit in two such transactions.
57 * One maximum size Ethernet packet takes twenty four of them.
58 * For high speed, each frame comfortably fits almost 36 max size
59 * Ethernet packets (so queues should be bigger).
61 * The goal is to let the USB host controller be busy for 5msec or
62 * more before an irq is required, under load. Jumbograms change
65 #define MAX_QUEUE_MEMORY (60 * 1518)
66 #define RX_QLEN(dev) ((dev)->rx_qlen)
67 #define TX_QLEN(dev) ((dev)->tx_qlen)
69 // reawaken network queue this soon after stopping; else watchdog barks
70 #define TX_TIMEOUT_JIFFIES (5*HZ)
72 /* throttle rx/tx briefly after some faults, so hub_wq might disconnect()
73 * us (it polls at HZ/4 usually) before we report too many false errors.
75 #define THROTTLE_JIFFIES (HZ/8)
78 #define UNLINK_TIMEOUT_MS 3
80 /*-------------------------------------------------------------------------*/
82 // randomly generated ethernet address
83 static u8 node_id
[ETH_ALEN
];
85 /* use ethtool to change the level for any given device */
86 static int msg_level
= -1;
87 module_param (msg_level
, int, 0);
88 MODULE_PARM_DESC (msg_level
, "Override default message level");
90 /*-------------------------------------------------------------------------*/
92 /* handles CDC Ethernet and many other network "bulk data" interfaces */
93 int usbnet_get_endpoints(struct usbnet
*dev
, struct usb_interface
*intf
)
96 struct usb_host_interface
*alt
= NULL
;
97 struct usb_host_endpoint
*in
= NULL
, *out
= NULL
;
98 struct usb_host_endpoint
*status
= NULL
;
100 for (tmp
= 0; tmp
< intf
->num_altsetting
; tmp
++) {
103 in
= out
= status
= NULL
;
104 alt
= intf
->altsetting
+ tmp
;
106 /* take the first altsetting with in-bulk + out-bulk;
107 * remember any status endpoint, just in case;
108 * ignore other endpoints and altsettings.
110 for (ep
= 0; ep
< alt
->desc
.bNumEndpoints
; ep
++) {
111 struct usb_host_endpoint
*e
;
114 e
= alt
->endpoint
+ ep
;
115 switch (e
->desc
.bmAttributes
) {
116 case USB_ENDPOINT_XFER_INT
:
117 if (!usb_endpoint_dir_in(&e
->desc
))
121 case USB_ENDPOINT_XFER_BULK
:
126 if (usb_endpoint_dir_in(&e
->desc
)) {
129 else if (intr
&& !status
)
139 if (!alt
|| !in
|| !out
)
142 if (alt
->desc
.bAlternateSetting
!= 0 ||
143 !(dev
->driver_info
->flags
& FLAG_NO_SETINT
)) {
144 tmp
= usb_set_interface (dev
->udev
, alt
->desc
.bInterfaceNumber
,
145 alt
->desc
.bAlternateSetting
);
150 dev
->in
= usb_rcvbulkpipe (dev
->udev
,
151 in
->desc
.bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
152 dev
->out
= usb_sndbulkpipe (dev
->udev
,
153 out
->desc
.bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
154 dev
->status
= status
;
157 EXPORT_SYMBOL_GPL(usbnet_get_endpoints
);
159 int usbnet_get_ethernet_addr(struct usbnet
*dev
, int iMACAddress
)
162 unsigned char buf
[13];
164 ret
= usb_string(dev
->udev
, iMACAddress
, buf
, sizeof buf
);
166 tmp
= hex2bin(dev
->net
->dev_addr
, buf
, 6);
168 dev_dbg(&dev
->udev
->dev
,
169 "bad MAC string %d fetch, %d\n", iMACAddress
, tmp
);
176 EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr
);
178 static void intr_complete (struct urb
*urb
)
180 struct usbnet
*dev
= urb
->context
;
181 int status
= urb
->status
;
186 dev
->driver_info
->status(dev
, urb
);
189 /* software-driven interface shutdown */
190 case -ENOENT
: /* urb killed */
191 case -ESHUTDOWN
: /* hardware gone */
192 netif_dbg(dev
, ifdown
, dev
->net
,
193 "intr shutdown, code %d\n", status
);
196 /* NOTE: not throttling like RX/TX, since this endpoint
197 * already polls infrequently
200 netdev_dbg(dev
->net
, "intr status %d\n", status
);
204 status
= usb_submit_urb (urb
, GFP_ATOMIC
);
206 netif_err(dev
, timer
, dev
->net
,
207 "intr resubmit --> %d\n", status
);
210 static int init_status (struct usbnet
*dev
, struct usb_interface
*intf
)
217 if (!dev
->driver_info
->status
)
220 pipe
= usb_rcvintpipe (dev
->udev
,
221 dev
->status
->desc
.bEndpointAddress
222 & USB_ENDPOINT_NUMBER_MASK
);
223 maxp
= usb_maxpacket (dev
->udev
, pipe
, 0);
225 /* avoid 1 msec chatter: min 8 msec poll rate */
226 period
= max ((int) dev
->status
->desc
.bInterval
,
227 (dev
->udev
->speed
== USB_SPEED_HIGH
) ? 7 : 3);
229 buf
= kmalloc (maxp
, GFP_KERNEL
);
231 dev
->interrupt
= usb_alloc_urb (0, GFP_KERNEL
);
232 if (!dev
->interrupt
) {
236 usb_fill_int_urb(dev
->interrupt
, dev
->udev
, pipe
,
237 buf
, maxp
, intr_complete
, dev
, period
);
238 dev
->interrupt
->transfer_flags
|= URB_FREE_BUFFER
;
240 "status ep%din, %d bytes period %d\n",
241 usb_pipeendpoint(pipe
), maxp
, period
);
247 /* Submit the interrupt URB if not previously submitted, increasing refcount */
248 int usbnet_status_start(struct usbnet
*dev
, gfp_t mem_flags
)
252 WARN_ON_ONCE(dev
->interrupt
== NULL
);
253 if (dev
->interrupt
) {
254 mutex_lock(&dev
->interrupt_mutex
);
256 if (++dev
->interrupt_count
== 1)
257 ret
= usb_submit_urb(dev
->interrupt
, mem_flags
);
259 dev_dbg(&dev
->udev
->dev
, "incremented interrupt URB count to %d\n",
260 dev
->interrupt_count
);
261 mutex_unlock(&dev
->interrupt_mutex
);
265 EXPORT_SYMBOL_GPL(usbnet_status_start
);
267 /* For resume; submit interrupt URB if previously submitted */
268 static int __usbnet_status_start_force(struct usbnet
*dev
, gfp_t mem_flags
)
272 mutex_lock(&dev
->interrupt_mutex
);
273 if (dev
->interrupt_count
) {
274 ret
= usb_submit_urb(dev
->interrupt
, mem_flags
);
275 dev_dbg(&dev
->udev
->dev
,
276 "submitted interrupt URB for resume\n");
278 mutex_unlock(&dev
->interrupt_mutex
);
282 /* Kill the interrupt URB if all submitters want it killed */
283 void usbnet_status_stop(struct usbnet
*dev
)
285 if (dev
->interrupt
) {
286 mutex_lock(&dev
->interrupt_mutex
);
287 WARN_ON(dev
->interrupt_count
== 0);
289 if (dev
->interrupt_count
&& --dev
->interrupt_count
== 0)
290 usb_kill_urb(dev
->interrupt
);
292 dev_dbg(&dev
->udev
->dev
,
293 "decremented interrupt URB count to %d\n",
294 dev
->interrupt_count
);
295 mutex_unlock(&dev
->interrupt_mutex
);
298 EXPORT_SYMBOL_GPL(usbnet_status_stop
);
300 /* For suspend; always kill interrupt URB */
301 static void __usbnet_status_stop_force(struct usbnet
*dev
)
303 if (dev
->interrupt
) {
304 mutex_lock(&dev
->interrupt_mutex
);
305 usb_kill_urb(dev
->interrupt
);
306 dev_dbg(&dev
->udev
->dev
, "killed interrupt URB for suspend\n");
307 mutex_unlock(&dev
->interrupt_mutex
);
311 /* Passes this packet up the stack, updating its accounting.
312 * Some link protocols batch packets, so their rx_fixup paths
313 * can return clones as well as just modify the original skb.
315 void usbnet_skb_return (struct usbnet
*dev
, struct sk_buff
*skb
)
317 struct pcpu_sw_netstats
*stats64
= this_cpu_ptr(dev
->stats64
);
321 if (test_bit(EVENT_RX_PAUSED
, &dev
->flags
)) {
322 skb_queue_tail(&dev
->rxq_pause
, skb
);
326 /* only update if unset to allow minidriver rx_fixup override */
327 if (skb
->protocol
== 0)
328 skb
->protocol
= eth_type_trans (skb
, dev
->net
);
330 flags
= u64_stats_update_begin_irqsave(&stats64
->syncp
);
331 stats64
->rx_packets
++;
332 stats64
->rx_bytes
+= skb
->len
;
333 u64_stats_update_end_irqrestore(&stats64
->syncp
, flags
);
335 netif_dbg(dev
, rx_status
, dev
->net
, "< rx, len %zu, type 0x%x\n",
336 skb
->len
+ sizeof (struct ethhdr
), skb
->protocol
);
337 memset (skb
->cb
, 0, sizeof (struct skb_data
));
339 if (skb_defer_rx_timestamp(skb
))
342 status
= netif_rx (skb
);
343 if (status
!= NET_RX_SUCCESS
)
344 netif_dbg(dev
, rx_err
, dev
->net
,
345 "netif_rx status %d\n", status
);
347 EXPORT_SYMBOL_GPL(usbnet_skb_return
);
349 /* must be called if hard_mtu or rx_urb_size changed */
350 void usbnet_update_max_qlen(struct usbnet
*dev
)
352 enum usb_device_speed speed
= dev
->udev
->speed
;
356 dev
->rx_qlen
= MAX_QUEUE_MEMORY
/ dev
->rx_urb_size
;
357 dev
->tx_qlen
= MAX_QUEUE_MEMORY
/ dev
->hard_mtu
;
359 case USB_SPEED_SUPER
:
360 case USB_SPEED_SUPER_PLUS
:
362 * Not take default 5ms qlen for super speed HC to
363 * save memory, and iperf tests show 2.5ms qlen can
366 dev
->rx_qlen
= 5 * MAX_QUEUE_MEMORY
/ dev
->rx_urb_size
;
367 dev
->tx_qlen
= 5 * MAX_QUEUE_MEMORY
/ dev
->hard_mtu
;
370 dev
->rx_qlen
= dev
->tx_qlen
= 4;
373 EXPORT_SYMBOL_GPL(usbnet_update_max_qlen
);
376 /*-------------------------------------------------------------------------
378 * Network Device Driver (peer link to "Host Device", from USB host)
380 *-------------------------------------------------------------------------*/
382 int usbnet_change_mtu (struct net_device
*net
, int new_mtu
)
384 struct usbnet
*dev
= netdev_priv(net
);
385 int ll_mtu
= new_mtu
+ net
->hard_header_len
;
386 int old_hard_mtu
= dev
->hard_mtu
;
387 int old_rx_urb_size
= dev
->rx_urb_size
;
389 // no second zero-length packet read wanted after mtu-sized packets
390 if ((ll_mtu
% dev
->maxpacket
) == 0)
394 dev
->hard_mtu
= net
->mtu
+ net
->hard_header_len
;
395 if (dev
->rx_urb_size
== old_hard_mtu
) {
396 dev
->rx_urb_size
= dev
->hard_mtu
;
397 if (dev
->rx_urb_size
> old_rx_urb_size
) {
398 usbnet_pause_rx(dev
);
399 usbnet_unlink_rx_urbs(dev
);
400 usbnet_resume_rx(dev
);
404 /* max qlen depend on hard_mtu and rx_urb_size */
405 usbnet_update_max_qlen(dev
);
409 EXPORT_SYMBOL_GPL(usbnet_change_mtu
);
411 /* The caller must hold list->lock */
412 static void __usbnet_queue_skb(struct sk_buff_head
*list
,
413 struct sk_buff
*newsk
, enum skb_state state
)
415 struct skb_data
*entry
= (struct skb_data
*) newsk
->cb
;
417 __skb_queue_tail(list
, newsk
);
418 entry
->state
= state
;
421 /*-------------------------------------------------------------------------*/
423 /* some LK 2.4 HCDs oopsed if we freed or resubmitted urbs from
424 * completion callbacks. 2.5 should have fixed those bugs...
427 static enum skb_state
defer_bh(struct usbnet
*dev
, struct sk_buff
*skb
,
428 struct sk_buff_head
*list
, enum skb_state state
)
431 enum skb_state old_state
;
432 struct skb_data
*entry
= (struct skb_data
*) skb
->cb
;
434 spin_lock_irqsave(&list
->lock
, flags
);
435 old_state
= entry
->state
;
436 entry
->state
= state
;
437 __skb_unlink(skb
, list
);
439 /* defer_bh() is never called with list == &dev->done.
440 * spin_lock_nested() tells lockdep that it is OK to take
441 * dev->done.lock here with list->lock held.
443 spin_lock_nested(&dev
->done
.lock
, SINGLE_DEPTH_NESTING
);
445 __skb_queue_tail(&dev
->done
, skb
);
446 if (dev
->done
.qlen
== 1)
447 tasklet_schedule(&dev
->bh
);
448 spin_unlock(&dev
->done
.lock
);
449 spin_unlock_irqrestore(&list
->lock
, flags
);
453 /* some work can't be done in tasklets, so we use keventd
455 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
456 * but tasklet_schedule() doesn't. hope the failure is rare.
458 void usbnet_defer_kevent (struct usbnet
*dev
, int work
)
460 set_bit (work
, &dev
->flags
);
461 if (!schedule_work (&dev
->kevent
))
462 netdev_dbg(dev
->net
, "kevent %d may have been dropped\n", work
);
464 netdev_dbg(dev
->net
, "kevent %d scheduled\n", work
);
466 EXPORT_SYMBOL_GPL(usbnet_defer_kevent
);
468 /*-------------------------------------------------------------------------*/
470 static void rx_complete (struct urb
*urb
);
472 static int rx_submit (struct usbnet
*dev
, struct urb
*urb
, gfp_t flags
)
475 struct skb_data
*entry
;
477 unsigned long lockflags
;
478 size_t size
= dev
->rx_urb_size
;
480 /* prevent rx skb allocation when error ratio is high */
481 if (test_bit(EVENT_RX_KILL
, &dev
->flags
)) {
486 if (test_bit(EVENT_NO_IP_ALIGN
, &dev
->flags
))
487 skb
= __netdev_alloc_skb(dev
->net
, size
, flags
);
489 skb
= __netdev_alloc_skb_ip_align(dev
->net
, size
, flags
);
491 netif_dbg(dev
, rx_err
, dev
->net
, "no rx skb\n");
492 usbnet_defer_kevent (dev
, EVENT_RX_MEMORY
);
497 entry
= (struct skb_data
*) skb
->cb
;
502 usb_fill_bulk_urb (urb
, dev
->udev
, dev
->in
,
503 skb
->data
, size
, rx_complete
, skb
);
505 spin_lock_irqsave (&dev
->rxq
.lock
, lockflags
);
507 if (netif_running (dev
->net
) &&
508 netif_device_present (dev
->net
) &&
509 !test_bit (EVENT_RX_HALT
, &dev
->flags
) &&
510 !test_bit (EVENT_DEV_ASLEEP
, &dev
->flags
)) {
511 switch (retval
= usb_submit_urb (urb
, GFP_ATOMIC
)) {
513 usbnet_defer_kevent (dev
, EVENT_RX_HALT
);
516 usbnet_defer_kevent (dev
, EVENT_RX_MEMORY
);
519 netif_dbg(dev
, ifdown
, dev
->net
, "device gone\n");
520 netif_device_detach (dev
->net
);
526 netif_dbg(dev
, rx_err
, dev
->net
,
527 "rx submit, %d\n", retval
);
528 tasklet_schedule (&dev
->bh
);
531 __usbnet_queue_skb(&dev
->rxq
, skb
, rx_start
);
534 netif_dbg(dev
, ifdown
, dev
->net
, "rx: stopped\n");
537 spin_unlock_irqrestore (&dev
->rxq
.lock
, lockflags
);
539 dev_kfree_skb_any (skb
);
546 /*-------------------------------------------------------------------------*/
548 static inline void rx_process (struct usbnet
*dev
, struct sk_buff
*skb
)
550 if (dev
->driver_info
->rx_fixup
&&
551 !dev
->driver_info
->rx_fixup (dev
, skb
)) {
552 /* With RX_ASSEMBLE, rx_fixup() must update counters */
553 if (!(dev
->driver_info
->flags
& FLAG_RX_ASSEMBLE
))
554 dev
->net
->stats
.rx_errors
++;
557 // else network stack removes extra byte if we forced a short packet
559 /* all data was already cloned from skb inside the driver */
560 if (dev
->driver_info
->flags
& FLAG_MULTI_PACKET
)
563 if (skb
->len
< ETH_HLEN
) {
564 dev
->net
->stats
.rx_errors
++;
565 dev
->net
->stats
.rx_length_errors
++;
566 netif_dbg(dev
, rx_err
, dev
->net
, "rx length %d\n", skb
->len
);
568 usbnet_skb_return(dev
, skb
);
573 skb_queue_tail(&dev
->done
, skb
);
576 /*-------------------------------------------------------------------------*/
578 static void rx_complete (struct urb
*urb
)
580 struct sk_buff
*skb
= (struct sk_buff
*) urb
->context
;
581 struct skb_data
*entry
= (struct skb_data
*) skb
->cb
;
582 struct usbnet
*dev
= entry
->dev
;
583 int urb_status
= urb
->status
;
584 enum skb_state state
;
586 skb_put (skb
, urb
->actual_length
);
590 switch (urb_status
) {
595 /* stalls need manual reset. this is rare ... except that
596 * when going through USB 2.0 TTs, unplug appears this way.
597 * we avoid the highspeed version of the ETIMEDOUT/EILSEQ
598 * storm, recovering as needed.
601 dev
->net
->stats
.rx_errors
++;
602 usbnet_defer_kevent (dev
, EVENT_RX_HALT
);
605 /* software-driven interface shutdown */
606 case -ECONNRESET
: /* async unlink */
607 case -ESHUTDOWN
: /* hardware gone */
608 netif_dbg(dev
, ifdown
, dev
->net
,
609 "rx shutdown, code %d\n", urb_status
);
612 /* we get controller i/o faults during hub_wq disconnect() delays.
613 * throttle down resubmits, to avoid log floods; just temporarily,
614 * so we still recover when the fault isn't a hub_wq delay.
619 dev
->net
->stats
.rx_errors
++;
620 if (!timer_pending (&dev
->delay
)) {
621 mod_timer (&dev
->delay
, jiffies
+ THROTTLE_JIFFIES
);
622 netif_dbg(dev
, link
, dev
->net
,
623 "rx throttle %d\n", urb_status
);
631 /* data overrun ... flush fifo? */
633 dev
->net
->stats
.rx_over_errors
++;
638 dev
->net
->stats
.rx_errors
++;
639 netif_dbg(dev
, rx_err
, dev
->net
, "rx status %d\n", urb_status
);
643 /* stop rx if packet error rate is high */
644 if (++dev
->pkt_cnt
> 30) {
648 if (state
== rx_cleanup
)
650 if (dev
->pkt_err
> 20)
651 set_bit(EVENT_RX_KILL
, &dev
->flags
);
654 state
= defer_bh(dev
, skb
, &dev
->rxq
, state
);
657 if (netif_running (dev
->net
) &&
658 !test_bit (EVENT_RX_HALT
, &dev
->flags
) &&
659 state
!= unlink_start
) {
660 rx_submit (dev
, urb
, GFP_ATOMIC
);
661 usb_mark_last_busy(dev
->udev
);
666 netif_dbg(dev
, rx_err
, dev
->net
, "no read resubmitted\n");
669 /*-------------------------------------------------------------------------*/
670 void usbnet_pause_rx(struct usbnet
*dev
)
672 set_bit(EVENT_RX_PAUSED
, &dev
->flags
);
674 netif_dbg(dev
, rx_status
, dev
->net
, "paused rx queue enabled\n");
676 EXPORT_SYMBOL_GPL(usbnet_pause_rx
);
678 void usbnet_resume_rx(struct usbnet
*dev
)
683 clear_bit(EVENT_RX_PAUSED
, &dev
->flags
);
685 while ((skb
= skb_dequeue(&dev
->rxq_pause
)) != NULL
) {
686 usbnet_skb_return(dev
, skb
);
690 tasklet_schedule(&dev
->bh
);
692 netif_dbg(dev
, rx_status
, dev
->net
,
693 "paused rx queue disabled, %d skbs requeued\n", num
);
695 EXPORT_SYMBOL_GPL(usbnet_resume_rx
);
697 void usbnet_purge_paused_rxq(struct usbnet
*dev
)
699 skb_queue_purge(&dev
->rxq_pause
);
701 EXPORT_SYMBOL_GPL(usbnet_purge_paused_rxq
);
703 /*-------------------------------------------------------------------------*/
705 // unlink pending rx/tx; completion handlers do all other cleanup
707 static int unlink_urbs (struct usbnet
*dev
, struct sk_buff_head
*q
)
713 spin_lock_irqsave (&q
->lock
, flags
);
714 while (!skb_queue_empty(q
)) {
715 struct skb_data
*entry
;
719 skb_queue_walk(q
, skb
) {
720 entry
= (struct skb_data
*) skb
->cb
;
721 if (entry
->state
!= unlink_start
)
726 entry
->state
= unlink_start
;
730 * Get reference count of the URB to avoid it to be
731 * freed during usb_unlink_urb, which may trigger
732 * use-after-free problem inside usb_unlink_urb since
733 * usb_unlink_urb is always racing with .complete
734 * handler(include defer_bh).
737 spin_unlock_irqrestore(&q
->lock
, flags
);
738 // during some PM-driven resume scenarios,
739 // these (async) unlinks complete immediately
740 retval
= usb_unlink_urb (urb
);
741 if (retval
!= -EINPROGRESS
&& retval
!= 0)
742 netdev_dbg(dev
->net
, "unlink urb err, %d\n", retval
);
746 spin_lock_irqsave(&q
->lock
, flags
);
748 spin_unlock_irqrestore (&q
->lock
, flags
);
752 // Flush all pending rx urbs
753 // minidrivers may need to do this when the MTU changes
755 void usbnet_unlink_rx_urbs(struct usbnet
*dev
)
757 if (netif_running(dev
->net
)) {
758 (void) unlink_urbs (dev
, &dev
->rxq
);
759 tasklet_schedule(&dev
->bh
);
762 EXPORT_SYMBOL_GPL(usbnet_unlink_rx_urbs
);
764 /*-------------------------------------------------------------------------*/
766 static void wait_skb_queue_empty(struct sk_buff_head
*q
)
770 spin_lock_irqsave(&q
->lock
, flags
);
771 while (!skb_queue_empty(q
)) {
772 spin_unlock_irqrestore(&q
->lock
, flags
);
773 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS
));
774 set_current_state(TASK_UNINTERRUPTIBLE
);
775 spin_lock_irqsave(&q
->lock
, flags
);
777 spin_unlock_irqrestore(&q
->lock
, flags
);
780 // precondition: never called in_interrupt
781 static void usbnet_terminate_urbs(struct usbnet
*dev
)
783 DECLARE_WAITQUEUE(wait
, current
);
786 /* ensure there are no more active urbs */
787 add_wait_queue(&dev
->wait
, &wait
);
788 set_current_state(TASK_UNINTERRUPTIBLE
);
789 temp
= unlink_urbs(dev
, &dev
->txq
) +
790 unlink_urbs(dev
, &dev
->rxq
);
792 /* maybe wait for deletions to finish. */
793 wait_skb_queue_empty(&dev
->rxq
);
794 wait_skb_queue_empty(&dev
->txq
);
795 wait_skb_queue_empty(&dev
->done
);
796 netif_dbg(dev
, ifdown
, dev
->net
,
797 "waited for %d urb completions\n", temp
);
798 set_current_state(TASK_RUNNING
);
799 remove_wait_queue(&dev
->wait
, &wait
);
802 int usbnet_stop (struct net_device
*net
)
804 struct usbnet
*dev
= netdev_priv(net
);
805 struct driver_info
*info
= dev
->driver_info
;
808 clear_bit(EVENT_DEV_OPEN
, &dev
->flags
);
809 netif_stop_queue (net
);
811 netif_info(dev
, ifdown
, dev
->net
,
812 "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
813 net
->stats
.rx_packets
, net
->stats
.tx_packets
,
814 net
->stats
.rx_errors
, net
->stats
.tx_errors
);
816 /* to not race resume */
817 pm
= usb_autopm_get_interface(dev
->intf
);
818 /* allow minidriver to stop correctly (wireless devices to turn off
821 retval
= info
->stop(dev
);
823 netif_info(dev
, ifdown
, dev
->net
,
824 "stop fail (%d) usbnet usb-%s-%s, %s\n",
826 dev
->udev
->bus
->bus_name
, dev
->udev
->devpath
,
830 if (!(info
->flags
& FLAG_AVOID_UNLINK_URBS
))
831 usbnet_terminate_urbs(dev
);
833 usbnet_status_stop(dev
);
835 usbnet_purge_paused_rxq(dev
);
837 mpn
= !test_and_clear_bit(EVENT_NO_RUNTIME_PM
, &dev
->flags
);
839 /* deferred work (task, timer, softirq) must also stop.
840 * can't flush_scheduled_work() until we drop rtnl (later),
841 * else workers could deadlock; so make workers a NOP.
844 del_timer_sync (&dev
->delay
);
845 tasklet_kill (&dev
->bh
);
847 usb_autopm_put_interface(dev
->intf
);
849 if (info
->manage_power
&& mpn
)
850 info
->manage_power(dev
, 0);
852 usb_autopm_put_interface(dev
->intf
);
856 EXPORT_SYMBOL_GPL(usbnet_stop
);
858 /*-------------------------------------------------------------------------*/
860 // posts reads, and enables write queuing
862 // precondition: never called in_interrupt
864 int usbnet_open (struct net_device
*net
)
866 struct usbnet
*dev
= netdev_priv(net
);
868 struct driver_info
*info
= dev
->driver_info
;
870 if ((retval
= usb_autopm_get_interface(dev
->intf
)) < 0) {
871 netif_info(dev
, ifup
, dev
->net
,
872 "resumption fail (%d) usbnet usb-%s-%s, %s\n",
874 dev
->udev
->bus
->bus_name
,
880 // put into "known safe" state
881 if (info
->reset
&& (retval
= info
->reset (dev
)) < 0) {
882 netif_info(dev
, ifup
, dev
->net
,
883 "open reset fail (%d) usbnet usb-%s-%s, %s\n",
885 dev
->udev
->bus
->bus_name
,
891 /* hard_mtu or rx_urb_size may change in reset() */
892 usbnet_update_max_qlen(dev
);
894 // insist peer be connected
895 if (info
->check_connect
&& (retval
= info
->check_connect (dev
)) < 0) {
896 netif_dbg(dev
, ifup
, dev
->net
, "can't open; %d\n", retval
);
900 /* start any status interrupt transfer */
901 if (dev
->interrupt
) {
902 retval
= usbnet_status_start(dev
, GFP_KERNEL
);
904 netif_err(dev
, ifup
, dev
->net
,
905 "intr submit %d\n", retval
);
910 set_bit(EVENT_DEV_OPEN
, &dev
->flags
);
911 netif_start_queue (net
);
912 netif_info(dev
, ifup
, dev
->net
,
913 "open: enable queueing (rx %d, tx %d) mtu %d %s framing\n",
914 (int)RX_QLEN(dev
), (int)TX_QLEN(dev
),
916 (dev
->driver_info
->flags
& FLAG_FRAMING_NC
) ? "NetChip" :
917 (dev
->driver_info
->flags
& FLAG_FRAMING_GL
) ? "GeneSys" :
918 (dev
->driver_info
->flags
& FLAG_FRAMING_Z
) ? "Zaurus" :
919 (dev
->driver_info
->flags
& FLAG_FRAMING_RN
) ? "RNDIS" :
920 (dev
->driver_info
->flags
& FLAG_FRAMING_AX
) ? "ASIX" :
923 /* reset rx error state */
926 clear_bit(EVENT_RX_KILL
, &dev
->flags
);
928 // delay posting reads until we're fully open
929 tasklet_schedule (&dev
->bh
);
930 if (info
->manage_power
) {
931 retval
= info
->manage_power(dev
, 1);
934 set_bit(EVENT_NO_RUNTIME_PM
, &dev
->flags
);
936 usb_autopm_put_interface(dev
->intf
);
941 usb_autopm_put_interface(dev
->intf
);
945 EXPORT_SYMBOL_GPL(usbnet_open
);
947 /*-------------------------------------------------------------------------*/
949 /* ethtool methods; minidrivers may need to add some more, but
950 * they'll probably want to use this base set.
953 int usbnet_get_link_ksettings(struct net_device
*net
,
954 struct ethtool_link_ksettings
*cmd
)
956 struct usbnet
*dev
= netdev_priv(net
);
958 if (!dev
->mii
.mdio_read
)
961 mii_ethtool_get_link_ksettings(&dev
->mii
, cmd
);
965 EXPORT_SYMBOL_GPL(usbnet_get_link_ksettings
);
967 int usbnet_set_link_ksettings(struct net_device
*net
,
968 const struct ethtool_link_ksettings
*cmd
)
970 struct usbnet
*dev
= netdev_priv(net
);
973 if (!dev
->mii
.mdio_write
)
976 retval
= mii_ethtool_set_link_ksettings(&dev
->mii
, cmd
);
978 /* link speed/duplex might have changed */
979 if (dev
->driver_info
->link_reset
)
980 dev
->driver_info
->link_reset(dev
);
982 /* hard_mtu or rx_urb_size may change in link_reset() */
983 usbnet_update_max_qlen(dev
);
987 EXPORT_SYMBOL_GPL(usbnet_set_link_ksettings
);
989 void usbnet_get_stats64(struct net_device
*net
, struct rtnl_link_stats64
*stats
)
991 struct usbnet
*dev
= netdev_priv(net
);
995 netdev_stats_to_stats64(stats
, &net
->stats
);
997 for_each_possible_cpu(cpu
) {
998 struct pcpu_sw_netstats
*stats64
;
999 u64 rx_packets
, rx_bytes
;
1000 u64 tx_packets
, tx_bytes
;
1002 stats64
= per_cpu_ptr(dev
->stats64
, cpu
);
1005 start
= u64_stats_fetch_begin_irq(&stats64
->syncp
);
1006 rx_packets
= stats64
->rx_packets
;
1007 rx_bytes
= stats64
->rx_bytes
;
1008 tx_packets
= stats64
->tx_packets
;
1009 tx_bytes
= stats64
->tx_bytes
;
1010 } while (u64_stats_fetch_retry_irq(&stats64
->syncp
, start
));
1012 stats
->rx_packets
+= rx_packets
;
1013 stats
->rx_bytes
+= rx_bytes
;
1014 stats
->tx_packets
+= tx_packets
;
1015 stats
->tx_bytes
+= tx_bytes
;
1018 EXPORT_SYMBOL_GPL(usbnet_get_stats64
);
1020 u32
usbnet_get_link (struct net_device
*net
)
1022 struct usbnet
*dev
= netdev_priv(net
);
1024 /* If a check_connect is defined, return its result */
1025 if (dev
->driver_info
->check_connect
)
1026 return dev
->driver_info
->check_connect (dev
) == 0;
1028 /* if the device has mii operations, use those */
1029 if (dev
->mii
.mdio_read
)
1030 return mii_link_ok(&dev
->mii
);
1032 /* Otherwise, dtrt for drivers calling netif_carrier_{on,off} */
1033 return ethtool_op_get_link(net
);
1035 EXPORT_SYMBOL_GPL(usbnet_get_link
);
1037 int usbnet_nway_reset(struct net_device
*net
)
1039 struct usbnet
*dev
= netdev_priv(net
);
1041 if (!dev
->mii
.mdio_write
)
1044 return mii_nway_restart(&dev
->mii
);
1046 EXPORT_SYMBOL_GPL(usbnet_nway_reset
);
1048 void usbnet_get_drvinfo (struct net_device
*net
, struct ethtool_drvinfo
*info
)
1050 struct usbnet
*dev
= netdev_priv(net
);
1052 strlcpy (info
->driver
, dev
->driver_name
, sizeof info
->driver
);
1053 strlcpy (info
->version
, DRIVER_VERSION
, sizeof info
->version
);
1054 strlcpy (info
->fw_version
, dev
->driver_info
->description
,
1055 sizeof info
->fw_version
);
1056 usb_make_path (dev
->udev
, info
->bus_info
, sizeof info
->bus_info
);
1058 EXPORT_SYMBOL_GPL(usbnet_get_drvinfo
);
1060 u32
usbnet_get_msglevel (struct net_device
*net
)
1062 struct usbnet
*dev
= netdev_priv(net
);
1064 return dev
->msg_enable
;
1066 EXPORT_SYMBOL_GPL(usbnet_get_msglevel
);
1068 void usbnet_set_msglevel (struct net_device
*net
, u32 level
)
1070 struct usbnet
*dev
= netdev_priv(net
);
1072 dev
->msg_enable
= level
;
1074 EXPORT_SYMBOL_GPL(usbnet_set_msglevel
);
1076 /* drivers may override default ethtool_ops in their bind() routine */
1077 static const struct ethtool_ops usbnet_ethtool_ops
= {
1078 .get_link
= usbnet_get_link
,
1079 .nway_reset
= usbnet_nway_reset
,
1080 .get_drvinfo
= usbnet_get_drvinfo
,
1081 .get_msglevel
= usbnet_get_msglevel
,
1082 .set_msglevel
= usbnet_set_msglevel
,
1083 .get_ts_info
= ethtool_op_get_ts_info
,
1084 .get_link_ksettings
= usbnet_get_link_ksettings
,
1085 .set_link_ksettings
= usbnet_set_link_ksettings
,
1088 /*-------------------------------------------------------------------------*/
1090 static void __handle_link_change(struct usbnet
*dev
)
1092 if (!test_bit(EVENT_DEV_OPEN
, &dev
->flags
))
1095 if (!netif_carrier_ok(dev
->net
)) {
1096 /* kill URBs for reading packets to save bus bandwidth */
1097 unlink_urbs(dev
, &dev
->rxq
);
1100 * tx_timeout will unlink URBs for sending packets and
1101 * tx queue is stopped by netcore after link becomes off
1104 /* submitting URBs for reading packets */
1105 tasklet_schedule(&dev
->bh
);
1108 /* hard_mtu or rx_urb_size may change during link change */
1109 usbnet_update_max_qlen(dev
);
1111 clear_bit(EVENT_LINK_CHANGE
, &dev
->flags
);
1114 static void usbnet_set_rx_mode(struct net_device
*net
)
1116 struct usbnet
*dev
= netdev_priv(net
);
1118 usbnet_defer_kevent(dev
, EVENT_SET_RX_MODE
);
1121 static void __handle_set_rx_mode(struct usbnet
*dev
)
1123 if (dev
->driver_info
->set_rx_mode
)
1124 (dev
->driver_info
->set_rx_mode
)(dev
);
1126 clear_bit(EVENT_SET_RX_MODE
, &dev
->flags
);
1129 /* work that cannot be done in interrupt context uses keventd.
1131 * NOTE: with 2.5 we could do more of this using completion callbacks,
1132 * especially now that control transfers can be queued.
1135 usbnet_deferred_kevent (struct work_struct
*work
)
1137 struct usbnet
*dev
=
1138 container_of(work
, struct usbnet
, kevent
);
1141 /* usb_clear_halt() needs a thread context */
1142 if (test_bit (EVENT_TX_HALT
, &dev
->flags
)) {
1143 unlink_urbs (dev
, &dev
->txq
);
1144 status
= usb_autopm_get_interface(dev
->intf
);
1147 status
= usb_clear_halt (dev
->udev
, dev
->out
);
1148 usb_autopm_put_interface(dev
->intf
);
1151 status
!= -ESHUTDOWN
) {
1152 if (netif_msg_tx_err (dev
))
1154 netdev_err(dev
->net
, "can't clear tx halt, status %d\n",
1157 clear_bit (EVENT_TX_HALT
, &dev
->flags
);
1158 if (status
!= -ESHUTDOWN
)
1159 netif_wake_queue (dev
->net
);
1162 if (test_bit (EVENT_RX_HALT
, &dev
->flags
)) {
1163 unlink_urbs (dev
, &dev
->rxq
);
1164 status
= usb_autopm_get_interface(dev
->intf
);
1167 status
= usb_clear_halt (dev
->udev
, dev
->in
);
1168 usb_autopm_put_interface(dev
->intf
);
1171 status
!= -ESHUTDOWN
) {
1172 if (netif_msg_rx_err (dev
))
1174 netdev_err(dev
->net
, "can't clear rx halt, status %d\n",
1177 clear_bit (EVENT_RX_HALT
, &dev
->flags
);
1178 tasklet_schedule (&dev
->bh
);
1182 /* tasklet could resubmit itself forever if memory is tight */
1183 if (test_bit (EVENT_RX_MEMORY
, &dev
->flags
)) {
1184 struct urb
*urb
= NULL
;
1187 if (netif_running (dev
->net
))
1188 urb
= usb_alloc_urb (0, GFP_KERNEL
);
1190 clear_bit (EVENT_RX_MEMORY
, &dev
->flags
);
1192 clear_bit (EVENT_RX_MEMORY
, &dev
->flags
);
1193 status
= usb_autopm_get_interface(dev
->intf
);
1198 if (rx_submit (dev
, urb
, GFP_KERNEL
) == -ENOLINK
)
1200 usb_autopm_put_interface(dev
->intf
);
1203 tasklet_schedule (&dev
->bh
);
1207 if (test_bit (EVENT_LINK_RESET
, &dev
->flags
)) {
1208 struct driver_info
*info
= dev
->driver_info
;
1211 clear_bit (EVENT_LINK_RESET
, &dev
->flags
);
1212 status
= usb_autopm_get_interface(dev
->intf
);
1215 if(info
->link_reset
&& (retval
= info
->link_reset(dev
)) < 0) {
1216 usb_autopm_put_interface(dev
->intf
);
1218 netdev_info(dev
->net
, "link reset failed (%d) usbnet usb-%s-%s, %s\n",
1220 dev
->udev
->bus
->bus_name
,
1224 usb_autopm_put_interface(dev
->intf
);
1227 /* handle link change from link resetting */
1228 __handle_link_change(dev
);
1231 if (test_bit (EVENT_LINK_CHANGE
, &dev
->flags
))
1232 __handle_link_change(dev
);
1234 if (test_bit (EVENT_SET_RX_MODE
, &dev
->flags
))
1235 __handle_set_rx_mode(dev
);
1239 netdev_dbg(dev
->net
, "kevent done, flags = 0x%lx\n", dev
->flags
);
1242 /*-------------------------------------------------------------------------*/
1244 static void tx_complete (struct urb
*urb
)
1246 struct sk_buff
*skb
= (struct sk_buff
*) urb
->context
;
1247 struct skb_data
*entry
= (struct skb_data
*) skb
->cb
;
1248 struct usbnet
*dev
= entry
->dev
;
1250 if (urb
->status
== 0) {
1251 struct pcpu_sw_netstats
*stats64
= this_cpu_ptr(dev
->stats64
);
1252 unsigned long flags
;
1254 flags
= u64_stats_update_begin_irqsave(&stats64
->syncp
);
1255 stats64
->tx_packets
+= entry
->packets
;
1256 stats64
->tx_bytes
+= entry
->length
;
1257 u64_stats_update_end_irqrestore(&stats64
->syncp
, flags
);
1259 dev
->net
->stats
.tx_errors
++;
1261 switch (urb
->status
) {
1263 usbnet_defer_kevent (dev
, EVENT_TX_HALT
);
1266 /* software-driven interface shutdown */
1267 case -ECONNRESET
: // async unlink
1268 case -ESHUTDOWN
: // hardware gone
1271 /* like rx, tx gets controller i/o faults during hub_wq
1272 * delays and so it uses the same throttling mechanism.
1277 usb_mark_last_busy(dev
->udev
);
1278 if (!timer_pending (&dev
->delay
)) {
1279 mod_timer (&dev
->delay
,
1280 jiffies
+ THROTTLE_JIFFIES
);
1281 netif_dbg(dev
, link
, dev
->net
,
1282 "tx throttle %d\n", urb
->status
);
1284 netif_stop_queue (dev
->net
);
1287 netif_dbg(dev
, tx_err
, dev
->net
,
1288 "tx err %d\n", entry
->urb
->status
);
1293 usb_autopm_put_interface_async(dev
->intf
);
1294 (void) defer_bh(dev
, skb
, &dev
->txq
, tx_done
);
1297 /*-------------------------------------------------------------------------*/
1299 void usbnet_tx_timeout (struct net_device
*net
)
1301 struct usbnet
*dev
= netdev_priv(net
);
1303 unlink_urbs (dev
, &dev
->txq
);
1304 tasklet_schedule (&dev
->bh
);
1305 /* this needs to be handled individually because the generic layer
1306 * doesn't know what is sufficient and could not restore private
1307 * information if a remedy of an unconditional reset were used.
1309 if (dev
->driver_info
->recover
)
1310 (dev
->driver_info
->recover
)(dev
);
1312 EXPORT_SYMBOL_GPL(usbnet_tx_timeout
);
1314 /*-------------------------------------------------------------------------*/
1316 static int build_dma_sg(const struct sk_buff
*skb
, struct urb
*urb
)
1318 unsigned num_sgs
, total_len
= 0;
1321 num_sgs
= skb_shinfo(skb
)->nr_frags
+ 1;
1325 /* reserve one for zero packet */
1326 urb
->sg
= kmalloc((num_sgs
+ 1) * sizeof(struct scatterlist
),
1331 urb
->num_sgs
= num_sgs
;
1332 sg_init_table(urb
->sg
, urb
->num_sgs
+ 1);
1334 sg_set_buf(&urb
->sg
[s
++], skb
->data
, skb_headlen(skb
));
1335 total_len
+= skb_headlen(skb
);
1337 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
1338 struct skb_frag_struct
*f
= &skb_shinfo(skb
)->frags
[i
];
1340 total_len
+= skb_frag_size(f
);
1341 sg_set_page(&urb
->sg
[i
+ s
], f
->page
.p
, f
->size
,
1344 urb
->transfer_buffer_length
= total_len
;
1349 netdev_tx_t
usbnet_start_xmit (struct sk_buff
*skb
,
1350 struct net_device
*net
)
1352 struct usbnet
*dev
= netdev_priv(net
);
1353 unsigned int length
;
1354 struct urb
*urb
= NULL
;
1355 struct skb_data
*entry
;
1356 struct driver_info
*info
= dev
->driver_info
;
1357 unsigned long flags
;
1361 skb_tx_timestamp(skb
);
1363 // some devices want funky USB-level framing, for
1364 // win32 driver (usually) and/or hardware quirks
1365 if (info
->tx_fixup
) {
1366 skb
= info
->tx_fixup (dev
, skb
, GFP_ATOMIC
);
1368 /* packet collected; minidriver waiting for more */
1369 if (info
->flags
& FLAG_MULTI_PACKET
)
1371 netif_dbg(dev
, tx_err
, dev
->net
, "can't tx_fixup skb\n");
1376 if (!(urb
= usb_alloc_urb (0, GFP_ATOMIC
))) {
1377 netif_dbg(dev
, tx_err
, dev
->net
, "no urb\n");
1381 entry
= (struct skb_data
*) skb
->cb
;
1385 usb_fill_bulk_urb (urb
, dev
->udev
, dev
->out
,
1386 skb
->data
, skb
->len
, tx_complete
, skb
);
1387 if (dev
->can_dma_sg
) {
1388 if (build_dma_sg(skb
, urb
) < 0)
1391 length
= urb
->transfer_buffer_length
;
1393 /* don't assume the hardware handles USB_ZERO_PACKET
1394 * NOTE: strictly conforming cdc-ether devices should expect
1395 * the ZLP here, but ignore the one-byte packet.
1396 * NOTE2: CDC NCM specification is different from CDC ECM when
1397 * handling ZLP/short packets, so cdc_ncm driver will make short
1398 * packet itself if needed.
1400 if (length
% dev
->maxpacket
== 0) {
1401 if (!(info
->flags
& FLAG_SEND_ZLP
)) {
1402 if (!(info
->flags
& FLAG_MULTI_PACKET
)) {
1404 if (skb_tailroom(skb
) && !urb
->num_sgs
) {
1405 skb
->data
[skb
->len
] = 0;
1407 } else if (urb
->num_sgs
)
1408 sg_set_buf(&urb
->sg
[urb
->num_sgs
++],
1409 dev
->padding_pkt
, 1);
1412 urb
->transfer_flags
|= URB_ZERO_PACKET
;
1414 urb
->transfer_buffer_length
= length
;
1416 if (info
->flags
& FLAG_MULTI_PACKET
) {
1417 /* Driver has set number of packets and a length delta.
1418 * Calculate the complete length and ensure that it's
1421 entry
->length
+= length
;
1422 if (WARN_ON_ONCE(entry
->length
<= 0))
1423 entry
->length
= length
;
1425 usbnet_set_skb_tx_stats(skb
, 1, length
);
1428 spin_lock_irqsave(&dev
->txq
.lock
, flags
);
1429 retval
= usb_autopm_get_interface_async(dev
->intf
);
1431 spin_unlock_irqrestore(&dev
->txq
.lock
, flags
);
1436 /* if this triggers the device is still a sleep */
1437 if (test_bit(EVENT_DEV_ASLEEP
, &dev
->flags
)) {
1438 /* transmission will be done in resume */
1439 usb_anchor_urb(urb
, &dev
->deferred
);
1440 /* no use to process more packets */
1441 netif_stop_queue(net
);
1443 spin_unlock_irqrestore(&dev
->txq
.lock
, flags
);
1444 netdev_dbg(dev
->net
, "Delaying transmission for resumption\n");
1449 switch ((retval
= usb_submit_urb (urb
, GFP_ATOMIC
))) {
1451 netif_stop_queue (net
);
1452 usbnet_defer_kevent (dev
, EVENT_TX_HALT
);
1453 usb_autopm_put_interface_async(dev
->intf
);
1456 usb_autopm_put_interface_async(dev
->intf
);
1457 netif_dbg(dev
, tx_err
, dev
->net
,
1458 "tx: submit urb err %d\n", retval
);
1461 netif_trans_update(net
);
1462 __usbnet_queue_skb(&dev
->txq
, skb
, tx_start
);
1463 if (dev
->txq
.qlen
>= TX_QLEN (dev
))
1464 netif_stop_queue (net
);
1466 spin_unlock_irqrestore (&dev
->txq
.lock
, flags
);
1469 netif_dbg(dev
, tx_err
, dev
->net
, "drop, code %d\n", retval
);
1471 dev
->net
->stats
.tx_dropped
++;
1474 dev_kfree_skb_any (skb
);
1480 netif_dbg(dev
, tx_queued
, dev
->net
,
1481 "> tx, len %u, type 0x%x\n", length
, skb
->protocol
);
1485 return NETDEV_TX_OK
;
1487 EXPORT_SYMBOL_GPL(usbnet_start_xmit
);
1489 static int rx_alloc_submit(struct usbnet
*dev
, gfp_t flags
)
1495 /* don't refill the queue all at once */
1496 for (i
= 0; i
< 10 && dev
->rxq
.qlen
< RX_QLEN(dev
); i
++) {
1497 urb
= usb_alloc_urb(0, flags
);
1499 ret
= rx_submit(dev
, urb
, flags
);
1511 /*-------------------------------------------------------------------------*/
1513 // tasklet (work deferred from completions, in_irq) or timer
1515 static void usbnet_bh (struct timer_list
*t
)
1517 struct usbnet
*dev
= from_timer(dev
, t
, delay
);
1518 struct sk_buff
*skb
;
1519 struct skb_data
*entry
;
1521 while ((skb
= skb_dequeue (&dev
->done
))) {
1522 entry
= (struct skb_data
*) skb
->cb
;
1523 switch (entry
->state
) {
1525 entry
->state
= rx_cleanup
;
1526 rx_process (dev
, skb
);
1529 kfree(entry
->urb
->sg
);
1531 usb_free_urb (entry
->urb
);
1532 dev_kfree_skb (skb
);
1535 netdev_dbg(dev
->net
, "bogus skb state %d\n", entry
->state
);
1539 /* restart RX again after disabling due to high error rate */
1540 clear_bit(EVENT_RX_KILL
, &dev
->flags
);
1542 /* waiting for all pending urbs to complete?
1543 * only then can we forgo submitting anew
1545 if (waitqueue_active(&dev
->wait
)) {
1546 if (dev
->txq
.qlen
+ dev
->rxq
.qlen
+ dev
->done
.qlen
== 0)
1547 wake_up_all(&dev
->wait
);
1549 // or are we maybe short a few urbs?
1550 } else if (netif_running (dev
->net
) &&
1551 netif_device_present (dev
->net
) &&
1552 netif_carrier_ok(dev
->net
) &&
1553 !timer_pending(&dev
->delay
) &&
1554 !test_bit(EVENT_RX_PAUSED
, &dev
->flags
) &&
1555 !test_bit(EVENT_RX_HALT
, &dev
->flags
)) {
1556 int temp
= dev
->rxq
.qlen
;
1558 if (temp
< RX_QLEN(dev
)) {
1559 if (rx_alloc_submit(dev
, GFP_ATOMIC
) == -ENOLINK
)
1561 if (temp
!= dev
->rxq
.qlen
)
1562 netif_dbg(dev
, link
, dev
->net
,
1563 "rxqlen %d --> %d\n",
1564 temp
, dev
->rxq
.qlen
);
1565 if (dev
->rxq
.qlen
< RX_QLEN(dev
))
1566 tasklet_schedule (&dev
->bh
);
1568 if (dev
->txq
.qlen
< TX_QLEN (dev
))
1569 netif_wake_queue (dev
->net
);
1574 /*-------------------------------------------------------------------------
1576 * USB Device Driver support
1578 *-------------------------------------------------------------------------*/
1580 // precondition: never called in_interrupt
1582 void usbnet_disconnect (struct usb_interface
*intf
)
1585 struct usb_device
*xdev
;
1586 struct net_device
*net
;
1588 dev
= usb_get_intfdata(intf
);
1589 usb_set_intfdata(intf
, NULL
);
1593 xdev
= interface_to_usbdev (intf
);
1595 netif_info(dev
, probe
, dev
->net
, "unregister '%s' usb-%s-%s, %s\n",
1596 intf
->dev
.driver
->name
,
1597 xdev
->bus
->bus_name
, xdev
->devpath
,
1598 dev
->driver_info
->description
);
1601 unregister_netdev (net
);
1603 cancel_work_sync(&dev
->kevent
);
1605 usb_scuttle_anchored_urbs(&dev
->deferred
);
1607 if (dev
->driver_info
->unbind
)
1608 dev
->driver_info
->unbind (dev
, intf
);
1610 usb_kill_urb(dev
->interrupt
);
1611 usb_free_urb(dev
->interrupt
);
1612 kfree(dev
->padding_pkt
);
1614 free_percpu(dev
->stats64
);
1617 EXPORT_SYMBOL_GPL(usbnet_disconnect
);
1619 static const struct net_device_ops usbnet_netdev_ops
= {
1620 .ndo_open
= usbnet_open
,
1621 .ndo_stop
= usbnet_stop
,
1622 .ndo_start_xmit
= usbnet_start_xmit
,
1623 .ndo_tx_timeout
= usbnet_tx_timeout
,
1624 .ndo_set_rx_mode
= usbnet_set_rx_mode
,
1625 .ndo_change_mtu
= usbnet_change_mtu
,
1626 .ndo_get_stats64
= usbnet_get_stats64
,
1627 .ndo_set_mac_address
= eth_mac_addr
,
1628 .ndo_validate_addr
= eth_validate_addr
,
1631 /*-------------------------------------------------------------------------*/
1633 // precondition: never called in_interrupt
1635 static struct device_type wlan_type
= {
1639 static struct device_type wwan_type
= {
1644 usbnet_probe (struct usb_interface
*udev
, const struct usb_device_id
*prod
)
1647 struct net_device
*net
;
1648 struct usb_host_interface
*interface
;
1649 struct driver_info
*info
;
1650 struct usb_device
*xdev
;
1653 struct usb_driver
*driver
= to_usb_driver(udev
->dev
.driver
);
1655 /* usbnet already took usb runtime pm, so have to enable the feature
1656 * for usb interface, otherwise usb_autopm_get_interface may return
1657 * failure if RUNTIME_PM is enabled.
1659 if (!driver
->supports_autosuspend
) {
1660 driver
->supports_autosuspend
= 1;
1661 pm_runtime_enable(&udev
->dev
);
1664 name
= udev
->dev
.driver
->name
;
1665 info
= (struct driver_info
*) prod
->driver_info
;
1667 dev_dbg (&udev
->dev
, "blacklisted by %s\n", name
);
1670 xdev
= interface_to_usbdev (udev
);
1671 interface
= udev
->cur_altsetting
;
1675 // set up our own records
1676 net
= alloc_etherdev(sizeof(*dev
));
1680 /* netdev_printk() needs this so do it as early as possible */
1681 SET_NETDEV_DEV(net
, &udev
->dev
);
1683 dev
= netdev_priv(net
);
1686 dev
->driver_info
= info
;
1687 dev
->driver_name
= name
;
1689 dev
->stats64
= netdev_alloc_pcpu_stats(struct pcpu_sw_netstats
);
1693 dev
->msg_enable
= netif_msg_init (msg_level
, NETIF_MSG_DRV
1694 | NETIF_MSG_PROBE
| NETIF_MSG_LINK
);
1695 init_waitqueue_head(&dev
->wait
);
1696 skb_queue_head_init (&dev
->rxq
);
1697 skb_queue_head_init (&dev
->txq
);
1698 skb_queue_head_init (&dev
->done
);
1699 skb_queue_head_init(&dev
->rxq_pause
);
1700 dev
->bh
.func
= (void (*)(unsigned long))usbnet_bh
;
1701 dev
->bh
.data
= (unsigned long)&dev
->delay
;
1702 INIT_WORK (&dev
->kevent
, usbnet_deferred_kevent
);
1703 init_usb_anchor(&dev
->deferred
);
1704 timer_setup(&dev
->delay
, usbnet_bh
, 0);
1705 mutex_init (&dev
->phy_mutex
);
1706 mutex_init(&dev
->interrupt_mutex
);
1707 dev
->interrupt_count
= 0;
1710 strcpy (net
->name
, "usb%d");
1711 memcpy (net
->dev_addr
, node_id
, sizeof node_id
);
1713 /* rx and tx sides can use different message sizes;
1714 * bind() should set rx_urb_size in that case.
1716 dev
->hard_mtu
= net
->mtu
+ net
->hard_header_len
;
1718 net
->max_mtu
= ETH_MAX_MTU
;
1720 net
->netdev_ops
= &usbnet_netdev_ops
;
1721 net
->watchdog_timeo
= TX_TIMEOUT_JIFFIES
;
1722 net
->ethtool_ops
= &usbnet_ethtool_ops
;
1724 // allow device-specific bind/init procedures
1725 // NOTE net->name still not usable ...
1727 status
= info
->bind (dev
, udev
);
1731 // heuristic: "usb%d" for links we know are two-host,
1732 // else "eth%d" when there's reasonable doubt. userspace
1733 // can rename the link if it knows better.
1734 if ((dev
->driver_info
->flags
& FLAG_ETHER
) != 0 &&
1735 ((dev
->driver_info
->flags
& FLAG_POINTTOPOINT
) == 0 ||
1736 (net
->dev_addr
[0] & 0x02) == 0))
1737 strcpy (net
->name
, "eth%d");
1738 /* WLAN devices should always be named "wlan%d" */
1739 if ((dev
->driver_info
->flags
& FLAG_WLAN
) != 0)
1740 strcpy(net
->name
, "wlan%d");
1741 /* WWAN devices should always be named "wwan%d" */
1742 if ((dev
->driver_info
->flags
& FLAG_WWAN
) != 0)
1743 strcpy(net
->name
, "wwan%d");
1745 /* devices that cannot do ARP */
1746 if ((dev
->driver_info
->flags
& FLAG_NOARP
) != 0)
1747 net
->flags
|= IFF_NOARP
;
1749 /* maybe the remote can't receive an Ethernet MTU */
1750 if (net
->mtu
> (dev
->hard_mtu
- net
->hard_header_len
))
1751 net
->mtu
= dev
->hard_mtu
- net
->hard_header_len
;
1752 } else if (!info
->in
|| !info
->out
)
1753 status
= usbnet_get_endpoints (dev
, udev
);
1755 dev
->in
= usb_rcvbulkpipe (xdev
, info
->in
);
1756 dev
->out
= usb_sndbulkpipe (xdev
, info
->out
);
1757 if (!(info
->flags
& FLAG_NO_SETINT
))
1758 status
= usb_set_interface (xdev
,
1759 interface
->desc
.bInterfaceNumber
,
1760 interface
->desc
.bAlternateSetting
);
1765 if (status
>= 0 && dev
->status
)
1766 status
= init_status (dev
, udev
);
1770 if (!dev
->rx_urb_size
)
1771 dev
->rx_urb_size
= dev
->hard_mtu
;
1772 dev
->maxpacket
= usb_maxpacket (dev
->udev
, dev
->out
, 1);
1774 /* let userspace know we have a random address */
1775 if (ether_addr_equal(net
->dev_addr
, node_id
))
1776 net
->addr_assign_type
= NET_ADDR_RANDOM
;
1778 if ((dev
->driver_info
->flags
& FLAG_WLAN
) != 0)
1779 SET_NETDEV_DEVTYPE(net
, &wlan_type
);
1780 if ((dev
->driver_info
->flags
& FLAG_WWAN
) != 0)
1781 SET_NETDEV_DEVTYPE(net
, &wwan_type
);
1783 /* initialize max rx_qlen and tx_qlen */
1784 usbnet_update_max_qlen(dev
);
1786 if (dev
->can_dma_sg
&& !(info
->flags
& FLAG_SEND_ZLP
) &&
1787 !(info
->flags
& FLAG_MULTI_PACKET
)) {
1788 dev
->padding_pkt
= kzalloc(1, GFP_KERNEL
);
1789 if (!dev
->padding_pkt
) {
1795 status
= register_netdev (net
);
1798 netif_info(dev
, probe
, dev
->net
,
1799 "register '%s' at usb-%s-%s, %s, %pM\n",
1800 udev
->dev
.driver
->name
,
1801 xdev
->bus
->bus_name
, xdev
->devpath
,
1802 dev
->driver_info
->description
,
1805 // ok, it's ready to go.
1806 usb_set_intfdata (udev
, dev
);
1808 netif_device_attach (net
);
1810 if (dev
->driver_info
->flags
& FLAG_LINK_INTR
)
1811 usbnet_link_change(dev
, 0, 0);
1816 kfree(dev
->padding_pkt
);
1818 usb_free_urb(dev
->interrupt
);
1821 info
->unbind (dev
, udev
);
1823 /* subdrivers must undo all they did in bind() if they
1824 * fail it, but we may fail later and a deferred kevent
1825 * may trigger an error resubmitting itself and, worse,
1826 * schedule a timer. So we kill it all just in case.
1828 cancel_work_sync(&dev
->kevent
);
1829 del_timer_sync(&dev
->delay
);
1830 free_percpu(dev
->stats64
);
1836 EXPORT_SYMBOL_GPL(usbnet_probe
);
1838 /*-------------------------------------------------------------------------*/
1841 * suspend the whole driver as soon as the first interface is suspended
1842 * resume only when the last interface is resumed
1845 int usbnet_suspend (struct usb_interface
*intf
, pm_message_t message
)
1847 struct usbnet
*dev
= usb_get_intfdata(intf
);
1849 if (!dev
->suspend_count
++) {
1850 spin_lock_irq(&dev
->txq
.lock
);
1851 /* don't autosuspend while transmitting */
1852 if (dev
->txq
.qlen
&& PMSG_IS_AUTO(message
)) {
1853 dev
->suspend_count
--;
1854 spin_unlock_irq(&dev
->txq
.lock
);
1857 set_bit(EVENT_DEV_ASLEEP
, &dev
->flags
);
1858 spin_unlock_irq(&dev
->txq
.lock
);
1861 * accelerate emptying of the rx and queues, to avoid
1862 * having everything error out.
1864 netif_device_detach (dev
->net
);
1865 usbnet_terminate_urbs(dev
);
1866 __usbnet_status_stop_force(dev
);
1869 * reattach so runtime management can use and
1872 netif_device_attach (dev
->net
);
1876 EXPORT_SYMBOL_GPL(usbnet_suspend
);
1878 int usbnet_resume (struct usb_interface
*intf
)
1880 struct usbnet
*dev
= usb_get_intfdata(intf
);
1881 struct sk_buff
*skb
;
1885 if (!--dev
->suspend_count
) {
1886 /* resume interrupt URB if it was previously submitted */
1887 __usbnet_status_start_force(dev
, GFP_NOIO
);
1889 spin_lock_irq(&dev
->txq
.lock
);
1890 while ((res
= usb_get_from_anchor(&dev
->deferred
))) {
1892 skb
= (struct sk_buff
*)res
->context
;
1893 retval
= usb_submit_urb(res
, GFP_ATOMIC
);
1895 dev_kfree_skb_any(skb
);
1898 usb_autopm_put_interface_async(dev
->intf
);
1900 netif_trans_update(dev
->net
);
1901 __skb_queue_tail(&dev
->txq
, skb
);
1906 clear_bit(EVENT_DEV_ASLEEP
, &dev
->flags
);
1907 spin_unlock_irq(&dev
->txq
.lock
);
1909 if (test_bit(EVENT_DEV_OPEN
, &dev
->flags
)) {
1910 /* handle remote wakeup ASAP
1911 * we cannot race against stop
1913 if (netif_device_present(dev
->net
) &&
1914 !timer_pending(&dev
->delay
) &&
1915 !test_bit(EVENT_RX_HALT
, &dev
->flags
))
1916 rx_alloc_submit(dev
, GFP_NOIO
);
1918 if (!(dev
->txq
.qlen
>= TX_QLEN(dev
)))
1919 netif_tx_wake_all_queues(dev
->net
);
1920 tasklet_schedule (&dev
->bh
);
1924 if (test_and_clear_bit(EVENT_DEVICE_REPORT_IDLE
, &dev
->flags
))
1925 usb_autopm_get_interface_no_resume(intf
);
1929 EXPORT_SYMBOL_GPL(usbnet_resume
);
1932 * Either a subdriver implements manage_power, then it is assumed to always
1933 * be ready to be suspended or it reports the readiness to be suspended
1936 void usbnet_device_suggests_idle(struct usbnet
*dev
)
1938 if (!test_and_set_bit(EVENT_DEVICE_REPORT_IDLE
, &dev
->flags
)) {
1939 dev
->intf
->needs_remote_wakeup
= 1;
1940 usb_autopm_put_interface_async(dev
->intf
);
1943 EXPORT_SYMBOL(usbnet_device_suggests_idle
);
1946 * For devices that can do without special commands
1948 int usbnet_manage_power(struct usbnet
*dev
, int on
)
1950 dev
->intf
->needs_remote_wakeup
= on
;
1953 EXPORT_SYMBOL(usbnet_manage_power
);
1955 void usbnet_link_change(struct usbnet
*dev
, bool link
, bool need_reset
)
1957 /* update link after link is reseted */
1958 if (link
&& !need_reset
)
1959 netif_carrier_on(dev
->net
);
1961 netif_carrier_off(dev
->net
);
1963 if (need_reset
&& link
)
1964 usbnet_defer_kevent(dev
, EVENT_LINK_RESET
);
1966 usbnet_defer_kevent(dev
, EVENT_LINK_CHANGE
);
1968 EXPORT_SYMBOL(usbnet_link_change
);
1970 /*-------------------------------------------------------------------------*/
1971 static int __usbnet_read_cmd(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
1972 u16 value
, u16 index
, void *data
, u16 size
)
1977 netdev_dbg(dev
->net
, "usbnet_read_cmd cmd=0x%02x reqtype=%02x"
1978 " value=0x%04x index=0x%04x size=%d\n",
1979 cmd
, reqtype
, value
, index
, size
);
1982 buf
= kmalloc(size
, GFP_KERNEL
);
1987 err
= usb_control_msg(dev
->udev
, usb_rcvctrlpipe(dev
->udev
, 0),
1988 cmd
, reqtype
, value
, index
, buf
, size
,
1989 USB_CTRL_GET_TIMEOUT
);
1990 if (err
> 0 && err
<= size
) {
1992 memcpy(data
, buf
, err
);
1994 netdev_dbg(dev
->net
,
1995 "Huh? Data requested but thrown away.\n");
2002 static int __usbnet_write_cmd(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
2003 u16 value
, u16 index
, const void *data
,
2009 netdev_dbg(dev
->net
, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
2010 " value=0x%04x index=0x%04x size=%d\n",
2011 cmd
, reqtype
, value
, index
, size
);
2014 buf
= kmemdup(data
, size
, GFP_KERNEL
);
2025 err
= usb_control_msg(dev
->udev
, usb_sndctrlpipe(dev
->udev
, 0),
2026 cmd
, reqtype
, value
, index
, buf
, size
,
2027 USB_CTRL_SET_TIMEOUT
);
2035 * The function can't be called inside suspend/resume callback,
2036 * otherwise deadlock will be caused.
2038 int usbnet_read_cmd(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
2039 u16 value
, u16 index
, void *data
, u16 size
)
2043 if (usb_autopm_get_interface(dev
->intf
) < 0)
2045 ret
= __usbnet_read_cmd(dev
, cmd
, reqtype
, value
, index
,
2047 usb_autopm_put_interface(dev
->intf
);
2050 EXPORT_SYMBOL_GPL(usbnet_read_cmd
);
2053 * The function can't be called inside suspend/resume callback,
2054 * otherwise deadlock will be caused.
2056 int usbnet_write_cmd(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
2057 u16 value
, u16 index
, const void *data
, u16 size
)
2061 if (usb_autopm_get_interface(dev
->intf
) < 0)
2063 ret
= __usbnet_write_cmd(dev
, cmd
, reqtype
, value
, index
,
2065 usb_autopm_put_interface(dev
->intf
);
2068 EXPORT_SYMBOL_GPL(usbnet_write_cmd
);
2071 * The function can be called inside suspend/resume callback safely
2072 * and should only be called by suspend/resume callback generally.
2074 int usbnet_read_cmd_nopm(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
2075 u16 value
, u16 index
, void *data
, u16 size
)
2077 return __usbnet_read_cmd(dev
, cmd
, reqtype
, value
, index
,
2080 EXPORT_SYMBOL_GPL(usbnet_read_cmd_nopm
);
2083 * The function can be called inside suspend/resume callback safely
2084 * and should only be called by suspend/resume callback generally.
2086 int usbnet_write_cmd_nopm(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
2087 u16 value
, u16 index
, const void *data
,
2090 return __usbnet_write_cmd(dev
, cmd
, reqtype
, value
, index
,
2093 EXPORT_SYMBOL_GPL(usbnet_write_cmd_nopm
);
2095 static void usbnet_async_cmd_cb(struct urb
*urb
)
2097 struct usb_ctrlrequest
*req
= (struct usb_ctrlrequest
*)urb
->context
;
2098 int status
= urb
->status
;
2101 dev_dbg(&urb
->dev
->dev
, "%s failed with %d",
2109 * The caller must make sure that device can't be put into suspend
2110 * state until the control URB completes.
2112 int usbnet_write_cmd_async(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
2113 u16 value
, u16 index
, const void *data
, u16 size
)
2115 struct usb_ctrlrequest
*req
= NULL
;
2120 netdev_dbg(dev
->net
, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
2121 " value=0x%04x index=0x%04x size=%d\n",
2122 cmd
, reqtype
, value
, index
, size
);
2124 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
2129 buf
= kmemdup(data
, size
, GFP_ATOMIC
);
2131 netdev_err(dev
->net
, "Error allocating buffer"
2132 " in %s!\n", __func__
);
2137 req
= kmalloc(sizeof(struct usb_ctrlrequest
), GFP_ATOMIC
);
2141 req
->bRequestType
= reqtype
;
2142 req
->bRequest
= cmd
;
2143 req
->wValue
= cpu_to_le16(value
);
2144 req
->wIndex
= cpu_to_le16(index
);
2145 req
->wLength
= cpu_to_le16(size
);
2147 usb_fill_control_urb(urb
, dev
->udev
,
2148 usb_sndctrlpipe(dev
->udev
, 0),
2149 (void *)req
, buf
, size
,
2150 usbnet_async_cmd_cb
, req
);
2151 urb
->transfer_flags
|= URB_FREE_BUFFER
;
2153 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
2155 netdev_err(dev
->net
, "Error submitting the control"
2156 " message: status=%d\n", err
);
2170 EXPORT_SYMBOL_GPL(usbnet_write_cmd_async
);
2171 /*-------------------------------------------------------------------------*/
2173 static int __init
usbnet_init(void)
2175 /* Compiler should optimize this out. */
2177 FIELD_SIZEOF(struct sk_buff
, cb
) < sizeof(struct skb_data
));
2179 eth_random_addr(node_id
);
2182 module_init(usbnet_init
);
2184 static void __exit
usbnet_exit(void)
2187 module_exit(usbnet_exit
);
2189 MODULE_AUTHOR("David Brownell");
2190 MODULE_DESCRIPTION("USB network driver framework");
2191 MODULE_LICENSE("GPL");