aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/gadget/ether.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/usb/gadget/ether.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'drivers/usb/gadget/ether.c')
-rw-r--r--drivers/usb/gadget/ether.c2660
1 files changed, 2660 insertions, 0 deletions
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
new file mode 100644
index 000000000000..cff9fb0b73cc
--- /dev/null
+++ b/drivers/usb/gadget/ether.c
@@ -0,0 +1,2660 @@
1/*
2 * ether.c -- Ethernet gadget driver, with CDC and non-CDC options
3 *
4 * Copyright (C) 2003-2005 David Brownell
5 * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22
23// #define DEBUG 1
24// #define VERBOSE
25
26#include <linux/config.h>
27#include <linux/module.h>
28#include <linux/kernel.h>
29#include <linux/delay.h>
30#include <linux/ioport.h>
31#include <linux/sched.h>
32#include <linux/slab.h>
33#include <linux/smp_lock.h>
34#include <linux/errno.h>
35#include <linux/init.h>
36#include <linux/timer.h>
37#include <linux/list.h>
38#include <linux/interrupt.h>
39#include <linux/utsname.h>
40#include <linux/device.h>
41#include <linux/moduleparam.h>
42#include <linux/ctype.h>
43
44#include <asm/byteorder.h>
45#include <asm/io.h>
46#include <asm/irq.h>
47#include <asm/system.h>
48#include <asm/uaccess.h>
49#include <asm/unaligned.h>
50
51#include <linux/usb_ch9.h>
52#include <linux/usb_cdc.h>
53#include <linux/usb_gadget.h>
54
55#include <linux/random.h>
56#include <linux/netdevice.h>
57#include <linux/etherdevice.h>
58#include <linux/ethtool.h>
59
60#include "gadget_chips.h"
61
62/*-------------------------------------------------------------------------*/
63
64/*
65 * Ethernet gadget driver -- with CDC and non-CDC options
66 * Builds on hardware support for a full duplex link.
67 *
68 * CDC Ethernet is the standard USB solution for sending Ethernet frames
69 * using USB. Real hardware tends to use the same framing protocol but look
70 * different for control features. This driver strongly prefers to use
71 * this USB-IF standard as its open-systems interoperability solution;
72 * most host side USB stacks (except from Microsoft) support it.
73 *
74 * There's some hardware that can't talk CDC. We make that hardware
75 * implement a "minimalist" vendor-agnostic CDC core: same framing, but
76 * link-level setup only requires activating the configuration.
77 * Linux supports it, but other host operating systems may not.
78 * (This is a subset of CDC Ethernet.)
79 *
80 * A third option is also in use. Rather than CDC Ethernet, or something
81 * simpler, Microsoft pushes their own approach: RNDIS. The published
82 * RNDIS specs are ambiguous and appear to be incomplete, and are also
83 * needlessly complex.
84 */
85
86#define DRIVER_DESC "Ethernet Gadget"
87#define DRIVER_VERSION "Equinox 2004"
88
89static const char shortname [] = "ether";
90static const char driver_desc [] = DRIVER_DESC;
91
92#define RX_EXTRA 20 /* guard against rx overflows */
93
94#ifdef CONFIG_USB_ETH_RNDIS
95#include "rndis.h"
96#else
97#define rndis_init() 0
98#define rndis_exit() do{}while(0)
99#endif
100
101/* CDC and RNDIS support the same host-chosen outgoing packet filters. */
102#define DEFAULT_FILTER (USB_CDC_PACKET_TYPE_BROADCAST \
103 |USB_CDC_PACKET_TYPE_DIRECTED)
104
105
106/*-------------------------------------------------------------------------*/
107
108struct eth_dev {
109 spinlock_t lock;
110 struct usb_gadget *gadget;
111 struct usb_request *req; /* for control responses */
112 struct usb_request *stat_req; /* for cdc & rndis status */
113
114 u8 config;
115 struct usb_ep *in_ep, *out_ep, *status_ep;
116 const struct usb_endpoint_descriptor
117 *in, *out, *status;
118 struct list_head tx_reqs, rx_reqs;
119
120 struct net_device *net;
121 struct net_device_stats stats;
122 atomic_t tx_qlen;
123
124 struct work_struct work;
125 unsigned zlp:1;
126 unsigned cdc:1;
127 unsigned rndis:1;
128 unsigned suspended:1;
129 u16 cdc_filter;
130 unsigned long todo;
131#define WORK_RX_MEMORY 0
132 int rndis_config;
133 u8 host_mac [ETH_ALEN];
134};
135
136/* This version autoconfigures as much as possible at run-time.
137 *
138 * It also ASSUMES a self-powered device, without remote wakeup,
139 * although remote wakeup support would make sense.
140 */
141static const char *EP_IN_NAME;
142static const char *EP_OUT_NAME;
143static const char *EP_STATUS_NAME;
144
145/*-------------------------------------------------------------------------*/
146
147/* DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
148 * Instead: allocate your own, using normal USB-IF procedures.
149 */
150
151/* Thanks to NetChip Technologies for donating this product ID.
152 * It's for devices with only CDC Ethernet configurations.
153 */
154#define CDC_VENDOR_NUM 0x0525 /* NetChip */
155#define CDC_PRODUCT_NUM 0xa4a1 /* Linux-USB Ethernet Gadget */
156
157/* For hardware that can't talk CDC, we use the same vendor ID that
158 * ARM Linux has used for ethernet-over-usb, both with sa1100 and
159 * with pxa250. We're protocol-compatible, if the host-side drivers
160 * use the endpoint descriptors. bcdDevice (version) is nonzero, so
161 * drivers that need to hard-wire endpoint numbers have a hook.
162 *
163 * The protocol is a minimal subset of CDC Ether, which works on any bulk
164 * hardware that's not deeply broken ... even on hardware that can't talk
165 * RNDIS (like SA-1100, with no interrupt endpoint, or anything that
166 * doesn't handle control-OUT).
167 */
168#define SIMPLE_VENDOR_NUM 0x049f
169#define SIMPLE_PRODUCT_NUM 0x505a
170
171/* For hardware that can talk RNDIS and either of the above protocols,
172 * use this ID ... the windows INF files will know it. Unless it's
173 * used with CDC Ethernet, Linux 2.4 hosts will need updates to choose
174 * the non-RNDIS configuration.
175 */
176#define RNDIS_VENDOR_NUM 0x0525 /* NetChip */
177#define RNDIS_PRODUCT_NUM 0xa4a2 /* Ethernet/RNDIS Gadget */
178
179
180/* Some systems will want different product identifers published in the
181 * device descriptor, either numbers or strings or both. These string
182 * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
183 */
184
185static ushort __initdata idVendor;
186module_param(idVendor, ushort, S_IRUGO);
187MODULE_PARM_DESC(idVendor, "USB Vendor ID");
188
189static ushort __initdata idProduct;
190module_param(idProduct, ushort, S_IRUGO);
191MODULE_PARM_DESC(idProduct, "USB Product ID");
192
193static ushort __initdata bcdDevice;
194module_param(bcdDevice, ushort, S_IRUGO);
195MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
196
197static char *__initdata iManufacturer;
198module_param(iManufacturer, charp, S_IRUGO);
199MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
200
201static char *__initdata iProduct;
202module_param(iProduct, charp, S_IRUGO);
203MODULE_PARM_DESC(iProduct, "USB Product string");
204
205/* initial value, changed by "ifconfig usb0 hw ether xx:xx:xx:xx:xx:xx" */
206static char *__initdata dev_addr;
207module_param(dev_addr, charp, S_IRUGO);
208MODULE_PARM_DESC(dev_addr, "Device Ethernet Address");
209
210/* this address is invisible to ifconfig */
211static char *__initdata host_addr;
212module_param(host_addr, charp, S_IRUGO);
213MODULE_PARM_DESC(host_addr, "Host Ethernet Address");
214
215
216/*-------------------------------------------------------------------------*/
217
218/* Include CDC support if we could run on CDC-capable hardware. */
219
220#ifdef CONFIG_USB_GADGET_NET2280
221#define DEV_CONFIG_CDC
222#endif
223
224#ifdef CONFIG_USB_GADGET_DUMMY_HCD
225#define DEV_CONFIG_CDC
226#endif
227
228#ifdef CONFIG_USB_GADGET_GOKU
229#define DEV_CONFIG_CDC
230#endif
231
232#ifdef CONFIG_USB_GADGET_LH7A40X
233#define DEV_CONFIG_CDC
234#endif
235
236#ifdef CONFIG_USB_GADGET_MQ11XX
237#define DEV_CONFIG_CDC
238#endif
239
240#ifdef CONFIG_USB_GADGET_OMAP
241#define DEV_CONFIG_CDC
242#endif
243
244#ifdef CONFIG_USB_GADGET_N9604
245#define DEV_CONFIG_CDC
246#endif
247
248#ifdef CONFIG_USB_GADGET_PXA27X
249#define DEV_CONFIG_CDC
250#endif
251
252#ifdef CONFIG_USB_GADGET_AT91
253#define DEV_CONFIG_CDC
254#endif
255
256
257/* For CDC-incapable hardware, choose the simple cdc subset.
258 * Anything that talks bulk (without notable bugs) can do this.
259 */
260#ifdef CONFIG_USB_GADGET_PXA2XX
261#define DEV_CONFIG_SUBSET
262#endif
263
264#ifdef CONFIG_USB_GADGET_SH
265#define DEV_CONFIG_SUBSET
266#endif
267
268#ifdef CONFIG_USB_GADGET_SA1100
269/* use non-CDC for backwards compatibility */
270#define DEV_CONFIG_SUBSET
271#endif
272
273#ifdef CONFIG_USB_GADGET_S3C2410
274#define DEV_CONFIG_CDC
275#endif
276
277/*-------------------------------------------------------------------------*/
278
279/* "main" config is either CDC, or its simple subset */
280static inline int is_cdc(struct eth_dev *dev)
281{
282#if !defined(DEV_CONFIG_SUBSET)
283 return 1; /* only cdc possible */
284#elif !defined (DEV_CONFIG_CDC)
285 return 0; /* only subset possible */
286#else
287 return dev->cdc; /* depends on what hardware we found */
288#endif
289}
290
291/* "secondary" RNDIS config may sometimes be activated */
292static inline int rndis_active(struct eth_dev *dev)
293{
294#ifdef CONFIG_USB_ETH_RNDIS
295 return dev->rndis;
296#else
297 return 0;
298#endif
299}
300
301#define subset_active(dev) (!is_cdc(dev) && !rndis_active(dev))
302#define cdc_active(dev) ( is_cdc(dev) && !rndis_active(dev))
303
304
305
306#define DEFAULT_QLEN 2 /* double buffering by default */
307
308/* peak bulk transfer bits-per-second */
309#define HS_BPS (13 * 512 * 8 * 1000 * 8)
310#define FS_BPS (19 * 64 * 1 * 1000 * 8)
311
312#ifdef CONFIG_USB_GADGET_DUALSPEED
313
314static unsigned qmult = 5;
315module_param (qmult, uint, S_IRUGO|S_IWUSR);
316
317
318/* for dual-speed hardware, use deeper queues at highspeed */
319#define qlen(gadget) \
320 (DEFAULT_QLEN*((gadget->speed == USB_SPEED_HIGH) ? qmult : 1))
321
322/* also defer IRQs on highspeed TX */
323#define TX_DELAY qmult
324
325#define BITRATE(g) (((g)->speed == USB_SPEED_HIGH) ? HS_BPS : FS_BPS)
326
327#else /* full speed (low speed doesn't do bulk) */
328#define qlen(gadget) DEFAULT_QLEN
329
330#define BITRATE(g) FS_BPS
331#endif
332
333
334/*-------------------------------------------------------------------------*/
335
336#define xprintk(d,level,fmt,args...) \
337 printk(level "%s: " fmt , (d)->net->name , ## args)
338
339#ifdef DEBUG
340#undef DEBUG
341#define DEBUG(dev,fmt,args...) \
342 xprintk(dev , KERN_DEBUG , fmt , ## args)
343#else
344#define DEBUG(dev,fmt,args...) \
345 do { } while (0)
346#endif /* DEBUG */
347
348#ifdef VERBOSE
349#define VDEBUG DEBUG
350#else
351#define VDEBUG(dev,fmt,args...) \
352 do { } while (0)
353#endif /* DEBUG */
354
355#define ERROR(dev,fmt,args...) \
356 xprintk(dev , KERN_ERR , fmt , ## args)
357#define WARN(dev,fmt,args...) \
358 xprintk(dev , KERN_WARNING , fmt , ## args)
359#define INFO(dev,fmt,args...) \
360 xprintk(dev , KERN_INFO , fmt , ## args)
361
362/*-------------------------------------------------------------------------*/
363
364/* USB DRIVER HOOKUP (to the hardware driver, below us), mostly
365 * ep0 implementation: descriptors, config management, setup().
366 * also optional class-specific notification interrupt transfer.
367 */
368
369/*
370 * DESCRIPTORS ... most are static, but strings and (full) configuration
371 * descriptors are built on demand. For now we do either full CDC, or
372 * our simple subset, with RNDIS as an optional second configuration.
373 *
374 * RNDIS includes some CDC ACM descriptors ... like CDC Ethernet. But
375 * the class descriptors match a modem (they're ignored; it's really just
376 * Ethernet functionality), they don't need the NOP altsetting, and the
377 * status transfer endpoint isn't optional.
378 */
379
380#define STRING_MANUFACTURER 1
381#define STRING_PRODUCT 2
382#define STRING_ETHADDR 3
383#define STRING_DATA 4
384#define STRING_CONTROL 5
385#define STRING_RNDIS_CONTROL 6
386#define STRING_CDC 7
387#define STRING_SUBSET 8
388#define STRING_RNDIS 9
389
390#define USB_BUFSIZ 256 /* holds our biggest descriptor */
391
392/*
393 * This device advertises one configuration, eth_config, unless RNDIS
394 * is enabled (rndis_config) on hardware supporting at least two configs.
395 *
396 * NOTE: Controllers like superh_udc should probably be able to use
397 * an RNDIS-only configuration.
398 *
399 * FIXME define some higher-powered configurations to make it easier
400 * to recharge batteries ...
401 */
402
403#define DEV_CONFIG_VALUE 1 /* cdc or subset */
404#define DEV_RNDIS_CONFIG_VALUE 2 /* rndis; optional */
405
406static struct usb_device_descriptor
407device_desc = {
408 .bLength = sizeof device_desc,
409 .bDescriptorType = USB_DT_DEVICE,
410
411 .bcdUSB = __constant_cpu_to_le16 (0x0200),
412
413 .bDeviceClass = USB_CLASS_COMM,
414 .bDeviceSubClass = 0,
415 .bDeviceProtocol = 0,
416
417 .idVendor = __constant_cpu_to_le16 (CDC_VENDOR_NUM),
418 .idProduct = __constant_cpu_to_le16 (CDC_PRODUCT_NUM),
419 .iManufacturer = STRING_MANUFACTURER,
420 .iProduct = STRING_PRODUCT,
421 .bNumConfigurations = 1,
422};
423
424static struct usb_otg_descriptor
425otg_descriptor = {
426 .bLength = sizeof otg_descriptor,
427 .bDescriptorType = USB_DT_OTG,
428
429 .bmAttributes = USB_OTG_SRP,
430};
431
432static struct usb_config_descriptor
433eth_config = {
434 .bLength = sizeof eth_config,
435 .bDescriptorType = USB_DT_CONFIG,
436
437 /* compute wTotalLength on the fly */
438 .bNumInterfaces = 2,
439 .bConfigurationValue = DEV_CONFIG_VALUE,
440 .iConfiguration = STRING_CDC,
441 .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
442 .bMaxPower = 50,
443};
444
445#ifdef CONFIG_USB_ETH_RNDIS
446static struct usb_config_descriptor
447rndis_config = {
448 .bLength = sizeof rndis_config,
449 .bDescriptorType = USB_DT_CONFIG,
450
451 /* compute wTotalLength on the fly */
452 .bNumInterfaces = 2,
453 .bConfigurationValue = DEV_RNDIS_CONFIG_VALUE,
454 .iConfiguration = STRING_RNDIS,
455 .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
456 .bMaxPower = 50,
457};
458#endif
459
460/*
461 * Compared to the simple CDC subset, the full CDC Ethernet model adds
462 * three class descriptors, two interface descriptors, optional status
463 * endpoint. Both have a "data" interface and two bulk endpoints.
464 * There are also differences in how control requests are handled.
465 *
466 * RNDIS shares a lot with CDC-Ethernet, since it's a variant of
467 * the CDC-ACM (modem) spec.
468 */
469
470#ifdef DEV_CONFIG_CDC
471static struct usb_interface_descriptor
472control_intf = {
473 .bLength = sizeof control_intf,
474 .bDescriptorType = USB_DT_INTERFACE,
475
476 .bInterfaceNumber = 0,
477 /* status endpoint is optional; this may be patched later */
478 .bNumEndpoints = 1,
479 .bInterfaceClass = USB_CLASS_COMM,
480 .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
481 .bInterfaceProtocol = USB_CDC_PROTO_NONE,
482 .iInterface = STRING_CONTROL,
483};
484#endif
485
486#ifdef CONFIG_USB_ETH_RNDIS
487static const struct usb_interface_descriptor
488rndis_control_intf = {
489 .bLength = sizeof rndis_control_intf,
490 .bDescriptorType = USB_DT_INTERFACE,
491
492 .bInterfaceNumber = 0,
493 .bNumEndpoints = 1,
494 .bInterfaceClass = USB_CLASS_COMM,
495 .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
496 .bInterfaceProtocol = USB_CDC_ACM_PROTO_VENDOR,
497 .iInterface = STRING_RNDIS_CONTROL,
498};
499#endif
500
501#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
502
503static const struct usb_cdc_header_desc header_desc = {
504 .bLength = sizeof header_desc,
505 .bDescriptorType = USB_DT_CS_INTERFACE,
506 .bDescriptorSubType = USB_CDC_HEADER_TYPE,
507
508 .bcdCDC = __constant_cpu_to_le16 (0x0110),
509};
510
511static const struct usb_cdc_union_desc union_desc = {
512 .bLength = sizeof union_desc,
513 .bDescriptorType = USB_DT_CS_INTERFACE,
514 .bDescriptorSubType = USB_CDC_UNION_TYPE,
515
516 .bMasterInterface0 = 0, /* index of control interface */
517 .bSlaveInterface0 = 1, /* index of DATA interface */
518};
519
520#endif /* CDC || RNDIS */
521
522#ifdef CONFIG_USB_ETH_RNDIS
523
524static const struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor = {
525 .bLength = sizeof call_mgmt_descriptor,
526 .bDescriptorType = USB_DT_CS_INTERFACE,
527 .bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE,
528
529 .bmCapabilities = 0x00,
530 .bDataInterface = 0x01,
531};
532
533static struct usb_cdc_acm_descriptor acm_descriptor = {
534 .bLength = sizeof acm_descriptor,
535 .bDescriptorType = USB_DT_CS_INTERFACE,
536 .bDescriptorSubType = USB_CDC_ACM_TYPE,
537
538 .bmCapabilities = 0x00,
539};
540
541#endif
542
543#ifdef DEV_CONFIG_CDC
544
545static const struct usb_cdc_ether_desc ether_desc = {
546 .bLength = sizeof ether_desc,
547 .bDescriptorType = USB_DT_CS_INTERFACE,
548 .bDescriptorSubType = USB_CDC_ETHERNET_TYPE,
549
550 /* this descriptor actually adds value, surprise! */
551 .iMACAddress = STRING_ETHADDR,
552 .bmEthernetStatistics = __constant_cpu_to_le32 (0), /* no statistics */
553 .wMaxSegmentSize = __constant_cpu_to_le16 (ETH_FRAME_LEN),
554 .wNumberMCFilters = __constant_cpu_to_le16 (0),
555 .bNumberPowerFilters = 0,
556};
557
558#endif
559
560#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
561
562/* include the status endpoint if we can, even where it's optional.
563 * use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
564 * packet, to simplify cancelation; and a big transfer interval, to
565 * waste less bandwidth.
566 *
567 * some drivers (like Linux 2.4 cdc-ether!) "need" it to exist even
568 * if they ignore the connect/disconnect notifications that real aether
569 * can provide. more advanced cdc configurations might want to support
570 * encapsulated commands (vendor-specific, using control-OUT).
571 *
572 * RNDIS requires the status endpoint, since it uses that encapsulation
573 * mechanism for its funky RPC scheme.
574 */
575
576#define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */
577#define STATUS_BYTECOUNT 16 /* 8 byte header + data */
578
579static struct usb_endpoint_descriptor
580fs_status_desc = {
581 .bLength = USB_DT_ENDPOINT_SIZE,
582 .bDescriptorType = USB_DT_ENDPOINT,
583
584 .bEndpointAddress = USB_DIR_IN,
585 .bmAttributes = USB_ENDPOINT_XFER_INT,
586 .wMaxPacketSize = __constant_cpu_to_le16 (STATUS_BYTECOUNT),
587 .bInterval = 1 << LOG2_STATUS_INTERVAL_MSEC,
588};
589#endif
590
591#ifdef DEV_CONFIG_CDC
592
593/* the default data interface has no endpoints ... */
594
595static const struct usb_interface_descriptor
596data_nop_intf = {
597 .bLength = sizeof data_nop_intf,
598 .bDescriptorType = USB_DT_INTERFACE,
599
600 .bInterfaceNumber = 1,
601 .bAlternateSetting = 0,
602 .bNumEndpoints = 0,
603 .bInterfaceClass = USB_CLASS_CDC_DATA,
604 .bInterfaceSubClass = 0,
605 .bInterfaceProtocol = 0,
606};
607
608/* ... but the "real" data interface has two bulk endpoints */
609
610static const struct usb_interface_descriptor
611data_intf = {
612 .bLength = sizeof data_intf,
613 .bDescriptorType = USB_DT_INTERFACE,
614
615 .bInterfaceNumber = 1,
616 .bAlternateSetting = 1,
617 .bNumEndpoints = 2,
618 .bInterfaceClass = USB_CLASS_CDC_DATA,
619 .bInterfaceSubClass = 0,
620 .bInterfaceProtocol = 0,
621 .iInterface = STRING_DATA,
622};
623
624#endif
625
626#ifdef CONFIG_USB_ETH_RNDIS
627
628/* RNDIS doesn't activate by changing to the "real" altsetting */
629
630static const struct usb_interface_descriptor
631rndis_data_intf = {
632 .bLength = sizeof rndis_data_intf,
633 .bDescriptorType = USB_DT_INTERFACE,
634
635 .bInterfaceNumber = 1,
636 .bAlternateSetting = 0,
637 .bNumEndpoints = 2,
638 .bInterfaceClass = USB_CLASS_CDC_DATA,
639 .bInterfaceSubClass = 0,
640 .bInterfaceProtocol = 0,
641 .iInterface = STRING_DATA,
642};
643
644#endif
645
646#ifdef DEV_CONFIG_SUBSET
647
648/*
649 * "Simple" CDC-subset option is a simple vendor-neutral model that most
650 * full speed controllers can handle: one interface, two bulk endpoints.
651 */
652
653static const struct usb_interface_descriptor
654subset_data_intf = {
655 .bLength = sizeof subset_data_intf,
656 .bDescriptorType = USB_DT_INTERFACE,
657
658 .bInterfaceNumber = 0,
659 .bAlternateSetting = 0,
660 .bNumEndpoints = 2,
661 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
662 .bInterfaceSubClass = 0,
663 .bInterfaceProtocol = 0,
664 .iInterface = STRING_DATA,
665};
666
667#endif /* SUBSET */
668
669
670static struct usb_endpoint_descriptor
671fs_source_desc = {
672 .bLength = USB_DT_ENDPOINT_SIZE,
673 .bDescriptorType = USB_DT_ENDPOINT,
674
675 .bEndpointAddress = USB_DIR_IN,
676 .bmAttributes = USB_ENDPOINT_XFER_BULK,
677};
678
679static struct usb_endpoint_descriptor
680fs_sink_desc = {
681 .bLength = USB_DT_ENDPOINT_SIZE,
682 .bDescriptorType = USB_DT_ENDPOINT,
683
684 .bEndpointAddress = USB_DIR_OUT,
685 .bmAttributes = USB_ENDPOINT_XFER_BULK,
686};
687
688static const struct usb_descriptor_header *fs_eth_function [11] = {
689 (struct usb_descriptor_header *) &otg_descriptor,
690#ifdef DEV_CONFIG_CDC
691 /* "cdc" mode descriptors */
692 (struct usb_descriptor_header *) &control_intf,
693 (struct usb_descriptor_header *) &header_desc,
694 (struct usb_descriptor_header *) &union_desc,
695 (struct usb_descriptor_header *) &ether_desc,
696 /* NOTE: status endpoint may need to be removed */
697 (struct usb_descriptor_header *) &fs_status_desc,
698 /* data interface, with altsetting */
699 (struct usb_descriptor_header *) &data_nop_intf,
700 (struct usb_descriptor_header *) &data_intf,
701 (struct usb_descriptor_header *) &fs_source_desc,
702 (struct usb_descriptor_header *) &fs_sink_desc,
703 NULL,
704#endif /* DEV_CONFIG_CDC */
705};
706
707static inline void __init fs_subset_descriptors(void)
708{
709#ifdef DEV_CONFIG_SUBSET
710 fs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;
711 fs_eth_function[2] = (struct usb_descriptor_header *) &fs_source_desc;
712 fs_eth_function[3] = (struct usb_descriptor_header *) &fs_sink_desc;
713 fs_eth_function[4] = NULL;
714#else
715 fs_eth_function[1] = NULL;
716#endif
717}
718
719#ifdef CONFIG_USB_ETH_RNDIS
720static const struct usb_descriptor_header *fs_rndis_function [] = {
721 (struct usb_descriptor_header *) &otg_descriptor,
722 /* control interface matches ACM, not Ethernet */
723 (struct usb_descriptor_header *) &rndis_control_intf,
724 (struct usb_descriptor_header *) &header_desc,
725 (struct usb_descriptor_header *) &call_mgmt_descriptor,
726 (struct usb_descriptor_header *) &acm_descriptor,
727 (struct usb_descriptor_header *) &union_desc,
728 (struct usb_descriptor_header *) &fs_status_desc,
729 /* data interface has no altsetting */
730 (struct usb_descriptor_header *) &rndis_data_intf,
731 (struct usb_descriptor_header *) &fs_source_desc,
732 (struct usb_descriptor_header *) &fs_sink_desc,
733 NULL,
734};
735#endif
736
737#ifdef CONFIG_USB_GADGET_DUALSPEED
738
739/*
740 * usb 2.0 devices need to expose both high speed and full speed
741 * descriptors, unless they only run at full speed.
742 */
743
744#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
745static struct usb_endpoint_descriptor
746hs_status_desc = {
747 .bLength = USB_DT_ENDPOINT_SIZE,
748 .bDescriptorType = USB_DT_ENDPOINT,
749
750 .bmAttributes = USB_ENDPOINT_XFER_INT,
751 .wMaxPacketSize = __constant_cpu_to_le16 (STATUS_BYTECOUNT),
752 .bInterval = LOG2_STATUS_INTERVAL_MSEC + 4,
753};
754#endif /* DEV_CONFIG_CDC */
755
756static struct usb_endpoint_descriptor
757hs_source_desc = {
758 .bLength = USB_DT_ENDPOINT_SIZE,
759 .bDescriptorType = USB_DT_ENDPOINT,
760
761 .bmAttributes = USB_ENDPOINT_XFER_BULK,
762 .wMaxPacketSize = __constant_cpu_to_le16 (512),
763};
764
765static struct usb_endpoint_descriptor
766hs_sink_desc = {
767 .bLength = USB_DT_ENDPOINT_SIZE,
768 .bDescriptorType = USB_DT_ENDPOINT,
769
770 .bmAttributes = USB_ENDPOINT_XFER_BULK,
771 .wMaxPacketSize = __constant_cpu_to_le16 (512),
772};
773
774static struct usb_qualifier_descriptor
775dev_qualifier = {
776 .bLength = sizeof dev_qualifier,
777 .bDescriptorType = USB_DT_DEVICE_QUALIFIER,
778
779 .bcdUSB = __constant_cpu_to_le16 (0x0200),
780 .bDeviceClass = USB_CLASS_COMM,
781
782 .bNumConfigurations = 1,
783};
784
785static const struct usb_descriptor_header *hs_eth_function [11] = {
786 (struct usb_descriptor_header *) &otg_descriptor,
787#ifdef DEV_CONFIG_CDC
788 /* "cdc" mode descriptors */
789 (struct usb_descriptor_header *) &control_intf,
790 (struct usb_descriptor_header *) &header_desc,
791 (struct usb_descriptor_header *) &union_desc,
792 (struct usb_descriptor_header *) &ether_desc,
793 /* NOTE: status endpoint may need to be removed */
794 (struct usb_descriptor_header *) &hs_status_desc,
795 /* data interface, with altsetting */
796 (struct usb_descriptor_header *) &data_nop_intf,
797 (struct usb_descriptor_header *) &data_intf,
798 (struct usb_descriptor_header *) &hs_source_desc,
799 (struct usb_descriptor_header *) &hs_sink_desc,
800 NULL,
801#endif /* DEV_CONFIG_CDC */
802};
803
804static inline void __init hs_subset_descriptors(void)
805{
806#ifdef DEV_CONFIG_SUBSET
807 hs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;
808 hs_eth_function[2] = (struct usb_descriptor_header *) &fs_source_desc;
809 hs_eth_function[3] = (struct usb_descriptor_header *) &fs_sink_desc;
810 hs_eth_function[4] = NULL;
811#else
812 hs_eth_function[1] = NULL;
813#endif
814}
815
816#ifdef CONFIG_USB_ETH_RNDIS
817static const struct usb_descriptor_header *hs_rndis_function [] = {
818 (struct usb_descriptor_header *) &otg_descriptor,
819 /* control interface matches ACM, not Ethernet */
820 (struct usb_descriptor_header *) &rndis_control_intf,
821 (struct usb_descriptor_header *) &header_desc,
822 (struct usb_descriptor_header *) &call_mgmt_descriptor,
823 (struct usb_descriptor_header *) &acm_descriptor,
824 (struct usb_descriptor_header *) &union_desc,
825 (struct usb_descriptor_header *) &hs_status_desc,
826 /* data interface has no altsetting */
827 (struct usb_descriptor_header *) &rndis_data_intf,
828 (struct usb_descriptor_header *) &hs_source_desc,
829 (struct usb_descriptor_header *) &hs_sink_desc,
830 NULL,
831};
832#endif
833
834
835/* maxpacket and other transfer characteristics vary by speed. */
836#define ep_desc(g,hs,fs) (((g)->speed==USB_SPEED_HIGH)?(hs):(fs))
837
838#else
839
840/* if there's no high speed support, maxpacket doesn't change. */
841#define ep_desc(g,hs,fs) fs
842
843static inline void __init hs_subset_descriptors(void)
844{
845}
846
847#endif /* !CONFIG_USB_GADGET_DUALSPEED */
848
849/*-------------------------------------------------------------------------*/
850
851/* descriptors that are built on-demand */
852
853static char manufacturer [50];
854static char product_desc [40] = DRIVER_DESC;
855
856#ifdef DEV_CONFIG_CDC
857/* address that the host will use ... usually assigned at random */
858static char ethaddr [2 * ETH_ALEN + 1];
859#endif
860
861/* static strings, in UTF-8 */
862static struct usb_string strings [] = {
863 { STRING_MANUFACTURER, manufacturer, },
864 { STRING_PRODUCT, product_desc, },
865 { STRING_DATA, "Ethernet Data", },
866#ifdef DEV_CONFIG_CDC
867 { STRING_CDC, "CDC Ethernet", },
868 { STRING_ETHADDR, ethaddr, },
869 { STRING_CONTROL, "CDC Communications Control", },
870#endif
871#ifdef DEV_CONFIG_SUBSET
872 { STRING_SUBSET, "CDC Ethernet Subset", },
873#endif
874#ifdef CONFIG_USB_ETH_RNDIS
875 { STRING_RNDIS, "RNDIS", },
876 { STRING_RNDIS_CONTROL, "RNDIS Communications Control", },
877#endif
878 { } /* end of list */
879};
880
881static struct usb_gadget_strings stringtab = {
882 .language = 0x0409, /* en-us */
883 .strings = strings,
884};
885
886/*
887 * one config, two interfaces: control, data.
888 * complications: class descriptors, and an altsetting.
889 */
890static int
891config_buf (enum usb_device_speed speed,
892 u8 *buf, u8 type,
893 unsigned index, int is_otg)
894{
895 int len;
896 const struct usb_config_descriptor *config;
897 const struct usb_descriptor_header **function;
898#ifdef CONFIG_USB_GADGET_DUALSPEED
899 int hs = (speed == USB_SPEED_HIGH);
900
901 if (type == USB_DT_OTHER_SPEED_CONFIG)
902 hs = !hs;
903#define which_fn(t) (hs ? hs_ ## t ## _function : fs_ ## t ## _function)
904#else
905#define which_fn(t) (fs_ ## t ## _function)
906#endif
907
908 if (index >= device_desc.bNumConfigurations)
909 return -EINVAL;
910
911#ifdef CONFIG_USB_ETH_RNDIS
912 /* list the RNDIS config first, to make Microsoft's drivers
913 * happy. DOCSIS 1.0 needs this too.
914 */
915 if (device_desc.bNumConfigurations == 2 && index == 0) {
916 config = &rndis_config;
917 function = which_fn (rndis);
918 } else
919#endif
920 {
921 config = &eth_config;
922 function = which_fn (eth);
923 }
924
925 /* for now, don't advertise srp-only devices */
926 if (!is_otg)
927 function++;
928
929 len = usb_gadget_config_buf (config, buf, USB_BUFSIZ, function);
930 if (len < 0)
931 return len;
932 ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
933 return len;
934}
935
936/*-------------------------------------------------------------------------*/
937
938static void eth_start (struct eth_dev *dev, int gfp_flags);
939static int alloc_requests (struct eth_dev *dev, unsigned n, int gfp_flags);
940
941#ifdef DEV_CONFIG_CDC
942static inline int ether_alt_ep_setup (struct eth_dev *dev, struct usb_ep *ep)
943{
944 const struct usb_endpoint_descriptor *d;
945
946 /* With CDC, the host isn't allowed to use these two data
947 * endpoints in the default altsetting for the interface.
948 * so we don't activate them yet. Reset from SET_INTERFACE.
949 *
950 * Strictly speaking RNDIS should work the same: activation is
951 * a side effect of setting a packet filter. Deactivation is
952 * from REMOTE_NDIS_HALT_MSG, reset from REMOTE_NDIS_RESET_MSG.
953 */
954
955 /* one endpoint writes data back IN to the host */
956 if (strcmp (ep->name, EP_IN_NAME) == 0) {
957 d = ep_desc (dev->gadget, &hs_source_desc, &fs_source_desc);
958 ep->driver_data = dev;
959 dev->in = d;
960
961 /* one endpoint just reads OUT packets */
962 } else if (strcmp (ep->name, EP_OUT_NAME) == 0) {
963 d = ep_desc (dev->gadget, &hs_sink_desc, &fs_sink_desc);
964 ep->driver_data = dev;
965 dev->out = d;
966
967 /* optional status/notification endpoint */
968 } else if (EP_STATUS_NAME &&
969 strcmp (ep->name, EP_STATUS_NAME) == 0) {
970 int result;
971
972 d = ep_desc (dev->gadget, &hs_status_desc, &fs_status_desc);
973 result = usb_ep_enable (ep, d);
974 if (result < 0)
975 return result;
976
977 ep->driver_data = dev;
978 dev->status = d;
979 }
980 return 0;
981}
982#endif
983
984#if defined(DEV_CONFIG_SUBSET) || defined(CONFIG_USB_ETH_RNDIS)
985static inline int ether_ep_setup (struct eth_dev *dev, struct usb_ep *ep)
986{
987 int result;
988 const struct usb_endpoint_descriptor *d;
989
990 /* CDC subset is simpler: if the device is there,
991 * it's live with rx and tx endpoints.
992 *
993 * Do this as a shortcut for RNDIS too.
994 */
995
996 /* one endpoint writes data back IN to the host */
997 if (strcmp (ep->name, EP_IN_NAME) == 0) {
998 d = ep_desc (dev->gadget, &hs_source_desc, &fs_source_desc);
999 result = usb_ep_enable (ep, d);
1000 if (result < 0)
1001 return result;
1002
1003 ep->driver_data = dev;
1004 dev->in = d;
1005
1006 /* one endpoint just reads OUT packets */
1007 } else if (strcmp (ep->name, EP_OUT_NAME) == 0) {
1008 d = ep_desc (dev->gadget, &hs_sink_desc, &fs_sink_desc);
1009 result = usb_ep_enable (ep, d);
1010 if (result < 0)
1011 return result;
1012
1013 ep->driver_data = dev;
1014 dev->out = d;
1015 }
1016
1017 return 0;
1018}
1019#endif
1020
1021static int
1022set_ether_config (struct eth_dev *dev, int gfp_flags)
1023{
1024 int result = 0;
1025 struct usb_ep *ep;
1026 struct usb_gadget *gadget = dev->gadget;
1027
1028 gadget_for_each_ep (ep, gadget) {
1029#ifdef DEV_CONFIG_CDC
1030 if (!dev->rndis && dev->cdc) {
1031 result = ether_alt_ep_setup (dev, ep);
1032 if (result == 0)
1033 continue;
1034 }
1035#endif
1036
1037#ifdef CONFIG_USB_ETH_RNDIS
1038 if (dev->rndis && strcmp (ep->name, EP_STATUS_NAME) == 0) {
1039 const struct usb_endpoint_descriptor *d;
1040 d = ep_desc (gadget, &hs_status_desc, &fs_status_desc);
1041 result = usb_ep_enable (ep, d);
1042 if (result == 0) {
1043 ep->driver_data = dev;
1044 dev->status = d;
1045 continue;
1046 }
1047 } else
1048#endif
1049
1050 {
1051#if defined(DEV_CONFIG_SUBSET) || defined(CONFIG_USB_ETH_RNDIS)
1052 result = ether_ep_setup (dev, ep);
1053 if (result == 0)
1054 continue;
1055#endif
1056 }
1057
1058 /* stop on error */
1059 ERROR (dev, "can't enable %s, result %d\n", ep->name, result);
1060 break;
1061 }
1062 if (!result && (!dev->in_ep || !dev->out_ep))
1063 result = -ENODEV;
1064
1065 if (result == 0)
1066 result = alloc_requests (dev, qlen (gadget), gfp_flags);
1067
1068 /* on error, disable any endpoints */
1069 if (result < 0) {
1070#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
1071 if (dev->status)
1072 (void) usb_ep_disable (dev->status_ep);
1073#endif
1074 dev->status = NULL;
1075#if defined(DEV_CONFIG_SUBSET) || defined(CONFIG_USB_ETH_RNDIS)
1076 if (dev->rndis || !dev->cdc) {
1077 if (dev->in)
1078 (void) usb_ep_disable (dev->in_ep);
1079 if (dev->out)
1080 (void) usb_ep_disable (dev->out_ep);
1081 }
1082#endif
1083 dev->in = NULL;
1084 dev->out = NULL;
1085 } else
1086
1087 /* activate non-CDC configs right away
1088 * this isn't strictly according to the RNDIS spec
1089 */
1090#if defined(DEV_CONFIG_SUBSET) || defined(CONFIG_USB_ETH_RNDIS)
1091 if (dev->rndis || !dev->cdc) {
1092 netif_carrier_on (dev->net);
1093 if (netif_running (dev->net)) {
1094 spin_unlock (&dev->lock);
1095 eth_start (dev, GFP_ATOMIC);
1096 spin_lock (&dev->lock);
1097 }
1098 }
1099#endif
1100
1101 if (result == 0)
1102 DEBUG (dev, "qlen %d\n", qlen (gadget));
1103
1104 /* caller is responsible for cleanup on error */
1105 return result;
1106}
1107
1108static void eth_reset_config (struct eth_dev *dev)
1109{
1110 struct usb_request *req;
1111
1112 if (dev->config == 0)
1113 return;
1114
1115 DEBUG (dev, "%s\n", __FUNCTION__);
1116
1117 netif_stop_queue (dev->net);
1118 netif_carrier_off (dev->net);
1119
1120 /* disable endpoints, forcing (synchronous) completion of
1121 * pending i/o. then free the requests.
1122 */
1123 if (dev->in) {
1124 usb_ep_disable (dev->in_ep);
1125 while (likely (!list_empty (&dev->tx_reqs))) {
1126 req = container_of (dev->tx_reqs.next,
1127 struct usb_request, list);
1128 list_del (&req->list);
1129 usb_ep_free_request (dev->in_ep, req);
1130 }
1131 }
1132 if (dev->out) {
1133 usb_ep_disable (dev->out_ep);
1134 while (likely (!list_empty (&dev->rx_reqs))) {
1135 req = container_of (dev->rx_reqs.next,
1136 struct usb_request, list);
1137 list_del (&req->list);
1138 usb_ep_free_request (dev->out_ep, req);
1139 }
1140 }
1141
1142 if (dev->status) {
1143 usb_ep_disable (dev->status_ep);
1144 }
1145 dev->config = 0;
1146}
1147
1148/* change our operational config. must agree with the code
1149 * that returns config descriptors, and altsetting code.
1150 */
1151static int
1152eth_set_config (struct eth_dev *dev, unsigned number, int gfp_flags)
1153{
1154 int result = 0;
1155 struct usb_gadget *gadget = dev->gadget;
1156
1157 if (number == dev->config)
1158 return 0;
1159
1160 if (gadget_is_sa1100 (gadget)
1161 && dev->config
1162 && atomic_read (&dev->tx_qlen) != 0) {
1163 /* tx fifo is full, but we can't clear it...*/
1164 INFO (dev, "can't change configurations\n");
1165 return -ESPIPE;
1166 }
1167 eth_reset_config (dev);
1168
1169 /* default: pass all packets, no multicast filtering */
1170 dev->cdc_filter = 0x000f;
1171
1172 switch (number) {
1173 case DEV_CONFIG_VALUE:
1174 dev->rndis = 0;
1175 result = set_ether_config (dev, gfp_flags);
1176 break;
1177#ifdef CONFIG_USB_ETH_RNDIS
1178 case DEV_RNDIS_CONFIG_VALUE:
1179 dev->rndis = 1;
1180 result = set_ether_config (dev, gfp_flags);
1181 break;
1182#endif
1183 default:
1184 result = -EINVAL;
1185 /* FALL THROUGH */
1186 case 0:
1187 break;
1188 }
1189
1190 if (result) {
1191 if (number)
1192 eth_reset_config (dev);
1193 usb_gadget_vbus_draw(dev->gadget,
1194 dev->gadget->is_otg ? 8 : 100);
1195 } else {
1196 char *speed;
1197 unsigned power;
1198
1199 power = 2 * eth_config.bMaxPower;
1200 usb_gadget_vbus_draw(dev->gadget, power);
1201
1202 switch (gadget->speed) {
1203 case USB_SPEED_FULL: speed = "full"; break;
1204#ifdef CONFIG_USB_GADGET_DUALSPEED
1205 case USB_SPEED_HIGH: speed = "high"; break;
1206#endif
1207 default: speed = "?"; break;
1208 }
1209
1210 dev->config = number;
1211 INFO (dev, "%s speed config #%d: %d mA, %s, using %s\n",
1212 speed, number, power, driver_desc,
1213 dev->rndis
1214 ? "RNDIS"
1215 : (dev->cdc
1216 ? "CDC Ethernet"
1217 : "CDC Ethernet Subset"));
1218 }
1219 return result;
1220}
1221
1222/*-------------------------------------------------------------------------*/
1223
1224#ifdef DEV_CONFIG_CDC
1225
1226static void eth_status_complete (struct usb_ep *ep, struct usb_request *req)
1227{
1228 struct usb_cdc_notification *event = req->buf;
1229 int value = req->status;
1230 struct eth_dev *dev = ep->driver_data;
1231
1232 /* issue the second notification if host reads the first */
1233 if (event->bNotificationType == USB_CDC_NOTIFY_NETWORK_CONNECTION
1234 && value == 0) {
1235 __le32 *data = req->buf + sizeof *event;
1236
1237 event->bmRequestType = 0xA1;
1238 event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
1239 event->wValue = __constant_cpu_to_le16 (0);
1240 event->wIndex = __constant_cpu_to_le16 (1);
1241 event->wLength = __constant_cpu_to_le16 (8);
1242
1243 /* SPEED_CHANGE data is up/down speeds in bits/sec */
1244 data [0] = data [1] = cpu_to_le32 (BITRATE (dev->gadget));
1245
1246 req->length = STATUS_BYTECOUNT;
1247 value = usb_ep_queue (ep, req, GFP_ATOMIC);
1248 DEBUG (dev, "send SPEED_CHANGE --> %d\n", value);
1249 if (value == 0)
1250 return;
1251 } else if (value != -ECONNRESET)
1252 DEBUG (dev, "event %02x --> %d\n",
1253 event->bNotificationType, value);
1254 event->bmRequestType = 0xff;
1255}
1256
1257static void issue_start_status (struct eth_dev *dev)
1258{
1259 struct usb_request *req = dev->stat_req;
1260 struct usb_cdc_notification *event;
1261 int value;
1262
1263 DEBUG (dev, "%s, flush old status first\n", __FUNCTION__);
1264
1265 /* flush old status
1266 *
1267 * FIXME ugly idiom, maybe we'd be better with just
1268 * a "cancel the whole queue" primitive since any
1269 * unlink-one primitive has way too many error modes.
1270 * here, we "know" toggle is already clear...
1271 */
1272 usb_ep_disable (dev->status_ep);
1273 usb_ep_enable (dev->status_ep, dev->status);
1274
1275 /* 3.8.1 says to issue first NETWORK_CONNECTION, then
1276 * a SPEED_CHANGE. could be useful in some configs.
1277 */
1278 event = req->buf;
1279 event->bmRequestType = 0xA1;
1280 event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
1281 event->wValue = __constant_cpu_to_le16 (1); /* connected */
1282 event->wIndex = __constant_cpu_to_le16 (1);
1283 event->wLength = 0;
1284
1285 req->length = sizeof *event;
1286 req->complete = eth_status_complete;
1287 value = usb_ep_queue (dev->status_ep, req, GFP_ATOMIC);
1288 if (value < 0)
1289 DEBUG (dev, "status buf queue --> %d\n", value);
1290}
1291
1292#endif
1293
1294/*-------------------------------------------------------------------------*/
1295
1296static void eth_setup_complete (struct usb_ep *ep, struct usb_request *req)
1297{
1298 if (req->status || req->actual != req->length)
1299 DEBUG ((struct eth_dev *) ep->driver_data,
1300 "setup complete --> %d, %d/%d\n",
1301 req->status, req->actual, req->length);
1302}
1303
1304#ifdef CONFIG_USB_ETH_RNDIS
1305
1306static void rndis_response_complete (struct usb_ep *ep, struct usb_request *req)
1307{
1308 if (req->status || req->actual != req->length)
1309 DEBUG ((struct eth_dev *) ep->driver_data,
1310 "rndis response complete --> %d, %d/%d\n",
1311 req->status, req->actual, req->length);
1312
1313 /* done sending after USB_CDC_GET_ENCAPSULATED_RESPONSE */
1314}
1315
1316static void rndis_command_complete (struct usb_ep *ep, struct usb_request *req)
1317{
1318 struct eth_dev *dev = ep->driver_data;
1319 int status;
1320
1321 /* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */
1322 spin_lock(&dev->lock);
1323 status = rndis_msg_parser (dev->rndis_config, (u8 *) req->buf);
1324 if (status < 0)
1325 ERROR(dev, "%s: rndis parse error %d\n", __FUNCTION__, status);
1326 spin_unlock(&dev->lock);
1327}
1328
1329#endif /* RNDIS */
1330
1331/*
1332 * The setup() callback implements all the ep0 functionality that's not
1333 * handled lower down. CDC has a number of less-common features:
1334 *
1335 * - two interfaces: control, and ethernet data
1336 * - Ethernet data interface has two altsettings: default, and active
1337 * - class-specific descriptors for the control interface
1338 * - class-specific control requests
1339 */
1340static int
1341eth_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1342{
1343 struct eth_dev *dev = get_gadget_data (gadget);
1344 struct usb_request *req = dev->req;
1345 int value = -EOPNOTSUPP;
1346 u16 wIndex = ctrl->wIndex;
1347 u16 wValue = ctrl->wValue;
1348 u16 wLength = ctrl->wLength;
1349
1350 /* descriptors just go into the pre-allocated ep0 buffer,
1351 * while config change events may enable network traffic.
1352 */
1353 req->complete = eth_setup_complete;
1354 switch (ctrl->bRequest) {
1355
1356 case USB_REQ_GET_DESCRIPTOR:
1357 if (ctrl->bRequestType != USB_DIR_IN)
1358 break;
1359 switch (wValue >> 8) {
1360
1361 case USB_DT_DEVICE:
1362 value = min (wLength, (u16) sizeof device_desc);
1363 memcpy (req->buf, &device_desc, value);
1364 break;
1365#ifdef CONFIG_USB_GADGET_DUALSPEED
1366 case USB_DT_DEVICE_QUALIFIER:
1367 if (!gadget->is_dualspeed)
1368 break;
1369 value = min (wLength, (u16) sizeof dev_qualifier);
1370 memcpy (req->buf, &dev_qualifier, value);
1371 break;
1372
1373 case USB_DT_OTHER_SPEED_CONFIG:
1374 if (!gadget->is_dualspeed)
1375 break;
1376 // FALLTHROUGH
1377#endif /* CONFIG_USB_GADGET_DUALSPEED */
1378 case USB_DT_CONFIG:
1379 value = config_buf (gadget->speed, req->buf,
1380 wValue >> 8,
1381 wValue & 0xff,
1382 gadget->is_otg);
1383 if (value >= 0)
1384 value = min (wLength, (u16) value);
1385 break;
1386
1387 case USB_DT_STRING:
1388 value = usb_gadget_get_string (&stringtab,
1389 wValue & 0xff, req->buf);
1390 if (value >= 0)
1391 value = min (wLength, (u16) value);
1392 break;
1393 }
1394 break;
1395
1396 case USB_REQ_SET_CONFIGURATION:
1397 if (ctrl->bRequestType != 0)
1398 break;
1399 if (gadget->a_hnp_support)
1400 DEBUG (dev, "HNP available\n");
1401 else if (gadget->a_alt_hnp_support)
1402 DEBUG (dev, "HNP needs a different root port\n");
1403 spin_lock (&dev->lock);
1404 value = eth_set_config (dev, wValue, GFP_ATOMIC);
1405 spin_unlock (&dev->lock);
1406 break;
1407 case USB_REQ_GET_CONFIGURATION:
1408 if (ctrl->bRequestType != USB_DIR_IN)
1409 break;
1410 *(u8 *)req->buf = dev->config;
1411 value = min (wLength, (u16) 1);
1412 break;
1413
1414 case USB_REQ_SET_INTERFACE:
1415 if (ctrl->bRequestType != USB_RECIP_INTERFACE
1416 || !dev->config
1417 || wIndex > 1)
1418 break;
1419 if (!dev->cdc && wIndex != 0)
1420 break;
1421 spin_lock (&dev->lock);
1422
1423 /* PXA hardware partially handles SET_INTERFACE;
1424 * we need to kluge around that interference.
1425 */
1426 if (gadget_is_pxa (gadget)) {
1427 value = eth_set_config (dev, DEV_CONFIG_VALUE,
1428 GFP_ATOMIC);
1429 goto done_set_intf;
1430 }
1431
1432#ifdef DEV_CONFIG_CDC
1433 switch (wIndex) {
1434 case 0: /* control/master intf */
1435 if (wValue != 0)
1436 break;
1437 if (dev->status) {
1438 usb_ep_disable (dev->status_ep);
1439 usb_ep_enable (dev->status_ep, dev->status);
1440 }
1441 value = 0;
1442 break;
1443 case 1: /* data intf */
1444 if (wValue > 1)
1445 break;
1446 usb_ep_disable (dev->in_ep);
1447 usb_ep_disable (dev->out_ep);
1448
1449 /* CDC requires the data transfers not be done from
1450 * the default interface setting ... also, setting
1451 * the non-default interface clears filters etc.
1452 */
1453 if (wValue == 1) {
1454 usb_ep_enable (dev->in_ep, dev->in);
1455 usb_ep_enable (dev->out_ep, dev->out);
1456 dev->cdc_filter = DEFAULT_FILTER;
1457 netif_carrier_on (dev->net);
1458 if (dev->status)
1459 issue_start_status (dev);
1460 if (netif_running (dev->net)) {
1461 spin_unlock (&dev->lock);
1462 eth_start (dev, GFP_ATOMIC);
1463 spin_lock (&dev->lock);
1464 }
1465 } else {
1466 netif_stop_queue (dev->net);
1467 netif_carrier_off (dev->net);
1468 }
1469 value = 0;
1470 break;
1471 }
1472#else
1473 /* FIXME this is wrong, as is the assumption that
1474 * all non-PXA hardware talks real CDC ...
1475 */
1476 dev_warn (&gadget->dev, "set_interface ignored!\n");
1477#endif /* DEV_CONFIG_CDC */
1478
1479done_set_intf:
1480 spin_unlock (&dev->lock);
1481 break;
1482 case USB_REQ_GET_INTERFACE:
1483 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)
1484 || !dev->config
1485 || wIndex > 1)
1486 break;
1487 if (!(dev->cdc || dev->rndis) && wIndex != 0)
1488 break;
1489
1490 /* for CDC, iff carrier is on, data interface is active. */
1491 if (dev->rndis || wIndex != 1)
1492 *(u8 *)req->buf = 0;
1493 else
1494 *(u8 *)req->buf = netif_carrier_ok (dev->net) ? 1 : 0;
1495 value = min (wLength, (u16) 1);
1496 break;
1497
1498#ifdef DEV_CONFIG_CDC
1499 case USB_CDC_SET_ETHERNET_PACKET_FILTER:
1500 /* see 6.2.30: no data, wIndex = interface,
1501 * wValue = packet filter bitmap
1502 */
1503 if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)
1504 || !dev->cdc
1505 || dev->rndis
1506 || wLength != 0
1507 || wIndex > 1)
1508 break;
1509 DEBUG (dev, "packet filter %02x\n", wValue);
1510 dev->cdc_filter = wValue;
1511 value = 0;
1512 break;
1513
1514 /* and potentially:
1515 * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
1516 * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
1517 * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
1518 * case USB_CDC_GET_ETHERNET_STATISTIC:
1519 */
1520
1521#endif /* DEV_CONFIG_CDC */
1522
1523#ifdef CONFIG_USB_ETH_RNDIS
1524 /* RNDIS uses the CDC command encapsulation mechanism to implement
1525 * an RPC scheme, with much getting/setting of attributes by OID.
1526 */
1527 case USB_CDC_SEND_ENCAPSULATED_COMMAND:
1528 if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)
1529 || !dev->rndis
1530 || wLength > USB_BUFSIZ
1531 || wValue
1532 || rndis_control_intf.bInterfaceNumber
1533 != wIndex)
1534 break;
1535 /* read the request, then process it */
1536 value = wLength;
1537 req->complete = rndis_command_complete;
1538 /* later, rndis_control_ack () sends a notification */
1539 break;
1540
1541 case USB_CDC_GET_ENCAPSULATED_RESPONSE:
1542 if ((USB_DIR_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE)
1543 == ctrl->bRequestType
1544 && dev->rndis
1545 // && wLength >= 0x0400
1546 && !wValue
1547 && rndis_control_intf.bInterfaceNumber
1548 == wIndex) {
1549 u8 *buf;
1550
1551 /* return the result */
1552 buf = rndis_get_next_response (dev->rndis_config,
1553 &value);
1554 if (buf) {
1555 memcpy (req->buf, buf, value);
1556 req->complete = rndis_response_complete;
1557 rndis_free_response(dev->rndis_config, buf);
1558 }
1559 /* else stalls ... spec says to avoid that */
1560 }
1561 break;
1562#endif /* RNDIS */
1563
1564 default:
1565 VDEBUG (dev,
1566 "unknown control req%02x.%02x v%04x i%04x l%d\n",
1567 ctrl->bRequestType, ctrl->bRequest,
1568 wValue, wIndex, wLength);
1569 }
1570
1571 /* respond with data transfer before status phase? */
1572 if (value >= 0) {
1573 req->length = value;
1574 req->zero = value < wLength
1575 && (value % gadget->ep0->maxpacket) == 0;
1576 value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
1577 if (value < 0) {
1578 DEBUG (dev, "ep_queue --> %d\n", value);
1579 req->status = 0;
1580 eth_setup_complete (gadget->ep0, req);
1581 }
1582 }
1583
1584 /* host either stalls (value < 0) or reports success */
1585 return value;
1586}
1587
1588static void
1589eth_disconnect (struct usb_gadget *gadget)
1590{
1591 struct eth_dev *dev = get_gadget_data (gadget);
1592 unsigned long flags;
1593
1594 spin_lock_irqsave (&dev->lock, flags);
1595 netif_stop_queue (dev->net);
1596 netif_carrier_off (dev->net);
1597 eth_reset_config (dev);
1598 spin_unlock_irqrestore (&dev->lock, flags);
1599
1600 /* FIXME RNDIS should enter RNDIS_UNINITIALIZED */
1601
1602 /* next we may get setup() calls to enumerate new connections;
1603 * or an unbind() during shutdown (including removing module).
1604 */
1605}
1606
1607/*-------------------------------------------------------------------------*/
1608
1609/* NETWORK DRIVER HOOKUP (to the layer above this driver) */
1610
1611static int eth_change_mtu (struct net_device *net, int new_mtu)
1612{
1613 struct eth_dev *dev = netdev_priv(net);
1614
1615 // FIXME if rndis, don't change while link's live
1616
1617 if (new_mtu <= ETH_HLEN || new_mtu > ETH_FRAME_LEN)
1618 return -ERANGE;
1619 /* no zero-length packet read wanted after mtu-sized packets */
1620 if (((new_mtu + sizeof (struct ethhdr)) % dev->in_ep->maxpacket) == 0)
1621 return -EDOM;
1622 net->mtu = new_mtu;
1623 return 0;
1624}
1625
1626static struct net_device_stats *eth_get_stats (struct net_device *net)
1627{
1628 return &((struct eth_dev *)netdev_priv(net))->stats;
1629}
1630
1631static void eth_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *p)
1632{
1633 struct eth_dev *dev = netdev_priv(net);
1634 strlcpy(p->driver, shortname, sizeof p->driver);
1635 strlcpy(p->version, DRIVER_VERSION, sizeof p->version);
1636 strlcpy(p->fw_version, dev->gadget->name, sizeof p->fw_version);
1637 strlcpy (p->bus_info, dev->gadget->dev.bus_id, sizeof p->bus_info);
1638}
1639
1640static u32 eth_get_link(struct net_device *net)
1641{
1642 struct eth_dev *dev = netdev_priv(net);
1643 return dev->gadget->speed != USB_SPEED_UNKNOWN;
1644}
1645
1646static struct ethtool_ops ops = {
1647 .get_drvinfo = eth_get_drvinfo,
1648 .get_link = eth_get_link
1649};
1650
1651static void defer_kevent (struct eth_dev *dev, int flag)
1652{
1653 if (test_and_set_bit (flag, &dev->todo))
1654 return;
1655 if (!schedule_work (&dev->work))
1656 ERROR (dev, "kevent %d may have been dropped\n", flag);
1657 else
1658 DEBUG (dev, "kevent %d scheduled\n", flag);
1659}
1660
1661static void rx_complete (struct usb_ep *ep, struct usb_request *req);
1662
1663static int
1664rx_submit (struct eth_dev *dev, struct usb_request *req, int gfp_flags)
1665{
1666 struct sk_buff *skb;
1667 int retval = -ENOMEM;
1668 size_t size;
1669
1670 /* Padding up to RX_EXTRA handles minor disagreements with host.
1671 * Normally we use the USB "terminate on short read" convention;
1672 * so allow up to (N*maxpacket), since that memory is normally
1673 * already allocated. Some hardware doesn't deal well with short
1674 * reads (e.g. DMA must be N*maxpacket), so for now don't trim a
1675 * byte off the end (to force hardware errors on overflow).
1676 *
1677 * RNDIS uses internal framing, and explicitly allows senders to
1678 * pad to end-of-packet. That's potentially nice for speed,
1679 * but means receivers can't recover synch on their own.
1680 */
1681 size = (sizeof (struct ethhdr) + dev->net->mtu + RX_EXTRA);
1682 size += dev->out_ep->maxpacket - 1;
1683#ifdef CONFIG_USB_ETH_RNDIS
1684 if (dev->rndis)
1685 size += sizeof (struct rndis_packet_msg_type);
1686#endif
1687 size -= size % dev->out_ep->maxpacket;
1688
1689 if ((skb = alloc_skb (size + NET_IP_ALIGN, gfp_flags)) == 0) {
1690 DEBUG (dev, "no rx skb\n");
1691 goto enomem;
1692 }
1693
1694 /* Some platforms perform better when IP packets are aligned,
1695 * but on at least one, checksumming fails otherwise. Note:
1696 * this doesn't account for variable-sized RNDIS headers.
1697 */
1698 skb_reserve(skb, NET_IP_ALIGN);
1699
1700 req->buf = skb->data;
1701 req->length = size;
1702 req->complete = rx_complete;
1703 req->context = skb;
1704
1705 retval = usb_ep_queue (dev->out_ep, req, gfp_flags);
1706 if (retval == -ENOMEM)
1707enomem:
1708 defer_kevent (dev, WORK_RX_MEMORY);
1709 if (retval) {
1710 DEBUG (dev, "rx submit --> %d\n", retval);
1711 dev_kfree_skb_any (skb);
1712 spin_lock (&dev->lock);
1713 list_add (&req->list, &dev->rx_reqs);
1714 spin_unlock (&dev->lock);
1715 }
1716 return retval;
1717}
1718
1719static void rx_complete (struct usb_ep *ep, struct usb_request *req)
1720{
1721 struct sk_buff *skb = req->context;
1722 struct eth_dev *dev = ep->driver_data;
1723 int status = req->status;
1724
1725 switch (status) {
1726
1727 /* normal completion */
1728 case 0:
1729 skb_put (skb, req->actual);
1730#ifdef CONFIG_USB_ETH_RNDIS
1731 /* we know MaxPacketsPerTransfer == 1 here */
1732 if (dev->rndis)
1733 rndis_rm_hdr (req->buf, &(skb->len));
1734#endif
1735 if (ETH_HLEN > skb->len || skb->len > ETH_FRAME_LEN) {
1736 dev->stats.rx_errors++;
1737 dev->stats.rx_length_errors++;
1738 DEBUG (dev, "rx length %d\n", skb->len);
1739 break;
1740 }
1741
1742 skb->dev = dev->net;
1743 skb->protocol = eth_type_trans (skb, dev->net);
1744 dev->stats.rx_packets++;
1745 dev->stats.rx_bytes += skb->len;
1746
1747 /* no buffer copies needed, unless hardware can't
1748 * use skb buffers.
1749 */
1750 status = netif_rx (skb);
1751 skb = NULL;
1752 break;
1753
1754 /* software-driven interface shutdown */
1755 case -ECONNRESET: // unlink
1756 case -ESHUTDOWN: // disconnect etc
1757 VDEBUG (dev, "rx shutdown, code %d\n", status);
1758 goto quiesce;
1759
1760 /* for hardware automagic (such as pxa) */
1761 case -ECONNABORTED: // endpoint reset
1762 DEBUG (dev, "rx %s reset\n", ep->name);
1763 defer_kevent (dev, WORK_RX_MEMORY);
1764quiesce:
1765 dev_kfree_skb_any (skb);
1766 goto clean;
1767
1768 /* data overrun */
1769 case -EOVERFLOW:
1770 dev->stats.rx_over_errors++;
1771 // FALLTHROUGH
1772
1773 default:
1774 dev->stats.rx_errors++;
1775 DEBUG (dev, "rx status %d\n", status);
1776 break;
1777 }
1778
1779 if (skb)
1780 dev_kfree_skb_any (skb);
1781 if (!netif_running (dev->net)) {
1782clean:
1783 /* nobody reading rx_reqs, so no dev->lock */
1784 list_add (&req->list, &dev->rx_reqs);
1785 req = NULL;
1786 }
1787 if (req)
1788 rx_submit (dev, req, GFP_ATOMIC);
1789}
1790
1791static int prealloc (struct list_head *list, struct usb_ep *ep,
1792 unsigned n, int gfp_flags)
1793{
1794 unsigned i;
1795 struct usb_request *req;
1796
1797 if (!n)
1798 return -ENOMEM;
1799
1800 /* queue/recycle up to N requests */
1801 i = n;
1802 list_for_each_entry (req, list, list) {
1803 if (i-- == 0)
1804 goto extra;
1805 }
1806 while (i--) {
1807 req = usb_ep_alloc_request (ep, gfp_flags);
1808 if (!req)
1809 return list_empty (list) ? -ENOMEM : 0;
1810 list_add (&req->list, list);
1811 }
1812 return 0;
1813
1814extra:
1815 /* free extras */
1816 for (;;) {
1817 struct list_head *next;
1818
1819 next = req->list.next;
1820 list_del (&req->list);
1821 usb_ep_free_request (ep, req);
1822
1823 if (next == list)
1824 break;
1825
1826 req = container_of (next, struct usb_request, list);
1827 }
1828 return 0;
1829}
1830
1831static int alloc_requests (struct eth_dev *dev, unsigned n, int gfp_flags)
1832{
1833 int status;
1834
1835 status = prealloc (&dev->tx_reqs, dev->in_ep, n, gfp_flags);
1836 if (status < 0)
1837 goto fail;
1838 status = prealloc (&dev->rx_reqs, dev->out_ep, n, gfp_flags);
1839 if (status < 0)
1840 goto fail;
1841 return 0;
1842fail:
1843 DEBUG (dev, "can't alloc requests\n");
1844 return status;
1845}
1846
1847static void rx_fill (struct eth_dev *dev, int gfp_flags)
1848{
1849 struct usb_request *req;
1850 unsigned long flags;
1851
1852 clear_bit (WORK_RX_MEMORY, &dev->todo);
1853
1854 /* fill unused rxq slots with some skb */
1855 spin_lock_irqsave (&dev->lock, flags);
1856 while (!list_empty (&dev->rx_reqs)) {
1857 req = container_of (dev->rx_reqs.next,
1858 struct usb_request, list);
1859 list_del_init (&req->list);
1860 spin_unlock_irqrestore (&dev->lock, flags);
1861
1862 if (rx_submit (dev, req, gfp_flags) < 0) {
1863 defer_kevent (dev, WORK_RX_MEMORY);
1864 return;
1865 }
1866
1867 spin_lock_irqsave (&dev->lock, flags);
1868 }
1869 spin_unlock_irqrestore (&dev->lock, flags);
1870}
1871
1872static void eth_work (void *_dev)
1873{
1874 struct eth_dev *dev = _dev;
1875
1876 if (test_bit (WORK_RX_MEMORY, &dev->todo)) {
1877 if (netif_running (dev->net))
1878 rx_fill (dev, GFP_KERNEL);
1879 else
1880 clear_bit (WORK_RX_MEMORY, &dev->todo);
1881 }
1882
1883 if (dev->todo)
1884 DEBUG (dev, "work done, flags = 0x%lx\n", dev->todo);
1885}
1886
1887static void tx_complete (struct usb_ep *ep, struct usb_request *req)
1888{
1889 struct sk_buff *skb = req->context;
1890 struct eth_dev *dev = ep->driver_data;
1891
1892 switch (req->status) {
1893 default:
1894 dev->stats.tx_errors++;
1895 VDEBUG (dev, "tx err %d\n", req->status);
1896 /* FALLTHROUGH */
1897 case -ECONNRESET: // unlink
1898 case -ESHUTDOWN: // disconnect etc
1899 break;
1900 case 0:
1901 dev->stats.tx_bytes += skb->len;
1902 }
1903 dev->stats.tx_packets++;
1904
1905 spin_lock (&dev->lock);
1906 list_add (&req->list, &dev->tx_reqs);
1907 spin_unlock (&dev->lock);
1908 dev_kfree_skb_any (skb);
1909
1910 atomic_dec (&dev->tx_qlen);
1911 if (netif_carrier_ok (dev->net))
1912 netif_wake_queue (dev->net);
1913}
1914
1915static inline int eth_is_promisc (struct eth_dev *dev)
1916{
1917 /* no filters for the CDC subset; always promisc */
1918 if (subset_active (dev))
1919 return 1;
1920 return dev->cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;
1921}
1922
1923static int eth_start_xmit (struct sk_buff *skb, struct net_device *net)
1924{
1925 struct eth_dev *dev = netdev_priv(net);
1926 int length = skb->len;
1927 int retval;
1928 struct usb_request *req = NULL;
1929 unsigned long flags;
1930
1931 /* apply outgoing CDC or RNDIS filters */
1932 if (!eth_is_promisc (dev)) {
1933 u8 *dest = skb->data;
1934
1935 if (dest [0] & 0x01) {
1936 u16 type;
1937
1938 /* ignores USB_CDC_PACKET_TYPE_MULTICAST and host
1939 * SET_ETHERNET_MULTICAST_FILTERS requests
1940 */
1941 if (memcmp (dest, net->broadcast, ETH_ALEN) == 0)
1942 type = USB_CDC_PACKET_TYPE_BROADCAST;
1943 else
1944 type = USB_CDC_PACKET_TYPE_ALL_MULTICAST;
1945 if (!(dev->cdc_filter & type)) {
1946 dev_kfree_skb_any (skb);
1947 return 0;
1948 }
1949 }
1950 /* ignores USB_CDC_PACKET_TYPE_DIRECTED */
1951 }
1952
1953 spin_lock_irqsave (&dev->lock, flags);
1954 req = container_of (dev->tx_reqs.next, struct usb_request, list);
1955 list_del (&req->list);
1956 if (list_empty (&dev->tx_reqs))
1957 netif_stop_queue (net);
1958 spin_unlock_irqrestore (&dev->lock, flags);
1959
1960 /* no buffer copies needed, unless the network stack did it
1961 * or the hardware can't use skb buffers.
1962 * or there's not enough space for any RNDIS headers we need
1963 */
1964#ifdef CONFIG_USB_ETH_RNDIS
1965 if (dev->rndis) {
1966 struct sk_buff *skb_rndis;
1967
1968 skb_rndis = skb_realloc_headroom (skb,
1969 sizeof (struct rndis_packet_msg_type));
1970 if (!skb_rndis)
1971 goto drop;
1972
1973 dev_kfree_skb_any (skb);
1974 skb = skb_rndis;
1975 rndis_add_hdr (skb);
1976 length = skb->len;
1977 }
1978#endif
1979 req->buf = skb->data;
1980 req->context = skb;
1981 req->complete = tx_complete;
1982
1983 /* use zlp framing on tx for strict CDC-Ether conformance,
1984 * though any robust network rx path ignores extra padding.
1985 * and some hardware doesn't like to write zlps.
1986 */
1987 req->zero = 1;
1988 if (!dev->zlp && (length % dev->in_ep->maxpacket) == 0)
1989 length++;
1990
1991 req->length = length;
1992
1993#ifdef CONFIG_USB_GADGET_DUALSPEED
1994 /* throttle highspeed IRQ rate back slightly */
1995 req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
1996 ? ((atomic_read (&dev->tx_qlen) % TX_DELAY) != 0)
1997 : 0;
1998#endif
1999
2000 retval = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);
2001 switch (retval) {
2002 default:
2003 DEBUG (dev, "tx queue err %d\n", retval);
2004 break;
2005 case 0:
2006 net->trans_start = jiffies;
2007 atomic_inc (&dev->tx_qlen);
2008 }
2009
2010 if (retval) {
2011#ifdef CONFIG_USB_ETH_RNDIS
2012drop:
2013#endif
2014 dev->stats.tx_dropped++;
2015 dev_kfree_skb_any (skb);
2016 spin_lock_irqsave (&dev->lock, flags);
2017 if (list_empty (&dev->tx_reqs))
2018 netif_start_queue (net);
2019 list_add (&req->list, &dev->tx_reqs);
2020 spin_unlock_irqrestore (&dev->lock, flags);
2021 }
2022 return 0;
2023}
2024
2025/*-------------------------------------------------------------------------*/
2026
2027#ifdef CONFIG_USB_ETH_RNDIS
2028
2029static void rndis_send_media_state (struct eth_dev *dev, int connect)
2030{
2031 if (!dev)
2032 return;
2033
2034 if (connect) {
2035 if (rndis_signal_connect (dev->rndis_config))
2036 return;
2037 } else {
2038 if (rndis_signal_disconnect (dev->rndis_config))
2039 return;
2040 }
2041}
2042
2043static void
2044rndis_control_ack_complete (struct usb_ep *ep, struct usb_request *req)
2045{
2046 if (req->status || req->actual != req->length)
2047 DEBUG ((struct eth_dev *) ep->driver_data,
2048 "rndis control ack complete --> %d, %d/%d\n",
2049 req->status, req->actual, req->length);
2050
2051 usb_ep_free_buffer(ep, req->buf, req->dma, 8);
2052 usb_ep_free_request(ep, req);
2053}
2054
2055static int rndis_control_ack (struct net_device *net)
2056{
2057 struct eth_dev *dev = netdev_priv(net);
2058 u32 length;
2059 struct usb_request *resp;
2060
2061 /* in case RNDIS calls this after disconnect */
2062 if (!dev->status_ep) {
2063 DEBUG (dev, "status ENODEV\n");
2064 return -ENODEV;
2065 }
2066
2067 /* Allocate memory for notification ie. ACK */
2068 resp = usb_ep_alloc_request (dev->status_ep, GFP_ATOMIC);
2069 if (!resp) {
2070 DEBUG (dev, "status ENOMEM\n");
2071 return -ENOMEM;
2072 }
2073
2074 resp->buf = usb_ep_alloc_buffer (dev->status_ep, 8,
2075 &resp->dma, GFP_ATOMIC);
2076 if (!resp->buf) {
2077 DEBUG (dev, "status buf ENOMEM\n");
2078 usb_ep_free_request (dev->status_ep, resp);
2079 return -ENOMEM;
2080 }
2081
2082 /* Send RNDIS RESPONSE_AVAILABLE notification;
2083 * USB_CDC_NOTIFY_RESPONSE_AVAILABLE should work too
2084 */
2085 resp->length = 8;
2086 resp->complete = rndis_control_ack_complete;
2087
2088 *((__le32 *) resp->buf) = __constant_cpu_to_le32 (1);
2089 *((__le32 *) resp->buf + 1) = __constant_cpu_to_le32 (0);
2090
2091 length = usb_ep_queue (dev->status_ep, resp, GFP_ATOMIC);
2092 if (length < 0) {
2093 resp->status = 0;
2094 rndis_control_ack_complete (dev->status_ep, resp);
2095 }
2096
2097 return 0;
2098}
2099
2100#endif /* RNDIS */
2101
2102static void eth_start (struct eth_dev *dev, int gfp_flags)
2103{
2104 DEBUG (dev, "%s\n", __FUNCTION__);
2105
2106 /* fill the rx queue */
2107 rx_fill (dev, gfp_flags);
2108
2109 /* and open the tx floodgates */
2110 atomic_set (&dev->tx_qlen, 0);
2111 netif_wake_queue (dev->net);
2112#ifdef CONFIG_USB_ETH_RNDIS
2113 if (dev->rndis) {
2114 rndis_set_param_medium (dev->rndis_config,
2115 NDIS_MEDIUM_802_3,
2116 BITRATE(dev->gadget));
2117 rndis_send_media_state (dev, 1);
2118 }
2119#endif
2120}
2121
2122static int eth_open (struct net_device *net)
2123{
2124 struct eth_dev *dev = netdev_priv(net);
2125
2126 DEBUG (dev, "%s\n", __FUNCTION__);
2127 if (netif_carrier_ok (dev->net))
2128 eth_start (dev, GFP_KERNEL);
2129 return 0;
2130}
2131
2132static int eth_stop (struct net_device *net)
2133{
2134 struct eth_dev *dev = netdev_priv(net);
2135
2136 VDEBUG (dev, "%s\n", __FUNCTION__);
2137 netif_stop_queue (net);
2138
2139 DEBUG (dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n",
2140 dev->stats.rx_packets, dev->stats.tx_packets,
2141 dev->stats.rx_errors, dev->stats.tx_errors
2142 );
2143
2144 /* ensure there are no more active requests */
2145 if (dev->config) {
2146 usb_ep_disable (dev->in_ep);
2147 usb_ep_disable (dev->out_ep);
2148 if (netif_carrier_ok (dev->net)) {
2149 DEBUG (dev, "host still using in/out endpoints\n");
2150 // FIXME idiom may leave toggle wrong here
2151 usb_ep_enable (dev->in_ep, dev->in);
2152 usb_ep_enable (dev->out_ep, dev->out);
2153 }
2154 if (dev->status_ep) {
2155 usb_ep_disable (dev->status_ep);
2156 usb_ep_enable (dev->status_ep, dev->status);
2157 }
2158 }
2159
2160#ifdef CONFIG_USB_ETH_RNDIS
2161 if (dev->rndis) {
2162 rndis_set_param_medium (dev->rndis_config,
2163 NDIS_MEDIUM_802_3, 0);
2164 rndis_send_media_state (dev, 0);
2165 }
2166#endif
2167
2168 return 0;
2169}
2170
2171/*-------------------------------------------------------------------------*/
2172
2173static struct usb_request *eth_req_alloc (struct usb_ep *ep, unsigned size)
2174{
2175 struct usb_request *req;
2176
2177 req = usb_ep_alloc_request (ep, GFP_KERNEL);
2178 if (!req)
2179 return NULL;
2180
2181 req->buf = kmalloc (size, GFP_KERNEL);
2182 if (!req->buf) {
2183 usb_ep_free_request (ep, req);
2184 req = NULL;
2185 }
2186 return req;
2187}
2188
2189static void
2190eth_req_free (struct usb_ep *ep, struct usb_request *req)
2191{
2192 kfree (req->buf);
2193 usb_ep_free_request (ep, req);
2194}
2195
2196
2197static void
2198eth_unbind (struct usb_gadget *gadget)
2199{
2200 struct eth_dev *dev = get_gadget_data (gadget);
2201
2202 DEBUG (dev, "unbind\n");
2203#ifdef CONFIG_USB_ETH_RNDIS
2204 rndis_deregister (dev->rndis_config);
2205 rndis_exit ();
2206#endif
2207
2208 /* we've already been disconnected ... no i/o is active */
2209 if (dev->req) {
2210 eth_req_free (gadget->ep0, dev->req);
2211 dev->req = NULL;
2212 }
2213 if (dev->stat_req) {
2214 eth_req_free (dev->status_ep, dev->stat_req);
2215 dev->stat_req = NULL;
2216 }
2217
2218 unregister_netdev (dev->net);
2219 free_netdev(dev->net);
2220
2221 /* assuming we used keventd, it must quiesce too */
2222 flush_scheduled_work ();
2223 set_gadget_data (gadget, NULL);
2224}
2225
2226static u8 __init nibble (unsigned char c)
2227{
2228 if (likely (isdigit (c)))
2229 return c - '0';
2230 c = toupper (c);
2231 if (likely (isxdigit (c)))
2232 return 10 + c - 'A';
2233 return 0;
2234}
2235
2236static void __init get_ether_addr (const char *str, u8 *dev_addr)
2237{
2238 if (str) {
2239 unsigned i;
2240
2241 for (i = 0; i < 6; i++) {
2242 unsigned char num;
2243
2244 if((*str == '.') || (*str == ':'))
2245 str++;
2246 num = nibble(*str++) << 4;
2247 num |= (nibble(*str++));
2248 dev_addr [i] = num;
2249 }
2250 if (is_valid_ether_addr (dev_addr))
2251 return;
2252 }
2253 random_ether_addr(dev_addr);
2254}
2255
2256static int __init
2257eth_bind (struct usb_gadget *gadget)
2258{
2259 struct eth_dev *dev;
2260 struct net_device *net;
2261 u8 cdc = 1, zlp = 1, rndis = 1;
2262 struct usb_ep *in_ep, *out_ep, *status_ep = NULL;
2263 int status = -ENOMEM;
2264
2265 /* these flags are only ever cleared; compiler take note */
2266#ifndef DEV_CONFIG_CDC
2267 cdc = 0;
2268#endif
2269#ifndef CONFIG_USB_ETH_RNDIS
2270 rndis = 0;
2271#endif
2272
2273 /* Because most host side USB stacks handle CDC Ethernet, that
2274 * standard protocol is _strongly_ preferred for interop purposes.
2275 * (By everyone except Microsoft.)
2276 */
2277 if (gadget_is_net2280 (gadget)) {
2278 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0201);
2279 } else if (gadget_is_dummy (gadget)) {
2280 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0202);
2281 } else if (gadget_is_pxa (gadget)) {
2282 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0203);
2283 /* pxa doesn't support altsettings */
2284 cdc = 0;
2285 } else if (gadget_is_sh(gadget)) {
2286 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0204);
2287 /* sh doesn't support multiple interfaces or configs */
2288 cdc = 0;
2289 rndis = 0;
2290 } else if (gadget_is_sa1100 (gadget)) {
2291 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0205);
2292 /* hardware can't write zlps */
2293 zlp = 0;
2294 /* sa1100 CAN do CDC, without status endpoint ... we use
2295 * non-CDC to be compatible with ARM Linux-2.4 "usb-eth".
2296 */
2297 cdc = 0;
2298 } else if (gadget_is_goku (gadget)) {
2299 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0206);
2300 } else if (gadget_is_mq11xx (gadget)) {
2301 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0207);
2302 } else if (gadget_is_omap (gadget)) {
2303 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0208);
2304 } else if (gadget_is_lh7a40x(gadget)) {
2305 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0209);
2306 } else if (gadget_is_n9604(gadget)) {
2307 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0210);
2308 } else if (gadget_is_pxa27x(gadget)) {
2309 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0211);
2310 } else if (gadget_is_s3c2410(gadget)) {
2311 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0212);
2312 } else if (gadget_is_at91(gadget)) {
2313 device_desc.bcdDevice = __constant_cpu_to_le16 (0x0213);
2314 } else {
2315 /* can't assume CDC works. don't want to default to
2316 * anything less functional on CDC-capable hardware,
2317 * so we fail in this case.
2318 */
2319 dev_err (&gadget->dev,
2320 "controller '%s' not recognized\n",
2321 gadget->name);
2322 return -ENODEV;
2323 }
2324 snprintf (manufacturer, sizeof manufacturer, "%s %s/%s",
2325 system_utsname.sysname, system_utsname.release,
2326 gadget->name);
2327
2328 /* If there's an RNDIS configuration, that's what Windows wants to
2329 * be using ... so use these product IDs here and in the "linux.inf"
2330 * needed to install MSFT drivers. Current Linux kernels will use
2331 * the second configuration if it's CDC Ethernet, and need some help
2332 * to choose the right configuration otherwise.
2333 */
2334 if (rndis) {
2335 device_desc.idVendor =
2336 __constant_cpu_to_le16(RNDIS_VENDOR_NUM);
2337 device_desc.idProduct =
2338 __constant_cpu_to_le16(RNDIS_PRODUCT_NUM);
2339 snprintf (product_desc, sizeof product_desc,
2340 "RNDIS/%s", driver_desc);
2341
2342 /* CDC subset ... recognized by Linux since 2.4.10, but Windows
2343 * drivers aren't widely available.
2344 */
2345 } else if (!cdc) {
2346 device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC;
2347 device_desc.idVendor =
2348 __constant_cpu_to_le16(SIMPLE_VENDOR_NUM);
2349 device_desc.idProduct =
2350 __constant_cpu_to_le16(SIMPLE_PRODUCT_NUM);
2351 }
2352
2353 /* support optional vendor/distro customization */
2354 if (idVendor) {
2355 if (!idProduct) {
2356 dev_err (&gadget->dev, "idVendor needs idProduct!\n");
2357 return -ENODEV;
2358 }
2359 device_desc.idVendor = cpu_to_le16(idVendor);
2360 device_desc.idProduct = cpu_to_le16(idProduct);
2361 if (bcdDevice)
2362 device_desc.bcdDevice = cpu_to_le16(bcdDevice);
2363 }
2364 if (iManufacturer)
2365 strlcpy (manufacturer, iManufacturer, sizeof manufacturer);
2366 if (iProduct)
2367 strlcpy (product_desc, iProduct, sizeof product_desc);
2368
2369 /* all we really need is bulk IN/OUT */
2370 usb_ep_autoconfig_reset (gadget);
2371 in_ep = usb_ep_autoconfig (gadget, &fs_source_desc);
2372 if (!in_ep) {
2373autoconf_fail:
2374 dev_err (&gadget->dev,
2375 "can't autoconfigure on %s\n",
2376 gadget->name);
2377 return -ENODEV;
2378 }
2379 EP_IN_NAME = in_ep->name;
2380 in_ep->driver_data = in_ep; /* claim */
2381
2382 out_ep = usb_ep_autoconfig (gadget, &fs_sink_desc);
2383 if (!out_ep)
2384 goto autoconf_fail;
2385 EP_OUT_NAME = out_ep->name;
2386 out_ep->driver_data = out_ep; /* claim */
2387
2388#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
2389 /* CDC Ethernet control interface doesn't require a status endpoint.
2390 * Since some hosts expect one, try to allocate one anyway.
2391 */
2392 if (cdc || rndis) {
2393 status_ep = usb_ep_autoconfig (gadget, &fs_status_desc);
2394 if (status_ep) {
2395 EP_STATUS_NAME = status_ep->name;
2396 status_ep->driver_data = status_ep; /* claim */
2397 } else if (rndis) {
2398 dev_err (&gadget->dev,
2399 "can't run RNDIS on %s\n",
2400 gadget->name);
2401 return -ENODEV;
2402#ifdef DEV_CONFIG_CDC
2403 /* pxa25x only does CDC subset; often used with RNDIS */
2404 } else if (cdc) {
2405 control_intf.bNumEndpoints = 0;
2406 /* FIXME remove endpoint from descriptor list */
2407#endif
2408 }
2409 }
2410#endif
2411
2412 /* one config: cdc, else minimal subset */
2413 if (!cdc) {
2414 eth_config.bNumInterfaces = 1;
2415 eth_config.iConfiguration = STRING_SUBSET;
2416 fs_subset_descriptors();
2417 hs_subset_descriptors();
2418 }
2419
2420 /* For now RNDIS is always a second config */
2421 if (rndis)
2422 device_desc.bNumConfigurations = 2;
2423
2424#ifdef CONFIG_USB_GADGET_DUALSPEED
2425 if (rndis)
2426 dev_qualifier.bNumConfigurations = 2;
2427 else if (!cdc)
2428 dev_qualifier.bDeviceClass = USB_CLASS_VENDOR_SPEC;
2429
2430 /* assumes ep0 uses the same value for both speeds ... */
2431 dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
2432
2433 /* and that all endpoints are dual-speed */
2434 hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress;
2435 hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress;
2436#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
2437 if (EP_STATUS_NAME)
2438 hs_status_desc.bEndpointAddress =
2439 fs_status_desc.bEndpointAddress;
2440#endif
2441#endif /* DUALSPEED */
2442
2443 device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
2444 usb_gadget_set_selfpowered (gadget);
2445
2446 if (gadget->is_otg) {
2447 otg_descriptor.bmAttributes |= USB_OTG_HNP,
2448 eth_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
2449 eth_config.bMaxPower = 4;
2450#ifdef CONFIG_USB_ETH_RNDIS
2451 rndis_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
2452 rndis_config.bMaxPower = 4;
2453#endif
2454 }
2455
2456 net = alloc_etherdev (sizeof *dev);
2457 if (!net)
2458 return status;
2459 dev = netdev_priv(net);
2460 spin_lock_init (&dev->lock);
2461 INIT_WORK (&dev->work, eth_work, dev);
2462 INIT_LIST_HEAD (&dev->tx_reqs);
2463 INIT_LIST_HEAD (&dev->rx_reqs);
2464
2465 /* network device setup */
2466 dev->net = net;
2467 SET_MODULE_OWNER (net);
2468 strcpy (net->name, "usb%d");
2469 dev->cdc = cdc;
2470 dev->zlp = zlp;
2471
2472 dev->in_ep = in_ep;
2473 dev->out_ep = out_ep;
2474 dev->status_ep = status_ep;
2475
2476 /* Module params for these addresses should come from ID proms.
2477 * The host side address is used with CDC and RNDIS, and commonly
2478 * ends up in a persistent config database.
2479 */
2480 get_ether_addr(dev_addr, net->dev_addr);
2481 if (cdc || rndis) {
2482 get_ether_addr(host_addr, dev->host_mac);
2483#ifdef DEV_CONFIG_CDC
2484 snprintf (ethaddr, sizeof ethaddr, "%02X%02X%02X%02X%02X%02X",
2485 dev->host_mac [0], dev->host_mac [1],
2486 dev->host_mac [2], dev->host_mac [3],
2487 dev->host_mac [4], dev->host_mac [5]);
2488#endif
2489 }
2490
2491 if (rndis) {
2492 status = rndis_init();
2493 if (status < 0) {
2494 dev_err (&gadget->dev, "can't init RNDIS, %d\n",
2495 status);
2496 goto fail;
2497 }
2498 }
2499
2500 net->change_mtu = eth_change_mtu;
2501 net->get_stats = eth_get_stats;
2502 net->hard_start_xmit = eth_start_xmit;
2503 net->open = eth_open;
2504 net->stop = eth_stop;
2505 // watchdog_timeo, tx_timeout ...
2506 // set_multicast_list
2507 SET_ETHTOOL_OPS(net, &ops);
2508
2509 /* preallocate control message data and buffer */
2510 dev->req = eth_req_alloc (gadget->ep0, USB_BUFSIZ);
2511 if (!dev->req)
2512 goto fail;
2513 dev->req->complete = eth_setup_complete;
2514
2515 /* ... and maybe likewise for status transfer */
2516 if (dev->status_ep) {
2517 dev->stat_req = eth_req_alloc (dev->status_ep,
2518 STATUS_BYTECOUNT);
2519 if (!dev->stat_req) {
2520 eth_req_free (gadget->ep0, dev->req);
2521 goto fail;
2522 }
2523 }
2524
2525 /* finish hookup to lower layer ... */
2526 dev->gadget = gadget;
2527 set_gadget_data (gadget, dev);
2528 gadget->ep0->driver_data = dev;
2529
2530 /* two kinds of host-initiated state changes:
2531 * - iff DATA transfer is active, carrier is "on"
2532 * - tx queueing enabled if open *and* carrier is "on"
2533 */
2534 netif_stop_queue (dev->net);
2535 netif_carrier_off (dev->net);
2536
2537 // SET_NETDEV_DEV (dev->net, &gadget->dev);
2538 status = register_netdev (dev->net);
2539 if (status < 0)
2540 goto fail1;
2541
2542 INFO (dev, "%s, version: " DRIVER_VERSION "\n", driver_desc);
2543 INFO (dev, "using %s, OUT %s IN %s%s%s\n", gadget->name,
2544 EP_OUT_NAME, EP_IN_NAME,
2545 EP_STATUS_NAME ? " STATUS " : "",
2546 EP_STATUS_NAME ? EP_STATUS_NAME : ""
2547 );
2548 INFO (dev, "MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
2549 net->dev_addr [0], net->dev_addr [1],
2550 net->dev_addr [2], net->dev_addr [3],
2551 net->dev_addr [4], net->dev_addr [5]);
2552
2553 if (cdc || rndis)
2554 INFO (dev, "HOST MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
2555 dev->host_mac [0], dev->host_mac [1],
2556 dev->host_mac [2], dev->host_mac [3],
2557 dev->host_mac [4], dev->host_mac [5]);
2558
2559#ifdef CONFIG_USB_ETH_RNDIS
2560 if (rndis) {
2561 u32 vendorID = 0;
2562
2563 /* FIXME RNDIS vendor id == "vendor NIC code" == ? */
2564
2565 dev->rndis_config = rndis_register (rndis_control_ack);
2566 if (dev->rndis_config < 0) {
2567fail0:
2568 unregister_netdev (dev->net);
2569 status = -ENODEV;
2570 goto fail;
2571 }
2572
2573 /* these set up a lot of the OIDs that RNDIS needs */
2574 rndis_set_host_mac (dev->rndis_config, dev->host_mac);
2575 if (rndis_set_param_dev (dev->rndis_config, dev->net,
2576 &dev->stats))
2577 goto fail0;
2578 if (rndis_set_param_vendor (dev->rndis_config, vendorID,
2579 manufacturer))
2580 goto fail0;
2581 if (rndis_set_param_medium (dev->rndis_config,
2582 NDIS_MEDIUM_802_3,
2583 0))
2584 goto fail0;
2585 INFO (dev, "RNDIS ready\n");
2586 }
2587#endif
2588
2589 return status;
2590
2591fail1:
2592 dev_dbg(&gadget->dev, "register_netdev failed, %d\n", status);
2593fail:
2594 eth_unbind (gadget);
2595 return status;
2596}
2597
2598/*-------------------------------------------------------------------------*/
2599
2600static void
2601eth_suspend (struct usb_gadget *gadget)
2602{
2603 struct eth_dev *dev = get_gadget_data (gadget);
2604
2605 DEBUG (dev, "suspend\n");
2606 dev->suspended = 1;
2607}
2608
2609static void
2610eth_resume (struct usb_gadget *gadget)
2611{
2612 struct eth_dev *dev = get_gadget_data (gadget);
2613
2614 DEBUG (dev, "resume\n");
2615 dev->suspended = 0;
2616}
2617
2618/*-------------------------------------------------------------------------*/
2619
2620static struct usb_gadget_driver eth_driver = {
2621#ifdef CONFIG_USB_GADGET_DUALSPEED
2622 .speed = USB_SPEED_HIGH,
2623#else
2624 .speed = USB_SPEED_FULL,
2625#endif
2626 .function = (char *) driver_desc,
2627 .bind = eth_bind,
2628 .unbind = eth_unbind,
2629
2630 .setup = eth_setup,
2631 .disconnect = eth_disconnect,
2632
2633 .suspend = eth_suspend,
2634 .resume = eth_resume,
2635
2636 .driver = {
2637 .name = (char *) shortname,
2638 // .shutdown = ...
2639 // .suspend = ...
2640 // .resume = ...
2641 },
2642};
2643
2644MODULE_DESCRIPTION (DRIVER_DESC);
2645MODULE_AUTHOR ("David Brownell, Benedikt Spanger");
2646MODULE_LICENSE ("GPL");
2647
2648
2649static int __init init (void)
2650{
2651 return usb_gadget_register_driver (&eth_driver);
2652}
2653module_init (init);
2654
2655static void __exit cleanup (void)
2656{
2657 usb_gadget_unregister_driver (&eth_driver);
2658}
2659module_exit (cleanup);
2660
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-29 02:29:45 -0500