Merge branch 'autosuspend' into for-next
[linux-2.6] / drivers / usb / gadget / ether.c
1 /*
2  * ether.c -- Ethernet gadget driver, with CDC and non-CDC options
3  *
4  * Copyright (C) 2003-2005,2008 David Brownell
5  * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
6  * Copyright (C) 2008 Nokia Corporation
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22
23 /* #define VERBOSE_DEBUG */
24
25 #include <linux/kernel.h>
26 #include <linux/utsname.h>
27
28 #include "u_ether.h"
29
30
31 /*
32  * Ethernet gadget driver -- with CDC and non-CDC options
33  * Builds on hardware support for a full duplex link.
34  *
35  * CDC Ethernet is the standard USB solution for sending Ethernet frames
36  * using USB.  Real hardware tends to use the same framing protocol but look
37  * different for control features.  This driver strongly prefers to use
38  * this USB-IF standard as its open-systems interoperability solution;
39  * most host side USB stacks (except from Microsoft) support it.
40  *
41  * This is sometimes called "CDC ECM" (Ethernet Control Model) to support
42  * TLA-soup.  "CDC ACM" (Abstract Control Model) is for modems, and a new
43  * "CDC EEM" (Ethernet Emulation Model) is starting to spread.
44  *
45  * There's some hardware that can't talk CDC ECM.  We make that hardware
46  * implement a "minimalist" vendor-agnostic CDC core:  same framing, but
47  * link-level setup only requires activating the configuration.  Only the
48  * endpoint descriptors, and product/vendor IDs, are relevant; no control
49  * operations are available.  Linux supports it, but other host operating
50  * systems may not.  (This is a subset of CDC Ethernet.)
51  *
52  * It turns out that if you add a few descriptors to that "CDC Subset",
53  * (Windows) host side drivers from MCCI can treat it as one submode of
54  * a proprietary scheme called "SAFE" ... without needing to know about
55  * specific product/vendor IDs.  So we do that, making it easier to use
56  * those MS-Windows drivers.  Those added descriptors make it resemble a
57  * CDC MDLM device, but they don't change device behavior at all.  (See
58  * MCCI Engineering report 950198 "SAFE Networking Functions".)
59  *
60  * A third option is also in use.  Rather than CDC Ethernet, or something
61  * simpler, Microsoft pushes their own approach: RNDIS.  The published
62  * RNDIS specs are ambiguous and appear to be incomplete, and are also
63  * needlessly complex.  They borrow more from CDC ACM than CDC ECM.
64  */
65
66 #define DRIVER_DESC             "Ethernet Gadget"
67 #define DRIVER_VERSION          "Memorial Day 2008"
68
69 #ifdef CONFIG_USB_ETH_RNDIS
70 #define PREFIX                  "RNDIS/"
71 #else
72 #define PREFIX                  ""
73 #endif
74
75 /*
76  * This driver aims for interoperability by using CDC ECM unless
77  *
78  *              can_support_ecm()
79  *
80  * returns false, in which case it supports the CDC Subset.  By default,
81  * that returns true; most hardware has no problems with CDC ECM, that's
82  * a good default.  Previous versions of this driver had no default; this
83  * version changes that, removing overhead for new controller support.
84  *
85  *      IF YOUR HARDWARE CAN'T SUPPORT CDC ECM, UPDATE THAT ROUTINE!
86  */
87
88 static inline bool has_rndis(void)
89 {
90 #ifdef  CONFIG_USB_ETH_RNDIS
91         return true;
92 #else
93         return false;
94 #endif
95 }
96
97 /*-------------------------------------------------------------------------*/
98
99 /*
100  * Kbuild is not very cooperative with respect to linking separately
101  * compiled library objects into one module.  So for now we won't use
102  * separate compilation ... ensuring init/exit sections work to shrink
103  * the runtime footprint, and giving us at least some parts of what
104  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
105  */
106 #include "composite.c"
107 #include "usbstring.c"
108 #include "config.c"
109 #include "epautoconf.c"
110
111 #include "f_ecm.c"
112 #include "f_subset.c"
113 #ifdef  CONFIG_USB_ETH_RNDIS
114 #include "f_rndis.c"
115 #include "rndis.c"
116 #endif
117 #include "u_ether.c"
118
119 /*-------------------------------------------------------------------------*/
120
121 /* DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
122  * Instead:  allocate your own, using normal USB-IF procedures.
123  */
124
125 /* Thanks to NetChip Technologies for donating this product ID.
126  * It's for devices with only CDC Ethernet configurations.
127  */
128 #define CDC_VENDOR_NUM          0x0525  /* NetChip */
129 #define CDC_PRODUCT_NUM         0xa4a1  /* Linux-USB Ethernet Gadget */
130
131 /* For hardware that can't talk CDC, we use the same vendor ID that
132  * ARM Linux has used for ethernet-over-usb, both with sa1100 and
133  * with pxa250.  We're protocol-compatible, if the host-side drivers
134  * use the endpoint descriptors.  bcdDevice (version) is nonzero, so
135  * drivers that need to hard-wire endpoint numbers have a hook.
136  *
137  * The protocol is a minimal subset of CDC Ether, which works on any bulk
138  * hardware that's not deeply broken ... even on hardware that can't talk
139  * RNDIS (like SA-1100, with no interrupt endpoint, or anything that
140  * doesn't handle control-OUT).
141  */
142 #define SIMPLE_VENDOR_NUM       0x049f
143 #define SIMPLE_PRODUCT_NUM      0x505a
144
145 /* For hardware that can talk RNDIS and either of the above protocols,
146  * use this ID ... the windows INF files will know it.  Unless it's
147  * used with CDC Ethernet, Linux 2.4 hosts will need updates to choose
148  * the non-RNDIS configuration.
149  */
150 #define RNDIS_VENDOR_NUM        0x0525  /* NetChip */
151 #define RNDIS_PRODUCT_NUM       0xa4a2  /* Ethernet/RNDIS Gadget */
152
153 /*-------------------------------------------------------------------------*/
154
155 static struct usb_device_descriptor device_desc = {
156         .bLength =              sizeof device_desc,
157         .bDescriptorType =      USB_DT_DEVICE,
158
159         .bcdUSB =               cpu_to_le16 (0x0200),
160
161         .bDeviceClass =         USB_CLASS_COMM,
162         .bDeviceSubClass =      0,
163         .bDeviceProtocol =      0,
164         /* .bMaxPacketSize0 = f(hardware) */
165
166         /* Vendor and product id defaults change according to what configs
167          * we support.  (As does bNumConfigurations.)  These values can
168          * also be overridden by module parameters.
169          */
170         .idVendor =             cpu_to_le16 (CDC_VENDOR_NUM),
171         .idProduct =            cpu_to_le16 (CDC_PRODUCT_NUM),
172         /* .bcdDevice = f(hardware) */
173         /* .iManufacturer = DYNAMIC */
174         /* .iProduct = DYNAMIC */
175         /* NO SERIAL NUMBER */
176         .bNumConfigurations =   1,
177 };
178
179 static struct usb_otg_descriptor otg_descriptor = {
180         .bLength =              sizeof otg_descriptor,
181         .bDescriptorType =      USB_DT_OTG,
182
183         /* REVISIT SRP-only hardware is possible, although
184          * it would not be called "OTG" ...
185          */
186         .bmAttributes =         USB_OTG_SRP | USB_OTG_HNP,
187 };
188
189 static const struct usb_descriptor_header *otg_desc[] = {
190         (struct usb_descriptor_header *) &otg_descriptor,
191         NULL,
192 };
193
194
195 /* string IDs are assigned dynamically */
196
197 #define STRING_MANUFACTURER_IDX         0
198 #define STRING_PRODUCT_IDX              1
199
200 static char manufacturer[50];
201
202 static struct usb_string strings_dev[] = {
203         [STRING_MANUFACTURER_IDX].s = manufacturer,
204         [STRING_PRODUCT_IDX].s = PREFIX DRIVER_DESC,
205         {  } /* end of list */
206 };
207
208 static struct usb_gadget_strings stringtab_dev = {
209         .language       = 0x0409,       /* en-us */
210         .strings        = strings_dev,
211 };
212
213 static struct usb_gadget_strings *dev_strings[] = {
214         &stringtab_dev,
215         NULL,
216 };
217
218 static u8 hostaddr[ETH_ALEN];
219
220 /*-------------------------------------------------------------------------*/
221
222 /*
223  * We may not have an RNDIS configuration, but if we do it needs to be
224  * the first one present.  That's to make Microsoft's drivers happy,
225  * and to follow DOCSIS 1.0 (cable modem standard).
226  */
227 static int __init rndis_do_config(struct usb_configuration *c)
228 {
229         /* FIXME alloc iConfiguration string, set it in c->strings */
230
231         if (gadget_is_otg(c->cdev->gadget)) {
232                 c->descriptors = otg_desc;
233                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
234         }
235
236         return rndis_bind_config(c, hostaddr);
237 }
238
239 static struct usb_configuration rndis_config_driver = {
240         .label                  = "RNDIS",
241         .bind                   = rndis_do_config,
242         .bConfigurationValue    = 2,
243         /* .iConfiguration = DYNAMIC */
244         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
245 };
246
247 /*-------------------------------------------------------------------------*/
248
249 /*
250  * We _always_ have an ECM or CDC Subset configuration.
251  */
252 static int __init eth_do_config(struct usb_configuration *c)
253 {
254         /* FIXME alloc iConfiguration string, set it in c->strings */
255
256         if (gadget_is_otg(c->cdev->gadget)) {
257                 c->descriptors = otg_desc;
258                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
259         }
260
261         if (can_support_ecm(c->cdev->gadget))
262                 return ecm_bind_config(c, hostaddr);
263         else
264                 return geth_bind_config(c, hostaddr);
265 }
266
267 static struct usb_configuration eth_config_driver = {
268         /* .label = f(hardware) */
269         .bind                   = eth_do_config,
270         .bConfigurationValue    = 1,
271         /* .iConfiguration = DYNAMIC */
272         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
273 };
274
275 /*-------------------------------------------------------------------------*/
276
277 static int __init eth_bind(struct usb_composite_dev *cdev)
278 {
279         int                     gcnum;
280         struct usb_gadget       *gadget = cdev->gadget;
281         int                     status;
282
283         /* set up network link layer */
284         status = gether_setup(cdev->gadget, hostaddr);
285         if (status < 0)
286                 return status;
287
288         /* set up main config label and device descriptor */
289         if (can_support_ecm(cdev->gadget)) {
290                 /* ECM */
291                 eth_config_driver.label = "CDC Ethernet (ECM)";
292         } else {
293                 /* CDC Subset */
294                 eth_config_driver.label = "CDC Subset/SAFE";
295
296                 device_desc.idVendor = cpu_to_le16(SIMPLE_VENDOR_NUM),
297                 device_desc.idProduct = cpu_to_le16(SIMPLE_PRODUCT_NUM),
298                 device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC;
299         }
300
301         if (has_rndis()) {
302                 /* RNDIS plus ECM-or-Subset */
303                 device_desc.idVendor = cpu_to_le16(RNDIS_VENDOR_NUM),
304                 device_desc.idProduct = cpu_to_le16(RNDIS_PRODUCT_NUM),
305                 device_desc.bNumConfigurations = 2;
306         }
307
308         gcnum = usb_gadget_controller_number(gadget);
309         if (gcnum >= 0)
310                 device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
311         else {
312                 /* We assume that can_support_ecm() tells the truth;
313                  * but if the controller isn't recognized at all then
314                  * that assumption is a bit more likely to be wrong.
315                  */
316                 dev_warn(&gadget->dev,
317                                 "controller '%s' not recognized; trying %s\n",
318                                 gadget->name,
319                                 eth_config_driver.label);
320                 device_desc.bcdDevice =
321                         cpu_to_le16(0x0300 | 0x0099);
322         }
323
324
325         /* Allocate string descriptor numbers ... note that string
326          * contents can be overridden by the composite_dev glue.
327          */
328
329         /* device descriptor strings: manufacturer, product */
330         snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
331                 init_utsname()->sysname, init_utsname()->release,
332                 gadget->name);
333         status = usb_string_id(cdev);
334         if (status < 0)
335                 goto fail;
336         strings_dev[STRING_MANUFACTURER_IDX].id = status;
337         device_desc.iManufacturer = status;
338
339         status = usb_string_id(cdev);
340         if (status < 0)
341                 goto fail;
342         strings_dev[STRING_PRODUCT_IDX].id = status;
343         device_desc.iProduct = status;
344
345         /* register our configuration(s); RNDIS first, if it's used */
346         if (has_rndis()) {
347                 status = usb_add_config(cdev, &rndis_config_driver);
348                 if (status < 0)
349                         goto fail;
350         }
351
352         status = usb_add_config(cdev, &eth_config_driver);
353         if (status < 0)
354                 goto fail;
355
356         dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n",
357                         DRIVER_DESC);
358
359         return 0;
360
361 fail:
362         gether_cleanup();
363         return status;
364 }
365
366 static int __exit eth_unbind(struct usb_composite_dev *cdev)
367 {
368         gether_cleanup();
369         return 0;
370 }
371
372 static struct usb_composite_driver eth_driver = {
373         .name           = "g_ether",
374         .dev            = &device_desc,
375         .strings        = dev_strings,
376         .bind           = eth_bind,
377         .unbind         = __exit_p(eth_unbind),
378 };
379
380 MODULE_DESCRIPTION(PREFIX DRIVER_DESC);
381 MODULE_AUTHOR("David Brownell, Benedikt Spanger");
382 MODULE_LICENSE("GPL");
383
384 static int __init init(void)
385 {
386         return usb_composite_register(&eth_driver);
387 }
388 module_init(init);
389
390 static void __exit cleanup(void)
391 {
392         usb_composite_unregister(&eth_driver);
393 }
394 module_exit(cleanup);