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, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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.
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.
33 // #define DEBUG // error path messages, extra info
34 // #define VERBOSE // more; success messages
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>
50 #define DRIVER_VERSION "22-Aug-2005"
53 /*-------------------------------------------------------------------------*/
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).
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.
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)
72 // reawaken network queue this soon after stopping; else watchdog barks
73 #define TX_TIMEOUT_JIFFIES (5*HZ)
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)
80 #define UNLINK_TIMEOUT_MS 3
82 /*-------------------------------------------------------------------------*/
84 // randomly generated ethernet address
85 static u8 node_id
[ETH_ALEN
];
87 static const char driver_name
[] = "usbnet";
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");
94 /*-------------------------------------------------------------------------*/
96 /* handles CDC Ethernet and many other network "bulk data" interfaces */
97 int usbnet_get_endpoints(struct usbnet
*dev
, struct usb_interface
*intf
)
100 struct usb_host_interface
*alt
= NULL
;
101 struct usb_host_endpoint
*in
= NULL
, *out
= NULL
;
102 struct usb_host_endpoint
*status
= NULL
;
104 for (tmp
= 0; tmp
< intf
->num_altsetting
; tmp
++) {
107 in
= out
= status
= NULL
;
108 alt
= intf
->altsetting
+ tmp
;
110 /* take the first altsetting with in-bulk + out-bulk;
111 * remember any status endpoint, just in case;
112 * ignore other endpoints and altsettings.
114 for (ep
= 0; ep
< alt
->desc
.bNumEndpoints
; ep
++) {
115 struct usb_host_endpoint
*e
;
118 e
= alt
->endpoint
+ ep
;
119 switch (e
->desc
.bmAttributes
) {
120 case USB_ENDPOINT_XFER_INT
:
121 if (!usb_endpoint_dir_in(&e
->desc
))
125 case USB_ENDPOINT_XFER_BULK
:
130 if (usb_endpoint_dir_in(&e
->desc
)) {
133 else if (intr
&& !status
)
143 if (!alt
|| !in
|| !out
)
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
);
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
;
161 EXPORT_SYMBOL_GPL(usbnet_get_endpoints
);
163 int usbnet_get_ethernet_addr(struct usbnet
*dev
, int iMACAddress
)
166 unsigned char buf
[13];
168 tmp
= usb_string(dev
->udev
, iMACAddress
, buf
, sizeof buf
);
170 dev_dbg(&dev
->udev
->dev
,
171 "bad MAC string %d fetch, %d\n", iMACAddress
, tmp
);
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]);
181 EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr
);
183 static void intr_complete (struct urb
*urb
)
185 struct usbnet
*dev
= urb
->context
;
186 int status
= urb
->status
;
191 dev
->driver_info
->status(dev
, urb
);
194 /* software-driven interface shutdown */
195 case -ENOENT
: /* urb killed */
196 case -ESHUTDOWN
: /* hardware gone */
197 netif_dbg(dev
, ifdown
, dev
->net
,
198 "intr shutdown, code %d\n", status
);
201 /* NOTE: not throttling like RX/TX, since this endpoint
202 * already polls infrequently
205 netdev_dbg(dev
->net
, "intr status %d\n", status
);
209 if (!netif_running (dev
->net
))
212 status
= usb_submit_urb (urb
, GFP_ATOMIC
);
214 netif_err(dev
, timer
, dev
->net
,
215 "intr resubmit --> %d\n", status
);
218 static int init_status (struct usbnet
*dev
, struct usb_interface
*intf
)
225 if (!dev
->driver_info
->status
)
228 pipe
= usb_rcvintpipe (dev
->udev
,
229 dev
->status
->desc
.bEndpointAddress
230 & USB_ENDPOINT_NUMBER_MASK
);
231 maxp
= usb_maxpacket (dev
->udev
, pipe
, 0);
233 /* avoid 1 msec chatter: min 8 msec poll rate */
234 period
= max ((int) dev
->status
->desc
.bInterval
,
235 (dev
->udev
->speed
== USB_SPEED_HIGH
) ? 7 : 3);
237 buf
= kmalloc (maxp
, GFP_KERNEL
);
239 dev
->interrupt
= usb_alloc_urb (0, GFP_KERNEL
);
240 if (!dev
->interrupt
) {
244 usb_fill_int_urb(dev
->interrupt
, dev
->udev
, pipe
,
245 buf
, maxp
, intr_complete
, dev
, period
);
246 dev
->interrupt
->transfer_flags
|= URB_FREE_BUFFER
;
248 "status ep%din, %d bytes period %d\n",
249 usb_pipeendpoint(pipe
), maxp
, period
);
255 /* Submit the interrupt URB if not previously submitted, increasing refcount */
256 int usbnet_status_start(struct usbnet
*dev
, gfp_t mem_flags
)
260 WARN_ON_ONCE(dev
->interrupt
== NULL
);
261 if (dev
->interrupt
) {
262 mutex_lock(&dev
->interrupt_mutex
);
264 if (++dev
->interrupt_count
== 1)
265 ret
= usb_submit_urb(dev
->interrupt
, mem_flags
);
267 dev_dbg(&dev
->udev
->dev
, "incremented interrupt URB count to %d\n",
268 dev
->interrupt_count
);
269 mutex_unlock(&dev
->interrupt_mutex
);
273 EXPORT_SYMBOL_GPL(usbnet_status_start
);
275 /* For resume; submit interrupt URB if previously submitted */
276 static int __usbnet_status_start_force(struct usbnet
*dev
, gfp_t mem_flags
)
280 mutex_lock(&dev
->interrupt_mutex
);
281 if (dev
->interrupt_count
) {
282 ret
= usb_submit_urb(dev
->interrupt
, mem_flags
);
283 dev_dbg(&dev
->udev
->dev
,
284 "submitted interrupt URB for resume\n");
286 mutex_unlock(&dev
->interrupt_mutex
);
290 /* Kill the interrupt URB if all submitters want it killed */
291 void usbnet_status_stop(struct usbnet
*dev
)
293 if (dev
->interrupt
) {
294 mutex_lock(&dev
->interrupt_mutex
);
295 WARN_ON(dev
->interrupt_count
== 0);
297 if (dev
->interrupt_count
&& --dev
->interrupt_count
== 0)
298 usb_kill_urb(dev
->interrupt
);
300 dev_dbg(&dev
->udev
->dev
,
301 "decremented interrupt URB count to %d\n",
302 dev
->interrupt_count
);
303 mutex_unlock(&dev
->interrupt_mutex
);
306 EXPORT_SYMBOL_GPL(usbnet_status_stop
);
308 /* For suspend; always kill interrupt URB */
309 static void __usbnet_status_stop_force(struct usbnet
*dev
)
311 if (dev
->interrupt
) {
312 mutex_lock(&dev
->interrupt_mutex
);
313 usb_kill_urb(dev
->interrupt
);
314 dev_dbg(&dev
->udev
->dev
, "killed interrupt URB for suspend\n");
315 mutex_unlock(&dev
->interrupt_mutex
);
319 /* Passes this packet up the stack, updating its accounting.
320 * Some link protocols batch packets, so their rx_fixup paths
321 * can return clones as well as just modify the original skb.
323 void usbnet_skb_return (struct usbnet
*dev
, struct sk_buff
*skb
)
327 if (test_bit(EVENT_RX_PAUSED
, &dev
->flags
)) {
328 skb_queue_tail(&dev
->rxq_pause
, skb
);
332 skb
->protocol
= eth_type_trans (skb
, dev
->net
);
333 dev
->net
->stats
.rx_packets
++;
334 dev
->net
->stats
.rx_bytes
+= skb
->len
;
336 netif_dbg(dev
, rx_status
, dev
->net
, "< rx, len %zu, type 0x%x\n",
337 skb
->len
+ sizeof (struct ethhdr
), skb
->protocol
);
338 memset (skb
->cb
, 0, sizeof (struct skb_data
));
340 if (skb_defer_rx_timestamp(skb
))
343 status
= netif_rx (skb
);
344 if (status
!= NET_RX_SUCCESS
)
345 netif_dbg(dev
, rx_err
, dev
->net
,
346 "netif_rx status %d\n", status
);
348 EXPORT_SYMBOL_GPL(usbnet_skb_return
);
351 /*-------------------------------------------------------------------------
353 * Network Device Driver (peer link to "Host Device", from USB host)
355 *-------------------------------------------------------------------------*/
357 int usbnet_change_mtu (struct net_device
*net
, int new_mtu
)
359 struct usbnet
*dev
= netdev_priv(net
);
360 int ll_mtu
= new_mtu
+ net
->hard_header_len
;
361 int old_hard_mtu
= dev
->hard_mtu
;
362 int old_rx_urb_size
= dev
->rx_urb_size
;
366 // no second zero-length packet read wanted after mtu-sized packets
367 if ((ll_mtu
% dev
->maxpacket
) == 0)
371 dev
->hard_mtu
= net
->mtu
+ net
->hard_header_len
;
372 if (dev
->rx_urb_size
== old_hard_mtu
) {
373 dev
->rx_urb_size
= dev
->hard_mtu
;
374 if (dev
->rx_urb_size
> old_rx_urb_size
)
375 usbnet_unlink_rx_urbs(dev
);
380 EXPORT_SYMBOL_GPL(usbnet_change_mtu
);
382 /* The caller must hold list->lock */
383 static void __usbnet_queue_skb(struct sk_buff_head
*list
,
384 struct sk_buff
*newsk
, enum skb_state state
)
386 struct skb_data
*entry
= (struct skb_data
*) newsk
->cb
;
388 __skb_queue_tail(list
, newsk
);
389 entry
->state
= state
;
392 /*-------------------------------------------------------------------------*/
394 /* some LK 2.4 HCDs oopsed if we freed or resubmitted urbs from
395 * completion callbacks. 2.5 should have fixed those bugs...
398 static enum skb_state
defer_bh(struct usbnet
*dev
, struct sk_buff
*skb
,
399 struct sk_buff_head
*list
, enum skb_state state
)
402 enum skb_state old_state
;
403 struct skb_data
*entry
= (struct skb_data
*) skb
->cb
;
405 spin_lock_irqsave(&list
->lock
, flags
);
406 old_state
= entry
->state
;
407 entry
->state
= state
;
408 __skb_unlink(skb
, list
);
409 spin_unlock(&list
->lock
);
410 spin_lock(&dev
->done
.lock
);
411 __skb_queue_tail(&dev
->done
, skb
);
412 if (dev
->done
.qlen
== 1)
413 tasklet_schedule(&dev
->bh
);
414 spin_unlock_irqrestore(&dev
->done
.lock
, flags
);
418 /* some work can't be done in tasklets, so we use keventd
420 * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
421 * but tasklet_schedule() doesn't. hope the failure is rare.
423 void usbnet_defer_kevent (struct usbnet
*dev
, int work
)
425 set_bit (work
, &dev
->flags
);
426 if (!schedule_work (&dev
->kevent
)) {
428 netdev_err(dev
->net
, "kevent %d may have been dropped\n", work
);
430 netdev_dbg(dev
->net
, "kevent %d scheduled\n", work
);
433 EXPORT_SYMBOL_GPL(usbnet_defer_kevent
);
435 /*-------------------------------------------------------------------------*/
437 static void rx_complete (struct urb
*urb
);
439 static int rx_submit (struct usbnet
*dev
, struct urb
*urb
, gfp_t flags
)
442 struct skb_data
*entry
;
444 unsigned long lockflags
;
445 size_t size
= dev
->rx_urb_size
;
447 /* prevent rx skb allocation when error ratio is high */
448 if (test_bit(EVENT_RX_KILL
, &dev
->flags
)) {
453 skb
= __netdev_alloc_skb_ip_align(dev
->net
, size
, flags
);
455 netif_dbg(dev
, rx_err
, dev
->net
, "no rx skb\n");
456 usbnet_defer_kevent (dev
, EVENT_RX_MEMORY
);
461 entry
= (struct skb_data
*) skb
->cb
;
466 usb_fill_bulk_urb (urb
, dev
->udev
, dev
->in
,
467 skb
->data
, size
, rx_complete
, skb
);
469 spin_lock_irqsave (&dev
->rxq
.lock
, lockflags
);
471 if (netif_running (dev
->net
) &&
472 netif_device_present (dev
->net
) &&
473 !test_bit (EVENT_RX_HALT
, &dev
->flags
) &&
474 !test_bit (EVENT_DEV_ASLEEP
, &dev
->flags
)) {
475 switch (retval
= usb_submit_urb (urb
, GFP_ATOMIC
)) {
477 usbnet_defer_kevent (dev
, EVENT_RX_HALT
);
480 usbnet_defer_kevent (dev
, EVENT_RX_MEMORY
);
483 netif_dbg(dev
, ifdown
, dev
->net
, "device gone\n");
484 netif_device_detach (dev
->net
);
490 netif_dbg(dev
, rx_err
, dev
->net
,
491 "rx submit, %d\n", retval
);
492 tasklet_schedule (&dev
->bh
);
495 __usbnet_queue_skb(&dev
->rxq
, skb
, rx_start
);
498 netif_dbg(dev
, ifdown
, dev
->net
, "rx: stopped\n");
501 spin_unlock_irqrestore (&dev
->rxq
.lock
, lockflags
);
503 dev_kfree_skb_any (skb
);
510 /*-------------------------------------------------------------------------*/
512 static inline void rx_process (struct usbnet
*dev
, struct sk_buff
*skb
)
514 if (dev
->driver_info
->rx_fixup
&&
515 !dev
->driver_info
->rx_fixup (dev
, skb
)) {
516 /* With RX_ASSEMBLE, rx_fixup() must update counters */
517 if (!(dev
->driver_info
->flags
& FLAG_RX_ASSEMBLE
))
518 dev
->net
->stats
.rx_errors
++;
521 // else network stack removes extra byte if we forced a short packet
524 /* all data was already cloned from skb inside the driver */
525 if (dev
->driver_info
->flags
& FLAG_MULTI_PACKET
)
526 dev_kfree_skb_any(skb
);
528 usbnet_skb_return(dev
, skb
);
532 netif_dbg(dev
, rx_err
, dev
->net
, "drop\n");
533 dev
->net
->stats
.rx_errors
++;
535 skb_queue_tail(&dev
->done
, skb
);
538 /*-------------------------------------------------------------------------*/
540 static void rx_complete (struct urb
*urb
)
542 struct sk_buff
*skb
= (struct sk_buff
*) urb
->context
;
543 struct skb_data
*entry
= (struct skb_data
*) skb
->cb
;
544 struct usbnet
*dev
= entry
->dev
;
545 int urb_status
= urb
->status
;
546 enum skb_state state
;
548 skb_put (skb
, urb
->actual_length
);
552 switch (urb_status
) {
555 if (skb
->len
< dev
->net
->hard_header_len
) {
557 dev
->net
->stats
.rx_errors
++;
558 dev
->net
->stats
.rx_length_errors
++;
559 netif_dbg(dev
, rx_err
, dev
->net
,
560 "rx length %d\n", skb
->len
);
564 /* stalls need manual reset. this is rare ... except that
565 * when going through USB 2.0 TTs, unplug appears this way.
566 * we avoid the highspeed version of the ETIMEDOUT/EILSEQ
567 * storm, recovering as needed.
570 dev
->net
->stats
.rx_errors
++;
571 usbnet_defer_kevent (dev
, EVENT_RX_HALT
);
574 /* software-driven interface shutdown */
575 case -ECONNRESET
: /* async unlink */
576 case -ESHUTDOWN
: /* hardware gone */
577 netif_dbg(dev
, ifdown
, dev
->net
,
578 "rx shutdown, code %d\n", urb_status
);
581 /* we get controller i/o faults during khubd disconnect() delays.
582 * throttle down resubmits, to avoid log floods; just temporarily,
583 * so we still recover when the fault isn't a khubd delay.
588 dev
->net
->stats
.rx_errors
++;
589 if (!timer_pending (&dev
->delay
)) {
590 mod_timer (&dev
->delay
, jiffies
+ THROTTLE_JIFFIES
);
591 netif_dbg(dev
, link
, dev
->net
,
592 "rx throttle %d\n", urb_status
);
600 /* data overrun ... flush fifo? */
602 dev
->net
->stats
.rx_over_errors
++;
607 dev
->net
->stats
.rx_errors
++;
608 netif_dbg(dev
, rx_err
, dev
->net
, "rx status %d\n", urb_status
);
612 /* stop rx if packet error rate is high */
613 if (++dev
->pkt_cnt
> 30) {
617 if (state
== rx_cleanup
)
619 if (dev
->pkt_err
> 20)
620 set_bit(EVENT_RX_KILL
, &dev
->flags
);
623 state
= defer_bh(dev
, skb
, &dev
->rxq
, state
);
626 if (netif_running (dev
->net
) &&
627 !test_bit (EVENT_RX_HALT
, &dev
->flags
) &&
628 state
!= unlink_start
) {
629 rx_submit (dev
, urb
, GFP_ATOMIC
);
630 usb_mark_last_busy(dev
->udev
);
635 netif_dbg(dev
, rx_err
, dev
->net
, "no read resubmitted\n");
638 /*-------------------------------------------------------------------------*/
639 void usbnet_pause_rx(struct usbnet
*dev
)
641 set_bit(EVENT_RX_PAUSED
, &dev
->flags
);
643 netif_dbg(dev
, rx_status
, dev
->net
, "paused rx queue enabled\n");
645 EXPORT_SYMBOL_GPL(usbnet_pause_rx
);
647 void usbnet_resume_rx(struct usbnet
*dev
)
652 clear_bit(EVENT_RX_PAUSED
, &dev
->flags
);
654 while ((skb
= skb_dequeue(&dev
->rxq_pause
)) != NULL
) {
655 usbnet_skb_return(dev
, skb
);
659 tasklet_schedule(&dev
->bh
);
661 netif_dbg(dev
, rx_status
, dev
->net
,
662 "paused rx queue disabled, %d skbs requeued\n", num
);
664 EXPORT_SYMBOL_GPL(usbnet_resume_rx
);
666 void usbnet_purge_paused_rxq(struct usbnet
*dev
)
668 skb_queue_purge(&dev
->rxq_pause
);
670 EXPORT_SYMBOL_GPL(usbnet_purge_paused_rxq
);
672 /*-------------------------------------------------------------------------*/
674 // unlink pending rx/tx; completion handlers do all other cleanup
676 static int unlink_urbs (struct usbnet
*dev
, struct sk_buff_head
*q
)
682 spin_lock_irqsave (&q
->lock
, flags
);
683 while (!skb_queue_empty(q
)) {
684 struct skb_data
*entry
;
688 skb_queue_walk(q
, skb
) {
689 entry
= (struct skb_data
*) skb
->cb
;
690 if (entry
->state
!= unlink_start
)
695 entry
->state
= unlink_start
;
699 * Get reference count of the URB to avoid it to be
700 * freed during usb_unlink_urb, which may trigger
701 * use-after-free problem inside usb_unlink_urb since
702 * usb_unlink_urb is always racing with .complete
703 * handler(include defer_bh).
706 spin_unlock_irqrestore(&q
->lock
, flags
);
707 // during some PM-driven resume scenarios,
708 // these (async) unlinks complete immediately
709 retval
= usb_unlink_urb (urb
);
710 if (retval
!= -EINPROGRESS
&& retval
!= 0)
711 netdev_dbg(dev
->net
, "unlink urb err, %d\n", retval
);
715 spin_lock_irqsave(&q
->lock
, flags
);
717 spin_unlock_irqrestore (&q
->lock
, flags
);
721 // Flush all pending rx urbs
722 // minidrivers may need to do this when the MTU changes
724 void usbnet_unlink_rx_urbs(struct usbnet
*dev
)
726 if (netif_running(dev
->net
)) {
727 (void) unlink_urbs (dev
, &dev
->rxq
);
728 tasklet_schedule(&dev
->bh
);
731 EXPORT_SYMBOL_GPL(usbnet_unlink_rx_urbs
);
733 /*-------------------------------------------------------------------------*/
735 // precondition: never called in_interrupt
736 static void usbnet_terminate_urbs(struct usbnet
*dev
)
738 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup
);
739 DECLARE_WAITQUEUE(wait
, current
);
742 /* ensure there are no more active urbs */
743 add_wait_queue(&unlink_wakeup
, &wait
);
744 set_current_state(TASK_UNINTERRUPTIBLE
);
745 dev
->wait
= &unlink_wakeup
;
746 temp
= unlink_urbs(dev
, &dev
->txq
) +
747 unlink_urbs(dev
, &dev
->rxq
);
749 /* maybe wait for deletions to finish. */
750 while (!skb_queue_empty(&dev
->rxq
)
751 && !skb_queue_empty(&dev
->txq
)
752 && !skb_queue_empty(&dev
->done
)) {
753 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS
));
754 set_current_state(TASK_UNINTERRUPTIBLE
);
755 netif_dbg(dev
, ifdown
, dev
->net
,
756 "waited for %d urb completions\n", temp
);
758 set_current_state(TASK_RUNNING
);
760 remove_wait_queue(&unlink_wakeup
, &wait
);
763 int usbnet_stop (struct net_device
*net
)
765 struct usbnet
*dev
= netdev_priv(net
);
766 struct driver_info
*info
= dev
->driver_info
;
769 clear_bit(EVENT_DEV_OPEN
, &dev
->flags
);
770 netif_stop_queue (net
);
772 netif_info(dev
, ifdown
, dev
->net
,
773 "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
774 net
->stats
.rx_packets
, net
->stats
.tx_packets
,
775 net
->stats
.rx_errors
, net
->stats
.tx_errors
);
777 /* allow minidriver to stop correctly (wireless devices to turn off
780 retval
= info
->stop(dev
);
782 netif_info(dev
, ifdown
, dev
->net
,
783 "stop fail (%d) usbnet usb-%s-%s, %s\n",
785 dev
->udev
->bus
->bus_name
, dev
->udev
->devpath
,
789 if (!(info
->flags
& FLAG_AVOID_UNLINK_URBS
))
790 usbnet_terminate_urbs(dev
);
792 usbnet_status_stop(dev
);
794 usbnet_purge_paused_rxq(dev
);
796 /* deferred work (task, timer, softirq) must also stop.
797 * can't flush_scheduled_work() until we drop rtnl (later),
798 * else workers could deadlock; so make workers a NOP.
801 del_timer_sync (&dev
->delay
);
802 tasklet_kill (&dev
->bh
);
803 if (info
->manage_power
&&
804 !test_and_clear_bit(EVENT_NO_RUNTIME_PM
, &dev
->flags
))
805 info
->manage_power(dev
, 0);
807 usb_autopm_put_interface(dev
->intf
);
811 EXPORT_SYMBOL_GPL(usbnet_stop
);
813 /*-------------------------------------------------------------------------*/
815 // posts reads, and enables write queuing
817 // precondition: never called in_interrupt
819 int usbnet_open (struct net_device
*net
)
821 struct usbnet
*dev
= netdev_priv(net
);
823 struct driver_info
*info
= dev
->driver_info
;
825 if ((retval
= usb_autopm_get_interface(dev
->intf
)) < 0) {
826 netif_info(dev
, ifup
, dev
->net
,
827 "resumption fail (%d) usbnet usb-%s-%s, %s\n",
829 dev
->udev
->bus
->bus_name
,
835 // put into "known safe" state
836 if (info
->reset
&& (retval
= info
->reset (dev
)) < 0) {
837 netif_info(dev
, ifup
, dev
->net
,
838 "open reset fail (%d) usbnet usb-%s-%s, %s\n",
840 dev
->udev
->bus
->bus_name
,
846 // insist peer be connected
847 if (info
->check_connect
&& (retval
= info
->check_connect (dev
)) < 0) {
848 netif_dbg(dev
, ifup
, dev
->net
, "can't open; %d\n", retval
);
852 /* start any status interrupt transfer */
853 if (dev
->interrupt
) {
854 retval
= usbnet_status_start(dev
, GFP_KERNEL
);
856 netif_err(dev
, ifup
, dev
->net
,
857 "intr submit %d\n", retval
);
862 set_bit(EVENT_DEV_OPEN
, &dev
->flags
);
863 netif_start_queue (net
);
864 netif_info(dev
, ifup
, dev
->net
,
865 "open: enable queueing (rx %d, tx %d) mtu %d %s framing\n",
866 (int)RX_QLEN(dev
), (int)TX_QLEN(dev
),
868 (dev
->driver_info
->flags
& FLAG_FRAMING_NC
) ? "NetChip" :
869 (dev
->driver_info
->flags
& FLAG_FRAMING_GL
) ? "GeneSys" :
870 (dev
->driver_info
->flags
& FLAG_FRAMING_Z
) ? "Zaurus" :
871 (dev
->driver_info
->flags
& FLAG_FRAMING_RN
) ? "RNDIS" :
872 (dev
->driver_info
->flags
& FLAG_FRAMING_AX
) ? "ASIX" :
875 /* reset rx error state */
878 clear_bit(EVENT_RX_KILL
, &dev
->flags
);
880 // delay posting reads until we're fully open
881 tasklet_schedule (&dev
->bh
);
882 if (info
->manage_power
) {
883 retval
= info
->manage_power(dev
, 1);
886 set_bit(EVENT_NO_RUNTIME_PM
, &dev
->flags
);
888 usb_autopm_put_interface(dev
->intf
);
893 usb_autopm_put_interface(dev
->intf
);
897 EXPORT_SYMBOL_GPL(usbnet_open
);
899 /*-------------------------------------------------------------------------*/
901 /* ethtool methods; minidrivers may need to add some more, but
902 * they'll probably want to use this base set.
905 int usbnet_get_settings (struct net_device
*net
, struct ethtool_cmd
*cmd
)
907 struct usbnet
*dev
= netdev_priv(net
);
909 if (!dev
->mii
.mdio_read
)
912 return mii_ethtool_gset(&dev
->mii
, cmd
);
914 EXPORT_SYMBOL_GPL(usbnet_get_settings
);
916 int usbnet_set_settings (struct net_device
*net
, struct ethtool_cmd
*cmd
)
918 struct usbnet
*dev
= netdev_priv(net
);
921 if (!dev
->mii
.mdio_write
)
924 retval
= mii_ethtool_sset(&dev
->mii
, cmd
);
926 /* link speed/duplex might have changed */
927 if (dev
->driver_info
->link_reset
)
928 dev
->driver_info
->link_reset(dev
);
933 EXPORT_SYMBOL_GPL(usbnet_set_settings
);
935 u32
usbnet_get_link (struct net_device
*net
)
937 struct usbnet
*dev
= netdev_priv(net
);
939 /* If a check_connect is defined, return its result */
940 if (dev
->driver_info
->check_connect
)
941 return dev
->driver_info
->check_connect (dev
) == 0;
943 /* if the device has mii operations, use those */
944 if (dev
->mii
.mdio_read
)
945 return mii_link_ok(&dev
->mii
);
947 /* Otherwise, dtrt for drivers calling netif_carrier_{on,off} */
948 return ethtool_op_get_link(net
);
950 EXPORT_SYMBOL_GPL(usbnet_get_link
);
952 int usbnet_nway_reset(struct net_device
*net
)
954 struct usbnet
*dev
= netdev_priv(net
);
956 if (!dev
->mii
.mdio_write
)
959 return mii_nway_restart(&dev
->mii
);
961 EXPORT_SYMBOL_GPL(usbnet_nway_reset
);
963 void usbnet_get_drvinfo (struct net_device
*net
, struct ethtool_drvinfo
*info
)
965 struct usbnet
*dev
= netdev_priv(net
);
967 strlcpy (info
->driver
, dev
->driver_name
, sizeof info
->driver
);
968 strlcpy (info
->version
, DRIVER_VERSION
, sizeof info
->version
);
969 strlcpy (info
->fw_version
, dev
->driver_info
->description
,
970 sizeof info
->fw_version
);
971 usb_make_path (dev
->udev
, info
->bus_info
, sizeof info
->bus_info
);
973 EXPORT_SYMBOL_GPL(usbnet_get_drvinfo
);
975 u32
usbnet_get_msglevel (struct net_device
*net
)
977 struct usbnet
*dev
= netdev_priv(net
);
979 return dev
->msg_enable
;
981 EXPORT_SYMBOL_GPL(usbnet_get_msglevel
);
983 void usbnet_set_msglevel (struct net_device
*net
, u32 level
)
985 struct usbnet
*dev
= netdev_priv(net
);
987 dev
->msg_enable
= level
;
989 EXPORT_SYMBOL_GPL(usbnet_set_msglevel
);
991 /* drivers may override default ethtool_ops in their bind() routine */
992 static const struct ethtool_ops usbnet_ethtool_ops
= {
993 .get_settings
= usbnet_get_settings
,
994 .set_settings
= usbnet_set_settings
,
995 .get_link
= usbnet_get_link
,
996 .nway_reset
= usbnet_nway_reset
,
997 .get_drvinfo
= usbnet_get_drvinfo
,
998 .get_msglevel
= usbnet_get_msglevel
,
999 .set_msglevel
= usbnet_set_msglevel
,
1000 .get_ts_info
= ethtool_op_get_ts_info
,
1003 /*-------------------------------------------------------------------------*/
1005 static void __handle_link_change(struct usbnet
*dev
)
1007 if (!test_bit(EVENT_DEV_OPEN
, &dev
->flags
))
1010 if (!netif_carrier_ok(dev
->net
)) {
1011 /* kill URBs for reading packets to save bus bandwidth */
1012 unlink_urbs(dev
, &dev
->rxq
);
1015 * tx_timeout will unlink URBs for sending packets and
1016 * tx queue is stopped by netcore after link becomes off
1019 /* submitting URBs for reading packets */
1020 tasklet_schedule(&dev
->bh
);
1023 clear_bit(EVENT_LINK_CHANGE
, &dev
->flags
);
1026 /* work that cannot be done in interrupt context uses keventd.
1028 * NOTE: with 2.5 we could do more of this using completion callbacks,
1029 * especially now that control transfers can be queued.
1032 kevent (struct work_struct
*work
)
1034 struct usbnet
*dev
=
1035 container_of(work
, struct usbnet
, kevent
);
1038 /* usb_clear_halt() needs a thread context */
1039 if (test_bit (EVENT_TX_HALT
, &dev
->flags
)) {
1040 unlink_urbs (dev
, &dev
->txq
);
1041 status
= usb_autopm_get_interface(dev
->intf
);
1044 status
= usb_clear_halt (dev
->udev
, dev
->out
);
1045 usb_autopm_put_interface(dev
->intf
);
1048 status
!= -ESHUTDOWN
) {
1049 if (netif_msg_tx_err (dev
))
1051 netdev_err(dev
->net
, "can't clear tx halt, status %d\n",
1054 clear_bit (EVENT_TX_HALT
, &dev
->flags
);
1055 if (status
!= -ESHUTDOWN
)
1056 netif_wake_queue (dev
->net
);
1059 if (test_bit (EVENT_RX_HALT
, &dev
->flags
)) {
1060 unlink_urbs (dev
, &dev
->rxq
);
1061 status
= usb_autopm_get_interface(dev
->intf
);
1064 status
= usb_clear_halt (dev
->udev
, dev
->in
);
1065 usb_autopm_put_interface(dev
->intf
);
1068 status
!= -ESHUTDOWN
) {
1069 if (netif_msg_rx_err (dev
))
1071 netdev_err(dev
->net
, "can't clear rx halt, status %d\n",
1074 clear_bit (EVENT_RX_HALT
, &dev
->flags
);
1075 tasklet_schedule (&dev
->bh
);
1079 /* tasklet could resubmit itself forever if memory is tight */
1080 if (test_bit (EVENT_RX_MEMORY
, &dev
->flags
)) {
1081 struct urb
*urb
= NULL
;
1084 if (netif_running (dev
->net
))
1085 urb
= usb_alloc_urb (0, GFP_KERNEL
);
1087 clear_bit (EVENT_RX_MEMORY
, &dev
->flags
);
1089 clear_bit (EVENT_RX_MEMORY
, &dev
->flags
);
1090 status
= usb_autopm_get_interface(dev
->intf
);
1095 if (rx_submit (dev
, urb
, GFP_KERNEL
) == -ENOLINK
)
1097 usb_autopm_put_interface(dev
->intf
);
1100 tasklet_schedule (&dev
->bh
);
1104 if (test_bit (EVENT_LINK_RESET
, &dev
->flags
)) {
1105 struct driver_info
*info
= dev
->driver_info
;
1108 clear_bit (EVENT_LINK_RESET
, &dev
->flags
);
1109 status
= usb_autopm_get_interface(dev
->intf
);
1112 if(info
->link_reset
&& (retval
= info
->link_reset(dev
)) < 0) {
1113 usb_autopm_put_interface(dev
->intf
);
1115 netdev_info(dev
->net
, "link reset failed (%d) usbnet usb-%s-%s, %s\n",
1117 dev
->udev
->bus
->bus_name
,
1121 usb_autopm_put_interface(dev
->intf
);
1124 /* handle link change from link resetting */
1125 __handle_link_change(dev
);
1128 if (test_bit (EVENT_LINK_CHANGE
, &dev
->flags
))
1129 __handle_link_change(dev
);
1132 netdev_dbg(dev
->net
, "kevent done, flags = 0x%lx\n", dev
->flags
);
1135 /*-------------------------------------------------------------------------*/
1137 static void tx_complete (struct urb
*urb
)
1139 struct sk_buff
*skb
= (struct sk_buff
*) urb
->context
;
1140 struct skb_data
*entry
= (struct skb_data
*) skb
->cb
;
1141 struct usbnet
*dev
= entry
->dev
;
1143 if (urb
->status
== 0) {
1144 if (!(dev
->driver_info
->flags
& FLAG_MULTI_PACKET
))
1145 dev
->net
->stats
.tx_packets
++;
1146 dev
->net
->stats
.tx_bytes
+= entry
->length
;
1148 dev
->net
->stats
.tx_errors
++;
1150 switch (urb
->status
) {
1152 usbnet_defer_kevent (dev
, EVENT_TX_HALT
);
1155 /* software-driven interface shutdown */
1156 case -ECONNRESET
: // async unlink
1157 case -ESHUTDOWN
: // hardware gone
1160 // like rx, tx gets controller i/o faults during khubd delays
1161 // and so it uses the same throttling mechanism.
1165 usb_mark_last_busy(dev
->udev
);
1166 if (!timer_pending (&dev
->delay
)) {
1167 mod_timer (&dev
->delay
,
1168 jiffies
+ THROTTLE_JIFFIES
);
1169 netif_dbg(dev
, link
, dev
->net
,
1170 "tx throttle %d\n", urb
->status
);
1172 netif_stop_queue (dev
->net
);
1175 netif_dbg(dev
, tx_err
, dev
->net
,
1176 "tx err %d\n", entry
->urb
->status
);
1181 usb_autopm_put_interface_async(dev
->intf
);
1182 (void) defer_bh(dev
, skb
, &dev
->txq
, tx_done
);
1185 /*-------------------------------------------------------------------------*/
1187 void usbnet_tx_timeout (struct net_device
*net
)
1189 struct usbnet
*dev
= netdev_priv(net
);
1191 unlink_urbs (dev
, &dev
->txq
);
1192 tasklet_schedule (&dev
->bh
);
1194 // FIXME: device recovery -- reset?
1196 EXPORT_SYMBOL_GPL(usbnet_tx_timeout
);
1198 /*-------------------------------------------------------------------------*/
1200 static int build_dma_sg(const struct sk_buff
*skb
, struct urb
*urb
)
1202 unsigned num_sgs
, total_len
= 0;
1205 num_sgs
= skb_shinfo(skb
)->nr_frags
+ 1;
1209 urb
->sg
= kmalloc(num_sgs
* sizeof(struct scatterlist
), GFP_ATOMIC
);
1213 urb
->num_sgs
= num_sgs
;
1214 sg_init_table(urb
->sg
, urb
->num_sgs
);
1216 sg_set_buf(&urb
->sg
[s
++], skb
->data
, skb_headlen(skb
));
1217 total_len
+= skb_headlen(skb
);
1219 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
1220 struct skb_frag_struct
*f
= &skb_shinfo(skb
)->frags
[i
];
1222 total_len
+= skb_frag_size(f
);
1223 sg_set_page(&urb
->sg
[i
+ s
], f
->page
.p
, f
->size
,
1226 urb
->transfer_buffer_length
= total_len
;
1231 netdev_tx_t
usbnet_start_xmit (struct sk_buff
*skb
,
1232 struct net_device
*net
)
1234 struct usbnet
*dev
= netdev_priv(net
);
1236 struct urb
*urb
= NULL
;
1237 struct skb_data
*entry
;
1238 struct driver_info
*info
= dev
->driver_info
;
1239 unsigned long flags
;
1243 skb_tx_timestamp(skb
);
1245 // some devices want funky USB-level framing, for
1246 // win32 driver (usually) and/or hardware quirks
1247 if (info
->tx_fixup
) {
1248 skb
= info
->tx_fixup (dev
, skb
, GFP_ATOMIC
);
1250 /* packet collected; minidriver waiting for more */
1251 if (info
->flags
& FLAG_MULTI_PACKET
)
1253 netif_dbg(dev
, tx_err
, dev
->net
, "can't tx_fixup skb\n");
1258 if (!(urb
= usb_alloc_urb (0, GFP_ATOMIC
))) {
1259 netif_dbg(dev
, tx_err
, dev
->net
, "no urb\n");
1263 entry
= (struct skb_data
*) skb
->cb
;
1267 usb_fill_bulk_urb (urb
, dev
->udev
, dev
->out
,
1268 skb
->data
, skb
->len
, tx_complete
, skb
);
1269 if (dev
->can_dma_sg
) {
1270 if (build_dma_sg(skb
, urb
) < 0)
1273 entry
->length
= length
= urb
->transfer_buffer_length
;
1275 /* don't assume the hardware handles USB_ZERO_PACKET
1276 * NOTE: strictly conforming cdc-ether devices should expect
1277 * the ZLP here, but ignore the one-byte packet.
1278 * NOTE2: CDC NCM specification is different from CDC ECM when
1279 * handling ZLP/short packets, so cdc_ncm driver will make short
1280 * packet itself if needed.
1282 if (length
% dev
->maxpacket
== 0) {
1283 if (!(info
->flags
& FLAG_SEND_ZLP
)) {
1284 if (!(info
->flags
& FLAG_MULTI_PACKET
)) {
1285 urb
->transfer_buffer_length
++;
1286 if (skb_tailroom(skb
)) {
1287 skb
->data
[skb
->len
] = 0;
1292 urb
->transfer_flags
|= URB_ZERO_PACKET
;
1295 spin_lock_irqsave(&dev
->txq
.lock
, flags
);
1296 retval
= usb_autopm_get_interface_async(dev
->intf
);
1298 spin_unlock_irqrestore(&dev
->txq
.lock
, flags
);
1303 /* if this triggers the device is still a sleep */
1304 if (test_bit(EVENT_DEV_ASLEEP
, &dev
->flags
)) {
1305 /* transmission will be done in resume */
1306 usb_anchor_urb(urb
, &dev
->deferred
);
1307 /* no use to process more packets */
1308 netif_stop_queue(net
);
1310 spin_unlock_irqrestore(&dev
->txq
.lock
, flags
);
1311 netdev_dbg(dev
->net
, "Delaying transmission for resumption\n");
1316 switch ((retval
= usb_submit_urb (urb
, GFP_ATOMIC
))) {
1318 netif_stop_queue (net
);
1319 usbnet_defer_kevent (dev
, EVENT_TX_HALT
);
1320 usb_autopm_put_interface_async(dev
->intf
);
1323 usb_autopm_put_interface_async(dev
->intf
);
1324 netif_dbg(dev
, tx_err
, dev
->net
,
1325 "tx: submit urb err %d\n", retval
);
1328 net
->trans_start
= jiffies
;
1329 __usbnet_queue_skb(&dev
->txq
, skb
, tx_start
);
1330 if (dev
->txq
.qlen
>= TX_QLEN (dev
))
1331 netif_stop_queue (net
);
1333 spin_unlock_irqrestore (&dev
->txq
.lock
, flags
);
1336 netif_dbg(dev
, tx_err
, dev
->net
, "drop, code %d\n", retval
);
1338 dev
->net
->stats
.tx_dropped
++;
1341 dev_kfree_skb_any (skb
);
1347 netif_dbg(dev
, tx_queued
, dev
->net
,
1348 "> tx, len %d, type 0x%x\n", length
, skb
->protocol
);
1352 return NETDEV_TX_OK
;
1354 EXPORT_SYMBOL_GPL(usbnet_start_xmit
);
1356 static int rx_alloc_submit(struct usbnet
*dev
, gfp_t flags
)
1362 /* don't refill the queue all at once */
1363 for (i
= 0; i
< 10 && dev
->rxq
.qlen
< RX_QLEN(dev
); i
++) {
1364 urb
= usb_alloc_urb(0, flags
);
1366 ret
= rx_submit(dev
, urb
, flags
);
1378 /*-------------------------------------------------------------------------*/
1380 // tasklet (work deferred from completions, in_irq) or timer
1382 static void usbnet_bh (unsigned long param
)
1384 struct usbnet
*dev
= (struct usbnet
*) param
;
1385 struct sk_buff
*skb
;
1386 struct skb_data
*entry
;
1388 while ((skb
= skb_dequeue (&dev
->done
))) {
1389 entry
= (struct skb_data
*) skb
->cb
;
1390 switch (entry
->state
) {
1392 entry
->state
= rx_cleanup
;
1393 rx_process (dev
, skb
);
1396 kfree(entry
->urb
->sg
);
1398 usb_free_urb (entry
->urb
);
1399 dev_kfree_skb (skb
);
1402 netdev_dbg(dev
->net
, "bogus skb state %d\n", entry
->state
);
1406 /* restart RX again after disabling due to high error rate */
1407 clear_bit(EVENT_RX_KILL
, &dev
->flags
);
1409 // waiting for all pending urbs to complete?
1411 if ((dev
->txq
.qlen
+ dev
->rxq
.qlen
+ dev
->done
.qlen
) == 0) {
1412 wake_up (dev
->wait
);
1415 // or are we maybe short a few urbs?
1416 } else if (netif_running (dev
->net
) &&
1417 netif_device_present (dev
->net
) &&
1418 netif_carrier_ok(dev
->net
) &&
1419 !timer_pending (&dev
->delay
) &&
1420 !test_bit (EVENT_RX_HALT
, &dev
->flags
)) {
1421 int temp
= dev
->rxq
.qlen
;
1423 if (temp
< RX_QLEN(dev
)) {
1424 if (rx_alloc_submit(dev
, GFP_ATOMIC
) == -ENOLINK
)
1426 if (temp
!= dev
->rxq
.qlen
)
1427 netif_dbg(dev
, link
, dev
->net
,
1428 "rxqlen %d --> %d\n",
1429 temp
, dev
->rxq
.qlen
);
1430 if (dev
->rxq
.qlen
< RX_QLEN(dev
))
1431 tasklet_schedule (&dev
->bh
);
1433 if (dev
->txq
.qlen
< TX_QLEN (dev
))
1434 netif_wake_queue (dev
->net
);
1439 /*-------------------------------------------------------------------------
1441 * USB Device Driver support
1443 *-------------------------------------------------------------------------*/
1445 // precondition: never called in_interrupt
1447 void usbnet_disconnect (struct usb_interface
*intf
)
1450 struct usb_device
*xdev
;
1451 struct net_device
*net
;
1453 dev
= usb_get_intfdata(intf
);
1454 usb_set_intfdata(intf
, NULL
);
1458 xdev
= interface_to_usbdev (intf
);
1460 netif_info(dev
, probe
, dev
->net
, "unregister '%s' usb-%s-%s, %s\n",
1461 intf
->dev
.driver
->name
,
1462 xdev
->bus
->bus_name
, xdev
->devpath
,
1463 dev
->driver_info
->description
);
1466 unregister_netdev (net
);
1468 cancel_work_sync(&dev
->kevent
);
1470 usb_scuttle_anchored_urbs(&dev
->deferred
);
1472 if (dev
->driver_info
->unbind
)
1473 dev
->driver_info
->unbind (dev
, intf
);
1475 usb_kill_urb(dev
->interrupt
);
1476 usb_free_urb(dev
->interrupt
);
1480 EXPORT_SYMBOL_GPL(usbnet_disconnect
);
1482 static const struct net_device_ops usbnet_netdev_ops
= {
1483 .ndo_open
= usbnet_open
,
1484 .ndo_stop
= usbnet_stop
,
1485 .ndo_start_xmit
= usbnet_start_xmit
,
1486 .ndo_tx_timeout
= usbnet_tx_timeout
,
1487 .ndo_change_mtu
= usbnet_change_mtu
,
1488 .ndo_set_mac_address
= eth_mac_addr
,
1489 .ndo_validate_addr
= eth_validate_addr
,
1492 /*-------------------------------------------------------------------------*/
1494 // precondition: never called in_interrupt
1496 static struct device_type wlan_type
= {
1500 static struct device_type wwan_type
= {
1505 usbnet_probe (struct usb_interface
*udev
, const struct usb_device_id
*prod
)
1508 struct net_device
*net
;
1509 struct usb_host_interface
*interface
;
1510 struct driver_info
*info
;
1511 struct usb_device
*xdev
;
1514 struct usb_driver
*driver
= to_usb_driver(udev
->dev
.driver
);
1516 /* usbnet already took usb runtime pm, so have to enable the feature
1517 * for usb interface, otherwise usb_autopm_get_interface may return
1518 * failure if RUNTIME_PM is enabled.
1520 if (!driver
->supports_autosuspend
) {
1521 driver
->supports_autosuspend
= 1;
1522 pm_runtime_enable(&udev
->dev
);
1525 name
= udev
->dev
.driver
->name
;
1526 info
= (struct driver_info
*) prod
->driver_info
;
1528 dev_dbg (&udev
->dev
, "blacklisted by %s\n", name
);
1531 xdev
= interface_to_usbdev (udev
);
1532 interface
= udev
->cur_altsetting
;
1536 // set up our own records
1537 net
= alloc_etherdev(sizeof(*dev
));
1541 /* netdev_printk() needs this so do it as early as possible */
1542 SET_NETDEV_DEV(net
, &udev
->dev
);
1544 dev
= netdev_priv(net
);
1547 dev
->driver_info
= info
;
1548 dev
->driver_name
= name
;
1549 dev
->msg_enable
= netif_msg_init (msg_level
, NETIF_MSG_DRV
1550 | NETIF_MSG_PROBE
| NETIF_MSG_LINK
);
1551 skb_queue_head_init (&dev
->rxq
);
1552 skb_queue_head_init (&dev
->txq
);
1553 skb_queue_head_init (&dev
->done
);
1554 skb_queue_head_init(&dev
->rxq_pause
);
1555 dev
->bh
.func
= usbnet_bh
;
1556 dev
->bh
.data
= (unsigned long) dev
;
1557 INIT_WORK (&dev
->kevent
, kevent
);
1558 init_usb_anchor(&dev
->deferred
);
1559 dev
->delay
.function
= usbnet_bh
;
1560 dev
->delay
.data
= (unsigned long) dev
;
1561 init_timer (&dev
->delay
);
1562 mutex_init (&dev
->phy_mutex
);
1563 mutex_init(&dev
->interrupt_mutex
);
1564 dev
->interrupt_count
= 0;
1567 strcpy (net
->name
, "usb%d");
1568 memcpy (net
->dev_addr
, node_id
, sizeof node_id
);
1570 /* rx and tx sides can use different message sizes;
1571 * bind() should set rx_urb_size in that case.
1573 dev
->hard_mtu
= net
->mtu
+ net
->hard_header_len
;
1575 // dma_supported() is deeply broken on almost all architectures
1576 // possible with some EHCI controllers
1577 if (dma_supported (&udev
->dev
, DMA_BIT_MASK(64)))
1578 net
->features
|= NETIF_F_HIGHDMA
;
1581 net
->netdev_ops
= &usbnet_netdev_ops
;
1582 net
->watchdog_timeo
= TX_TIMEOUT_JIFFIES
;
1583 net
->ethtool_ops
= &usbnet_ethtool_ops
;
1585 // allow device-specific bind/init procedures
1586 // NOTE net->name still not usable ...
1588 status
= info
->bind (dev
, udev
);
1592 // heuristic: "usb%d" for links we know are two-host,
1593 // else "eth%d" when there's reasonable doubt. userspace
1594 // can rename the link if it knows better.
1595 if ((dev
->driver_info
->flags
& FLAG_ETHER
) != 0 &&
1596 ((dev
->driver_info
->flags
& FLAG_POINTTOPOINT
) == 0 ||
1597 (net
->dev_addr
[0] & 0x02) == 0))
1598 strcpy (net
->name
, "eth%d");
1599 /* WLAN devices should always be named "wlan%d" */
1600 if ((dev
->driver_info
->flags
& FLAG_WLAN
) != 0)
1601 strcpy(net
->name
, "wlan%d");
1602 /* WWAN devices should always be named "wwan%d" */
1603 if ((dev
->driver_info
->flags
& FLAG_WWAN
) != 0)
1604 strcpy(net
->name
, "wwan%d");
1606 /* devices that cannot do ARP */
1607 if ((dev
->driver_info
->flags
& FLAG_NOARP
) != 0)
1608 net
->flags
|= IFF_NOARP
;
1610 /* maybe the remote can't receive an Ethernet MTU */
1611 if (net
->mtu
> (dev
->hard_mtu
- net
->hard_header_len
))
1612 net
->mtu
= dev
->hard_mtu
- net
->hard_header_len
;
1613 } else if (!info
->in
|| !info
->out
)
1614 status
= usbnet_get_endpoints (dev
, udev
);
1616 dev
->in
= usb_rcvbulkpipe (xdev
, info
->in
);
1617 dev
->out
= usb_sndbulkpipe (xdev
, info
->out
);
1618 if (!(info
->flags
& FLAG_NO_SETINT
))
1619 status
= usb_set_interface (xdev
,
1620 interface
->desc
.bInterfaceNumber
,
1621 interface
->desc
.bAlternateSetting
);
1626 if (status
>= 0 && dev
->status
)
1627 status
= init_status (dev
, udev
);
1631 if (!dev
->rx_urb_size
)
1632 dev
->rx_urb_size
= dev
->hard_mtu
;
1633 dev
->maxpacket
= usb_maxpacket (dev
->udev
, dev
->out
, 1);
1635 if ((dev
->driver_info
->flags
& FLAG_WLAN
) != 0)
1636 SET_NETDEV_DEVTYPE(net
, &wlan_type
);
1637 if ((dev
->driver_info
->flags
& FLAG_WWAN
) != 0)
1638 SET_NETDEV_DEVTYPE(net
, &wwan_type
);
1640 status
= register_netdev (net
);
1643 netif_info(dev
, probe
, dev
->net
,
1644 "register '%s' at usb-%s-%s, %s, %pM\n",
1645 udev
->dev
.driver
->name
,
1646 xdev
->bus
->bus_name
, xdev
->devpath
,
1647 dev
->driver_info
->description
,
1650 // ok, it's ready to go.
1651 usb_set_intfdata (udev
, dev
);
1653 netif_device_attach (net
);
1655 if (dev
->driver_info
->flags
& FLAG_LINK_INTR
)
1656 usbnet_link_change(dev
, 0, 0);
1661 usb_free_urb(dev
->interrupt
);
1664 info
->unbind (dev
, udev
);
1670 EXPORT_SYMBOL_GPL(usbnet_probe
);
1672 /*-------------------------------------------------------------------------*/
1675 * suspend the whole driver as soon as the first interface is suspended
1676 * resume only when the last interface is resumed
1679 int usbnet_suspend (struct usb_interface
*intf
, pm_message_t message
)
1681 struct usbnet
*dev
= usb_get_intfdata(intf
);
1683 if (!dev
->suspend_count
++) {
1684 spin_lock_irq(&dev
->txq
.lock
);
1685 /* don't autosuspend while transmitting */
1686 if (dev
->txq
.qlen
&& PMSG_IS_AUTO(message
)) {
1687 dev
->suspend_count
--;
1688 spin_unlock_irq(&dev
->txq
.lock
);
1691 set_bit(EVENT_DEV_ASLEEP
, &dev
->flags
);
1692 spin_unlock_irq(&dev
->txq
.lock
);
1695 * accelerate emptying of the rx and queues, to avoid
1696 * having everything error out.
1698 netif_device_detach (dev
->net
);
1699 usbnet_terminate_urbs(dev
);
1700 __usbnet_status_stop_force(dev
);
1703 * reattach so runtime management can use and
1706 netif_device_attach (dev
->net
);
1710 EXPORT_SYMBOL_GPL(usbnet_suspend
);
1712 int usbnet_resume (struct usb_interface
*intf
)
1714 struct usbnet
*dev
= usb_get_intfdata(intf
);
1715 struct sk_buff
*skb
;
1719 if (!--dev
->suspend_count
) {
1720 /* resume interrupt URB if it was previously submitted */
1721 __usbnet_status_start_force(dev
, GFP_NOIO
);
1723 spin_lock_irq(&dev
->txq
.lock
);
1724 while ((res
= usb_get_from_anchor(&dev
->deferred
))) {
1726 skb
= (struct sk_buff
*)res
->context
;
1727 retval
= usb_submit_urb(res
, GFP_ATOMIC
);
1729 dev_kfree_skb_any(skb
);
1732 usb_autopm_put_interface_async(dev
->intf
);
1734 dev
->net
->trans_start
= jiffies
;
1735 __skb_queue_tail(&dev
->txq
, skb
);
1740 clear_bit(EVENT_DEV_ASLEEP
, &dev
->flags
);
1741 spin_unlock_irq(&dev
->txq
.lock
);
1743 if (test_bit(EVENT_DEV_OPEN
, &dev
->flags
)) {
1744 /* handle remote wakeup ASAP */
1746 netif_device_present(dev
->net
) &&
1747 !timer_pending(&dev
->delay
) &&
1748 !test_bit(EVENT_RX_HALT
, &dev
->flags
))
1749 rx_alloc_submit(dev
, GFP_NOIO
);
1751 if (!(dev
->txq
.qlen
>= TX_QLEN(dev
)))
1752 netif_tx_wake_all_queues(dev
->net
);
1753 tasklet_schedule (&dev
->bh
);
1757 if (test_and_clear_bit(EVENT_DEVICE_REPORT_IDLE
, &dev
->flags
))
1758 usb_autopm_get_interface_no_resume(intf
);
1762 EXPORT_SYMBOL_GPL(usbnet_resume
);
1765 * Either a subdriver implements manage_power, then it is assumed to always
1766 * be ready to be suspended or it reports the readiness to be suspended
1769 void usbnet_device_suggests_idle(struct usbnet
*dev
)
1771 if (!test_and_set_bit(EVENT_DEVICE_REPORT_IDLE
, &dev
->flags
)) {
1772 dev
->intf
->needs_remote_wakeup
= 1;
1773 usb_autopm_put_interface_async(dev
->intf
);
1776 EXPORT_SYMBOL(usbnet_device_suggests_idle
);
1779 * For devices that can do without special commands
1781 int usbnet_manage_power(struct usbnet
*dev
, int on
)
1783 dev
->intf
->needs_remote_wakeup
= on
;
1786 EXPORT_SYMBOL(usbnet_manage_power
);
1788 void usbnet_link_change(struct usbnet
*dev
, bool link
, bool need_reset
)
1790 /* update link after link is reseted */
1791 if (link
&& !need_reset
)
1792 netif_carrier_on(dev
->net
);
1794 netif_carrier_off(dev
->net
);
1796 if (need_reset
&& link
)
1797 usbnet_defer_kevent(dev
, EVENT_LINK_RESET
);
1799 usbnet_defer_kevent(dev
, EVENT_LINK_CHANGE
);
1801 EXPORT_SYMBOL(usbnet_link_change
);
1803 /*-------------------------------------------------------------------------*/
1804 static int __usbnet_read_cmd(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
1805 u16 value
, u16 index
, void *data
, u16 size
)
1810 netdev_dbg(dev
->net
, "usbnet_read_cmd cmd=0x%02x reqtype=%02x"
1811 " value=0x%04x index=0x%04x size=%d\n",
1812 cmd
, reqtype
, value
, index
, size
);
1815 buf
= kmalloc(size
, GFP_KERNEL
);
1820 err
= usb_control_msg(dev
->udev
, usb_rcvctrlpipe(dev
->udev
, 0),
1821 cmd
, reqtype
, value
, index
, buf
, size
,
1822 USB_CTRL_GET_TIMEOUT
);
1823 if (err
> 0 && err
<= size
)
1824 memcpy(data
, buf
, err
);
1830 static int __usbnet_write_cmd(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
1831 u16 value
, u16 index
, const void *data
,
1837 netdev_dbg(dev
->net
, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
1838 " value=0x%04x index=0x%04x size=%d\n",
1839 cmd
, reqtype
, value
, index
, size
);
1842 buf
= kmemdup(data
, size
, GFP_KERNEL
);
1847 err
= usb_control_msg(dev
->udev
, usb_sndctrlpipe(dev
->udev
, 0),
1848 cmd
, reqtype
, value
, index
, buf
, size
,
1849 USB_CTRL_SET_TIMEOUT
);
1857 * The function can't be called inside suspend/resume callback,
1858 * otherwise deadlock will be caused.
1860 int usbnet_read_cmd(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
1861 u16 value
, u16 index
, void *data
, u16 size
)
1865 if (usb_autopm_get_interface(dev
->intf
) < 0)
1867 ret
= __usbnet_read_cmd(dev
, cmd
, reqtype
, value
, index
,
1869 usb_autopm_put_interface(dev
->intf
);
1872 EXPORT_SYMBOL_GPL(usbnet_read_cmd
);
1875 * The function can't be called inside suspend/resume callback,
1876 * otherwise deadlock will be caused.
1878 int usbnet_write_cmd(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
1879 u16 value
, u16 index
, const void *data
, u16 size
)
1883 if (usb_autopm_get_interface(dev
->intf
) < 0)
1885 ret
= __usbnet_write_cmd(dev
, cmd
, reqtype
, value
, index
,
1887 usb_autopm_put_interface(dev
->intf
);
1890 EXPORT_SYMBOL_GPL(usbnet_write_cmd
);
1893 * The function can be called inside suspend/resume callback safely
1894 * and should only be called by suspend/resume callback generally.
1896 int usbnet_read_cmd_nopm(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
1897 u16 value
, u16 index
, void *data
, u16 size
)
1899 return __usbnet_read_cmd(dev
, cmd
, reqtype
, value
, index
,
1902 EXPORT_SYMBOL_GPL(usbnet_read_cmd_nopm
);
1905 * The function can be called inside suspend/resume callback safely
1906 * and should only be called by suspend/resume callback generally.
1908 int usbnet_write_cmd_nopm(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
1909 u16 value
, u16 index
, const void *data
,
1912 return __usbnet_write_cmd(dev
, cmd
, reqtype
, value
, index
,
1915 EXPORT_SYMBOL_GPL(usbnet_write_cmd_nopm
);
1917 static void usbnet_async_cmd_cb(struct urb
*urb
)
1919 struct usb_ctrlrequest
*req
= (struct usb_ctrlrequest
*)urb
->context
;
1920 int status
= urb
->status
;
1923 dev_dbg(&urb
->dev
->dev
, "%s failed with %d",
1931 * The caller must make sure that device can't be put into suspend
1932 * state until the control URB completes.
1934 int usbnet_write_cmd_async(struct usbnet
*dev
, u8 cmd
, u8 reqtype
,
1935 u16 value
, u16 index
, const void *data
, u16 size
)
1937 struct usb_ctrlrequest
*req
= NULL
;
1942 netdev_dbg(dev
->net
, "usbnet_write_cmd cmd=0x%02x reqtype=%02x"
1943 " value=0x%04x index=0x%04x size=%d\n",
1944 cmd
, reqtype
, value
, index
, size
);
1946 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
1948 netdev_err(dev
->net
, "Error allocating URB in"
1949 " %s!\n", __func__
);
1954 buf
= kmemdup(data
, size
, GFP_ATOMIC
);
1956 netdev_err(dev
->net
, "Error allocating buffer"
1957 " in %s!\n", __func__
);
1962 req
= kmalloc(sizeof(struct usb_ctrlrequest
), GFP_ATOMIC
);
1966 req
->bRequestType
= reqtype
;
1967 req
->bRequest
= cmd
;
1968 req
->wValue
= cpu_to_le16(value
);
1969 req
->wIndex
= cpu_to_le16(index
);
1970 req
->wLength
= cpu_to_le16(size
);
1972 usb_fill_control_urb(urb
, dev
->udev
,
1973 usb_sndctrlpipe(dev
->udev
, 0),
1974 (void *)req
, buf
, size
,
1975 usbnet_async_cmd_cb
, req
);
1976 urb
->transfer_flags
|= URB_FREE_BUFFER
;
1978 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
1980 netdev_err(dev
->net
, "Error submitting the control"
1981 " message: status=%d\n", err
);
1995 EXPORT_SYMBOL_GPL(usbnet_write_cmd_async
);
1996 /*-------------------------------------------------------------------------*/
1998 static int __init
usbnet_init(void)
2000 /* Compiler should optimize this out. */
2002 FIELD_SIZEOF(struct sk_buff
, cb
) < sizeof(struct skb_data
));
2004 eth_random_addr(node_id
);
2007 module_init(usbnet_init
);
2009 static void __exit
usbnet_exit(void)
2012 module_exit(usbnet_exit
);
2014 MODULE_AUTHOR("David Brownell");
2015 MODULE_DESCRIPTION("USB network driver framework");
2016 MODULE_LICENSE("GPL");