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