diff options
Diffstat (limited to 'drivers/usb/gadget')
-rw-r--r-- | drivers/usb/gadget/Makefile | 4 | ||||
-rw-r--r-- | drivers/usb/gadget/zero.c | 1162 |
2 files changed, 97 insertions, 1069 deletions
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile index 16211435761f..fe60cca704d9 100644 --- a/drivers/usb/gadget/Makefile +++ b/drivers/usb/gadget/Makefile | |||
@@ -22,7 +22,9 @@ obj-$(CONFIG_USB_M66592) += m66592-udc.o | |||
22 | # | 22 | # |
23 | # USB gadget drivers | 23 | # USB gadget drivers |
24 | # | 24 | # |
25 | g_zero-objs := zero.o usbstring.o config.o epautoconf.o | 25 | C_UTILS = composite.o usbstring.o config.o epautoconf.o |
26 | |||
27 | g_zero-objs := zero.o f_sourcesink.o f_loopback.o $(C_UTILS) | ||
26 | g_ether-objs := ether.o usbstring.o config.o epautoconf.o | 28 | g_ether-objs := ether.o usbstring.o config.o epautoconf.o |
27 | g_serial-objs := serial.o u_serial.o usbstring.o config.o epautoconf.o | 29 | g_serial-objs := serial.o u_serial.o usbstring.o config.o epautoconf.o |
28 | g_midi-objs := gmidi.o usbstring.o config.o epautoconf.o | 30 | g_midi-objs := gmidi.o usbstring.o config.o epautoconf.o |
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c index fce4924dbbe8..aa0bd4f126a1 100644 --- a/drivers/usb/gadget/zero.c +++ b/drivers/usb/gadget/zero.c | |||
@@ -1,8 +1,8 @@ | |||
1 | /* | 1 | /* |
2 | * zero.c -- Gadget Zero, for USB development | 2 | * zero.c -- Gadget Zero, for USB development |
3 | * | 3 | * |
4 | * Copyright (C) 2003-2007 David Brownell | 4 | * Copyright (C) 2003-2008 David Brownell |
5 | * All rights reserved. | 5 | * Copyright (C) 2008 by Nokia Corporation |
6 | * | 6 | * |
7 | * This program is free software; you can redistribute it and/or modify | 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 | 8 | * it under the terms of the GNU General Public License as published by |
@@ -30,12 +30,7 @@ | |||
30 | * | 30 | * |
31 | * It supports two similar configurations. One sinks whatever the usb host | 31 | * It supports two similar configurations. One sinks whatever the usb host |
32 | * writes, and in return sources zeroes. The other loops whatever the host | 32 | * writes, and in return sources zeroes. The other loops whatever the host |
33 | * writes back, so the host can read it. Module options include: | 33 | * writes back, so the host can read it. |
34 | * | ||
35 | * buflen=N default N=4096, buffer size used | ||
36 | * qlen=N default N=32, how many buffers in the loopback queue | ||
37 | * loopdefault default false, list loopback config first | ||
38 | * autoresume=N default N=0, seconds before triggering remote wakeup | ||
39 | * | 34 | * |
40 | * Many drivers will only have one configuration, letting them be much | 35 | * Many drivers will only have one configuration, letting them be much |
41 | * simpler if they also don't support high speed operation (like this | 36 | * simpler if they also don't support high speed operation (like this |
@@ -47,94 +42,35 @@ | |||
47 | * work with low capability USB controllers without four bulk endpoints. | 42 | * work with low capability USB controllers without four bulk endpoints. |
48 | */ | 43 | */ |
49 | 44 | ||
45 | /* | ||
46 | * driver assumes self-powered hardware, and | ||
47 | * has no way for users to trigger remote wakeup. | ||
48 | */ | ||
49 | |||
50 | /* #define VERBOSE_DEBUG */ | 50 | /* #define VERBOSE_DEBUG */ |
51 | 51 | ||
52 | #include <linux/kernel.h> | 52 | #include <linux/kernel.h> |
53 | #include <linux/utsname.h> | 53 | #include <linux/utsname.h> |
54 | #include <linux/device.h> | 54 | #include <linux/device.h> |
55 | 55 | ||
56 | #include <linux/usb/ch9.h> | 56 | #include "g_zero.h" |
57 | #include <linux/usb/gadget.h> | ||
58 | |||
59 | #include "gadget_chips.h" | 57 | #include "gadget_chips.h" |
60 | 58 | ||
61 | 59 | ||
62 | /*-------------------------------------------------------------------------*/ | 60 | /*-------------------------------------------------------------------------*/ |
63 | 61 | ||
64 | #define DRIVER_VERSION "Earth Day 2008" | 62 | #define DRIVER_VERSION "Cinco de Mayo 2008" |
65 | 63 | ||
66 | static const char shortname[] = "zero"; | ||
67 | static const char longname[] = "Gadget Zero"; | 64 | static const char longname[] = "Gadget Zero"; |
68 | 65 | ||
69 | static const char source_sink[] = "source and sink data"; | 66 | unsigned buflen = 4096; |
70 | static const char loopback[] = "loop input to output"; | 67 | module_param(buflen, uint, 0); |
71 | |||
72 | /*-------------------------------------------------------------------------*/ | ||
73 | |||
74 | /* | ||
75 | * driver assumes self-powered hardware, and | ||
76 | * has no way for users to trigger remote wakeup. | ||
77 | * | ||
78 | * this version autoconfigures as much as possible, | ||
79 | * which is reasonable for most "bulk-only" drivers. | ||
80 | */ | ||
81 | static const char *EP_IN_NAME; /* source */ | ||
82 | static const char *EP_OUT_NAME; /* sink */ | ||
83 | |||
84 | /*-------------------------------------------------------------------------*/ | ||
85 | |||
86 | /* big enough to hold our biggest descriptor */ | ||
87 | #define USB_BUFSIZ 256 | ||
88 | |||
89 | struct zero_dev { | ||
90 | spinlock_t lock; | ||
91 | struct usb_gadget *gadget; | ||
92 | struct usb_request *req; /* for control responses */ | ||
93 | |||
94 | /* when configured, we have one of two configs: | ||
95 | * - source data (in to host) and sink it (out from host) | ||
96 | * - or loop it back (out from host back in to host) | ||
97 | */ | ||
98 | u8 config; | ||
99 | struct usb_ep *in_ep, *out_ep; | ||
100 | |||
101 | /* autoresume timer */ | ||
102 | struct timer_list resume; | ||
103 | }; | ||
104 | |||
105 | #define DBG(d, fmt, args...) \ | ||
106 | dev_dbg(&(d)->gadget->dev , fmt , ## args) | ||
107 | #define VDBG(d, fmt, args...) \ | ||
108 | dev_vdbg(&(d)->gadget->dev , fmt , ## args) | ||
109 | #define ERROR(d, fmt, args...) \ | ||
110 | dev_err(&(d)->gadget->dev , fmt , ## args) | ||
111 | #define WARN(d, fmt, args...) \ | ||
112 | dev_warn(&(d)->gadget->dev , fmt , ## args) | ||
113 | #define INFO(d, fmt, args...) \ | ||
114 | dev_info(&(d)->gadget->dev , fmt , ## args) | ||
115 | |||
116 | /*-------------------------------------------------------------------------*/ | ||
117 | |||
118 | static unsigned buflen = 4096; | ||
119 | static unsigned qlen = 32; | ||
120 | static unsigned pattern = 0; | ||
121 | |||
122 | module_param(buflen, uint, S_IRUGO); | ||
123 | module_param(qlen, uint, S_IRUGO); | ||
124 | module_param(pattern, uint, S_IRUGO|S_IWUSR); | ||
125 | |||
126 | /* | ||
127 | * if it's nonzero, autoresume says how many seconds to wait | ||
128 | * before trying to wake up the host after suspend. | ||
129 | */ | ||
130 | static unsigned autoresume = 0; | ||
131 | module_param(autoresume, uint, 0); | ||
132 | 68 | ||
133 | /* | 69 | /* |
134 | * Normally the "loopback" configuration is second (index 1) so | 70 | * Normally the "loopback" configuration is second (index 1) so |
135 | * it's not the default. Here's where to change that order, to | 71 | * it's not the default. Here's where to change that order, to |
136 | * work better with hosts where config changes are problematic. | 72 | * work better with hosts where config changes are problematic or |
137 | * Or controllers (like superh) that only support one config. | 73 | * controllers (like original superh) that only support one config. |
138 | */ | 74 | */ |
139 | static int loopdefault = 0; | 75 | static int loopdefault = 0; |
140 | module_param(loopdefault, bool, S_IRUGO|S_IWUSR); | 76 | module_param(loopdefault, bool, S_IRUGO|S_IWUSR); |
@@ -156,24 +92,6 @@ module_param(loopdefault, bool, S_IRUGO|S_IWUSR); | |||
156 | 92 | ||
157 | /*-------------------------------------------------------------------------*/ | 93 | /*-------------------------------------------------------------------------*/ |
158 | 94 | ||
159 | /* | ||
160 | * DESCRIPTORS ... most are static, but strings and (full) | ||
161 | * configuration descriptors are built on demand. | ||
162 | */ | ||
163 | |||
164 | #define STRING_MANUFACTURER 25 | ||
165 | #define STRING_PRODUCT 42 | ||
166 | #define STRING_SERIAL 101 | ||
167 | #define STRING_SOURCE_SINK 250 | ||
168 | #define STRING_LOOPBACK 251 | ||
169 | |||
170 | /* | ||
171 | * This device advertises two configurations; these numbers work | ||
172 | * on a pxa250 as well as more flexible hardware. | ||
173 | */ | ||
174 | #define CONFIG_SOURCE_SINK 3 | ||
175 | #define CONFIG_LOOPBACK 2 | ||
176 | |||
177 | static struct usb_device_descriptor device_desc = { | 95 | static struct usb_device_descriptor device_desc = { |
178 | .bLength = sizeof device_desc, | 96 | .bLength = sizeof device_desc, |
179 | .bDescriptorType = USB_DT_DEVICE, | 97 | .bDescriptorType = USB_DT_DEVICE, |
@@ -183,248 +101,64 @@ static struct usb_device_descriptor device_desc = { | |||
183 | 101 | ||
184 | .idVendor = __constant_cpu_to_le16(DRIVER_VENDOR_NUM), | 102 | .idVendor = __constant_cpu_to_le16(DRIVER_VENDOR_NUM), |
185 | .idProduct = __constant_cpu_to_le16(DRIVER_PRODUCT_NUM), | 103 | .idProduct = __constant_cpu_to_le16(DRIVER_PRODUCT_NUM), |
186 | .iManufacturer = STRING_MANUFACTURER, | ||
187 | .iProduct = STRING_PRODUCT, | ||
188 | .iSerialNumber = STRING_SERIAL, | ||
189 | .bNumConfigurations = 2, | 104 | .bNumConfigurations = 2, |
190 | }; | 105 | }; |
191 | 106 | ||
192 | static struct usb_config_descriptor source_sink_config = { | 107 | #ifdef CONFIG_USB_OTG |
193 | .bLength = sizeof source_sink_config, | ||
194 | .bDescriptorType = USB_DT_CONFIG, | ||
195 | |||
196 | /* compute wTotalLength on the fly */ | ||
197 | .bNumInterfaces = 1, | ||
198 | .bConfigurationValue = CONFIG_SOURCE_SINK, | ||
199 | .iConfiguration = STRING_SOURCE_SINK, | ||
200 | .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER, | ||
201 | .bMaxPower = 1, /* self-powered */ | ||
202 | }; | ||
203 | |||
204 | static struct usb_config_descriptor loopback_config = { | ||
205 | .bLength = sizeof loopback_config, | ||
206 | .bDescriptorType = USB_DT_CONFIG, | ||
207 | |||
208 | /* compute wTotalLength on the fly */ | ||
209 | .bNumInterfaces = 1, | ||
210 | .bConfigurationValue = CONFIG_LOOPBACK, | ||
211 | .iConfiguration = STRING_LOOPBACK, | ||
212 | .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER, | ||
213 | .bMaxPower = 1, /* self-powered */ | ||
214 | }; | ||
215 | |||
216 | static struct usb_otg_descriptor otg_descriptor = { | 108 | static struct usb_otg_descriptor otg_descriptor = { |
217 | .bLength = sizeof otg_descriptor, | 109 | .bLength = sizeof otg_descriptor, |
218 | .bDescriptorType = USB_DT_OTG, | 110 | .bDescriptorType = USB_DT_OTG, |
219 | 111 | ||
220 | .bmAttributes = USB_OTG_SRP, | 112 | /* REVISIT SRP-only hardware is possible, although |
221 | }; | 113 | * it would not be called "OTG" ... |
222 | 114 | */ | |
223 | /* one interface in each configuration */ | 115 | .bmAttributes = USB_OTG_SRP | USB_OTG_HNP, |
224 | |||
225 | static const struct usb_interface_descriptor source_sink_intf = { | ||
226 | .bLength = sizeof source_sink_intf, | ||
227 | .bDescriptorType = USB_DT_INTERFACE, | ||
228 | |||
229 | .bNumEndpoints = 2, | ||
230 | .bInterfaceClass = USB_CLASS_VENDOR_SPEC, | ||
231 | .iInterface = STRING_SOURCE_SINK, | ||
232 | }; | ||
233 | |||
234 | static const struct usb_interface_descriptor loopback_intf = { | ||
235 | .bLength = sizeof loopback_intf, | ||
236 | .bDescriptorType = USB_DT_INTERFACE, | ||
237 | |||
238 | .bNumEndpoints = 2, | ||
239 | .bInterfaceClass = USB_CLASS_VENDOR_SPEC, | ||
240 | .iInterface = STRING_LOOPBACK, | ||
241 | }; | ||
242 | |||
243 | /* two full speed bulk endpoints; their use is config-dependent */ | ||
244 | |||
245 | static struct usb_endpoint_descriptor fs_source_desc = { | ||
246 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
247 | .bDescriptorType = USB_DT_ENDPOINT, | ||
248 | |||
249 | .bEndpointAddress = USB_DIR_IN, | ||
250 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
251 | }; | ||
252 | |||
253 | static struct usb_endpoint_descriptor fs_sink_desc = { | ||
254 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
255 | .bDescriptorType = USB_DT_ENDPOINT, | ||
256 | |||
257 | .bEndpointAddress = USB_DIR_OUT, | ||
258 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
259 | }; | ||
260 | |||
261 | static const struct usb_descriptor_header *fs_source_sink_function[] = { | ||
262 | (struct usb_descriptor_header *) &otg_descriptor, | ||
263 | (struct usb_descriptor_header *) &source_sink_intf, | ||
264 | (struct usb_descriptor_header *) &fs_sink_desc, | ||
265 | (struct usb_descriptor_header *) &fs_source_desc, | ||
266 | NULL, | ||
267 | }; | ||
268 | |||
269 | static const struct usb_descriptor_header *fs_loopback_function[] = { | ||
270 | (struct usb_descriptor_header *) &otg_descriptor, | ||
271 | (struct usb_descriptor_header *) &loopback_intf, | ||
272 | (struct usb_descriptor_header *) &fs_sink_desc, | ||
273 | (struct usb_descriptor_header *) &fs_source_desc, | ||
274 | NULL, | ||
275 | }; | ||
276 | |||
277 | /* | ||
278 | * usb 2.0 devices need to expose both high speed and full speed | ||
279 | * descriptors, unless they only run at full speed. | ||
280 | * | ||
281 | * that means alternate endpoint descriptors (bigger packets) | ||
282 | * and a "device qualifier" ... plus more construction options | ||
283 | * for the config descriptor. | ||
284 | */ | ||
285 | |||
286 | static struct usb_endpoint_descriptor hs_source_desc = { | ||
287 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
288 | .bDescriptorType = USB_DT_ENDPOINT, | ||
289 | |||
290 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
291 | .wMaxPacketSize = __constant_cpu_to_le16(512), | ||
292 | }; | ||
293 | |||
294 | static struct usb_endpoint_descriptor hs_sink_desc = { | ||
295 | .bLength = USB_DT_ENDPOINT_SIZE, | ||
296 | .bDescriptorType = USB_DT_ENDPOINT, | ||
297 | |||
298 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | ||
299 | .wMaxPacketSize = __constant_cpu_to_le16(512), | ||
300 | }; | ||
301 | |||
302 | static struct usb_qualifier_descriptor dev_qualifier = { | ||
303 | .bLength = sizeof dev_qualifier, | ||
304 | .bDescriptorType = USB_DT_DEVICE_QUALIFIER, | ||
305 | |||
306 | .bcdUSB = __constant_cpu_to_le16(0x0200), | ||
307 | .bDeviceClass = USB_CLASS_VENDOR_SPEC, | ||
308 | |||
309 | .bNumConfigurations = 2, | ||
310 | }; | 116 | }; |
311 | 117 | ||
312 | static const struct usb_descriptor_header *hs_source_sink_function[] = { | 118 | const struct usb_descriptor_header *otg_desc[] = { |
313 | (struct usb_descriptor_header *) &otg_descriptor, | 119 | (struct usb_descriptor_header *) &otg_descriptor, |
314 | (struct usb_descriptor_header *) &source_sink_intf, | ||
315 | (struct usb_descriptor_header *) &hs_source_desc, | ||
316 | (struct usb_descriptor_header *) &hs_sink_desc, | ||
317 | NULL, | 120 | NULL, |
318 | }; | 121 | }; |
122 | #endif | ||
319 | 123 | ||
320 | static const struct usb_descriptor_header *hs_loopback_function[] = { | 124 | /* string IDs are assigned dynamically */ |
321 | (struct usb_descriptor_header *) &otg_descriptor, | ||
322 | (struct usb_descriptor_header *) &loopback_intf, | ||
323 | (struct usb_descriptor_header *) &hs_source_desc, | ||
324 | (struct usb_descriptor_header *) &hs_sink_desc, | ||
325 | NULL, | ||
326 | }; | ||
327 | 125 | ||
328 | /* maxpacket and other transfer characteristics vary by speed. */ | 126 | #define STRING_MANUFACTURER_IDX 0 |
329 | static inline struct usb_endpoint_descriptor * | 127 | #define STRING_PRODUCT_IDX 1 |
330 | ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs, | 128 | #define STRING_SERIAL_IDX 2 |
331 | struct usb_endpoint_descriptor *fs) | ||
332 | { | ||
333 | if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH) | ||
334 | return hs; | ||
335 | return fs; | ||
336 | } | ||
337 | 129 | ||
338 | static char manufacturer[50]; | 130 | static char manufacturer[50]; |
339 | 131 | ||
340 | /* default serial number takes at least two packets */ | 132 | /* default serial number takes at least two packets */ |
341 | static char serial[] = "0123456789.0123456789.0123456789"; | 133 | static char serial[] = "0123456789.0123456789.0123456789"; |
342 | 134 | ||
343 | 135 | static struct usb_string strings_dev[] = { | |
344 | /* static strings, in UTF-8 */ | 136 | [STRING_MANUFACTURER_IDX].s = manufacturer, |
345 | static struct usb_string strings[] = { | 137 | [STRING_PRODUCT_IDX].s = longname, |
346 | { STRING_MANUFACTURER, manufacturer, }, | 138 | [STRING_SERIAL_IDX].s = serial, |
347 | { STRING_PRODUCT, longname, }, | ||
348 | { STRING_SERIAL, serial, }, | ||
349 | { STRING_LOOPBACK, loopback, }, | ||
350 | { STRING_SOURCE_SINK, source_sink, }, | ||
351 | { } /* end of list */ | 139 | { } /* end of list */ |
352 | }; | 140 | }; |
353 | 141 | ||
354 | static struct usb_gadget_strings stringtab = { | 142 | static struct usb_gadget_strings stringtab_dev = { |
355 | .language = 0x0409, /* en-us */ | 143 | .language = 0x0409, /* en-us */ |
356 | .strings = strings, | 144 | .strings = strings_dev, |
357 | }; | 145 | }; |
358 | 146 | ||
359 | /* | 147 | static struct usb_gadget_strings *dev_strings[] = { |
360 | * config descriptors are also handcrafted. these must agree with code | 148 | &stringtab_dev, |
361 | * that sets configurations, and with code managing interfaces and their | 149 | NULL, |
362 | * altsettings. other complexity may come from: | 150 | }; |
363 | * | ||
364 | * - high speed support, including "other speed config" rules | ||
365 | * - multiple configurations | ||
366 | * - interfaces with alternate settings | ||
367 | * - embedded class or vendor-specific descriptors | ||
368 | * | ||
369 | * this handles high speed, and has a second config that could as easily | ||
370 | * have been an alternate interface setting (on most hardware). | ||
371 | * | ||
372 | * NOTE: to demonstrate (and test) more USB capabilities, this driver | ||
373 | * should include an altsetting to test interrupt transfers, including | ||
374 | * high bandwidth modes at high speed. (Maybe work like Intel's test | ||
375 | * device?) | ||
376 | */ | ||
377 | static int config_buf(struct usb_gadget *gadget, | ||
378 | u8 *buf, u8 type, unsigned index) | ||
379 | { | ||
380 | int is_source_sink; | ||
381 | int len; | ||
382 | const struct usb_descriptor_header **function; | ||
383 | int hs = 0; | ||
384 | |||
385 | /* two configurations will always be index 0 and index 1 */ | ||
386 | if (index > 1) | ||
387 | return -EINVAL; | ||
388 | is_source_sink = loopdefault ? (index == 1) : (index == 0); | ||
389 | |||
390 | if (gadget_is_dualspeed(gadget)) { | ||
391 | hs = (gadget->speed == USB_SPEED_HIGH); | ||
392 | if (type == USB_DT_OTHER_SPEED_CONFIG) | ||
393 | hs = !hs; | ||
394 | } | ||
395 | if (hs) | ||
396 | function = is_source_sink | ||
397 | ? hs_source_sink_function | ||
398 | : hs_loopback_function; | ||
399 | else | ||
400 | function = is_source_sink | ||
401 | ? fs_source_sink_function | ||
402 | : fs_loopback_function; | ||
403 | |||
404 | /* for now, don't advertise srp-only devices */ | ||
405 | if (!gadget_is_otg(gadget)) | ||
406 | function++; | ||
407 | |||
408 | len = usb_gadget_config_buf(is_source_sink | ||
409 | ? &source_sink_config | ||
410 | : &loopback_config, | ||
411 | buf, USB_BUFSIZ, function); | ||
412 | if (len < 0) | ||
413 | return len; | ||
414 | ((struct usb_config_descriptor *) buf)->bDescriptorType = type; | ||
415 | return len; | ||
416 | } | ||
417 | 151 | ||
418 | /*-------------------------------------------------------------------------*/ | 152 | /*-------------------------------------------------------------------------*/ |
419 | 153 | ||
420 | static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length) | 154 | struct usb_request *alloc_ep_req(struct usb_ep *ep) |
421 | { | 155 | { |
422 | struct usb_request *req; | 156 | struct usb_request *req; |
423 | 157 | ||
424 | req = usb_ep_alloc_request(ep, GFP_ATOMIC); | 158 | req = usb_ep_alloc_request(ep, GFP_ATOMIC); |
425 | if (req) { | 159 | if (req) { |
426 | req->length = length; | 160 | req->length = buflen; |
427 | req->buf = kmalloc(length, GFP_ATOMIC); | 161 | req->buf = kmalloc(buflen, GFP_ATOMIC); |
428 | if (!req->buf) { | 162 | if (!req->buf) { |
429 | usb_ep_free_request(ep, req); | 163 | usb_ep_free_request(ep, req); |
430 | req = NULL; | 164 | req = NULL; |
@@ -433,681 +167,73 @@ static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length) | |||
433 | return req; | 167 | return req; |
434 | } | 168 | } |
435 | 169 | ||
436 | static void free_ep_req(struct usb_ep *ep, struct usb_request *req) | 170 | void free_ep_req(struct usb_ep *ep, struct usb_request *req) |
437 | { | 171 | { |
438 | kfree(req->buf); | 172 | kfree(req->buf); |
439 | usb_ep_free_request(ep, req); | 173 | usb_ep_free_request(ep, req); |
440 | } | 174 | } |
441 | 175 | ||
442 | /*-------------------------------------------------------------------------*/ | 176 | static void disable_ep(struct usb_composite_dev *cdev, struct usb_ep *ep) |
443 | |||
444 | /* | ||
445 | * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripherals, | ||
446 | * this just sinks bulk packets OUT to the peripheral and sources them IN | ||
447 | * to the host, optionally with specific data patterns. | ||
448 | * | ||
449 | * In terms of control messaging, this supports all the standard requests | ||
450 | * plus two that support control-OUT tests. | ||
451 | * | ||
452 | * Note that because this doesn't queue more than one request at a time, | ||
453 | * some other function must be used to test queueing logic. The network | ||
454 | * link (g_ether) is probably the best option for that. | ||
455 | */ | ||
456 | |||
457 | /* optionally require specific source/sink data patterns */ | ||
458 | |||
459 | static int | ||
460 | check_read_data( | ||
461 | struct zero_dev *dev, | ||
462 | struct usb_ep *ep, | ||
463 | struct usb_request *req | ||
464 | ) | ||
465 | { | 177 | { |
466 | unsigned i; | 178 | int value; |
467 | u8 *buf = req->buf; | 179 | |
468 | 180 | if (ep->driver_data) { | |
469 | for (i = 0; i < req->actual; i++, buf++) { | 181 | value = usb_ep_disable(ep); |
470 | switch (pattern) { | 182 | if (value < 0) |
471 | /* all-zeroes has no synchronization issues */ | 183 | DBG(cdev, "disable %s --> %d\n", |
472 | case 0: | 184 | ep->name, value); |
473 | if (*buf == 0) | 185 | ep->driver_data = NULL; |
474 | continue; | ||
475 | break; | ||
476 | /* mod63 stays in sync with short-terminated transfers, | ||
477 | * or otherwise when host and gadget agree on how large | ||
478 | * each usb transfer request should be. resync is done | ||
479 | * with set_interface or set_config. | ||
480 | */ | ||
481 | case 1: | ||
482 | if (*buf == (u8)(i % 63)) | ||
483 | continue; | ||
484 | break; | ||
485 | } | ||
486 | ERROR(dev, "bad OUT byte, buf[%d] = %d\n", i, *buf); | ||
487 | usb_ep_set_halt(ep); | ||
488 | return -EINVAL; | ||
489 | } | 186 | } |
490 | return 0; | ||
491 | } | 187 | } |
492 | 188 | ||
493 | static void reinit_write_data(struct usb_ep *ep, struct usb_request *req) | 189 | void disable_endpoints(struct usb_composite_dev *cdev, |
190 | struct usb_ep *in, struct usb_ep *out) | ||
494 | { | 191 | { |
495 | unsigned i; | 192 | disable_ep(cdev, in); |
496 | u8 *buf = req->buf; | 193 | disable_ep(cdev, out); |
497 | |||
498 | switch (pattern) { | ||
499 | case 0: | ||
500 | memset(req->buf, 0, req->length); | ||
501 | break; | ||
502 | case 1: | ||
503 | for (i = 0; i < req->length; i++) | ||
504 | *buf++ = (u8) (i % 63); | ||
505 | break; | ||
506 | } | ||
507 | } | ||
508 | |||
509 | /* if there is only one request in the queue, there'll always be an | ||
510 | * irq delay between end of one request and start of the next. | ||
511 | * that prevents using hardware dma queues. | ||
512 | */ | ||
513 | static void source_sink_complete(struct usb_ep *ep, struct usb_request *req) | ||
514 | { | ||
515 | struct zero_dev *dev = ep->driver_data; | ||
516 | int status = req->status; | ||
517 | |||
518 | switch (status) { | ||
519 | |||
520 | case 0: /* normal completion? */ | ||
521 | if (ep == dev->out_ep) { | ||
522 | check_read_data(dev, ep, req); | ||
523 | memset(req->buf, 0x55, req->length); | ||
524 | } else | ||
525 | reinit_write_data(ep, req); | ||
526 | break; | ||
527 | |||
528 | /* this endpoint is normally active while we're configured */ | ||
529 | case -ECONNABORTED: /* hardware forced ep reset */ | ||
530 | case -ECONNRESET: /* request dequeued */ | ||
531 | case -ESHUTDOWN: /* disconnect from host */ | ||
532 | VDBG(dev, "%s gone (%d), %d/%d\n", ep->name, status, | ||
533 | req->actual, req->length); | ||
534 | if (ep == dev->out_ep) | ||
535 | check_read_data(dev, ep, req); | ||
536 | free_ep_req(ep, req); | ||
537 | return; | ||
538 | |||
539 | case -EOVERFLOW: /* buffer overrun on read means that | ||
540 | * we didn't provide a big enough | ||
541 | * buffer. | ||
542 | */ | ||
543 | default: | ||
544 | #if 1 | ||
545 | DBG(dev, "%s complete --> %d, %d/%d\n", ep->name, | ||
546 | status, req->actual, req->length); | ||
547 | #endif | ||
548 | case -EREMOTEIO: /* short read */ | ||
549 | break; | ||
550 | } | ||
551 | |||
552 | status = usb_ep_queue(ep, req, GFP_ATOMIC); | ||
553 | if (status) { | ||
554 | ERROR(dev, "kill %s: resubmit %d bytes --> %d\n", | ||
555 | ep->name, req->length, status); | ||
556 | usb_ep_set_halt(ep); | ||
557 | /* FIXME recover later ... somehow */ | ||
558 | } | ||
559 | } | ||
560 | |||
561 | static struct usb_request *source_sink_start_ep(struct usb_ep *ep) | ||
562 | { | ||
563 | struct usb_request *req; | ||
564 | int status; | ||
565 | |||
566 | req = alloc_ep_req(ep, buflen); | ||
567 | if (!req) | ||
568 | return NULL; | ||
569 | |||
570 | memset(req->buf, 0, req->length); | ||
571 | req->complete = source_sink_complete; | ||
572 | |||
573 | if (strcmp(ep->name, EP_IN_NAME) == 0) | ||
574 | reinit_write_data(ep, req); | ||
575 | else | ||
576 | memset(req->buf, 0x55, req->length); | ||
577 | |||
578 | status = usb_ep_queue(ep, req, GFP_ATOMIC); | ||
579 | if (status) { | ||
580 | struct zero_dev *dev = ep->driver_data; | ||
581 | |||
582 | ERROR(dev, "start %s --> %d\n", ep->name, status); | ||
583 | free_ep_req(ep, req); | ||
584 | req = NULL; | ||
585 | } | ||
586 | |||
587 | return req; | ||
588 | } | ||
589 | |||
590 | static int set_source_sink_config(struct zero_dev *dev) | ||
591 | { | ||
592 | int result = 0; | ||
593 | struct usb_ep *ep; | ||
594 | struct usb_gadget *gadget = dev->gadget; | ||
595 | |||
596 | gadget_for_each_ep(ep, gadget) { | ||
597 | const struct usb_endpoint_descriptor *d; | ||
598 | |||
599 | /* one endpoint writes (sources) zeroes in (to the host) */ | ||
600 | if (strcmp(ep->name, EP_IN_NAME) == 0) { | ||
601 | d = ep_desc(gadget, &hs_source_desc, &fs_source_desc); | ||
602 | result = usb_ep_enable(ep, d); | ||
603 | if (result == 0) { | ||
604 | ep->driver_data = dev; | ||
605 | if (source_sink_start_ep(ep) != NULL) { | ||
606 | dev->in_ep = ep; | ||
607 | continue; | ||
608 | } | ||
609 | usb_ep_disable(ep); | ||
610 | result = -EIO; | ||
611 | } | ||
612 | |||
613 | /* one endpoint reads (sinks) anything out (from the host) */ | ||
614 | } else if (strcmp(ep->name, EP_OUT_NAME) == 0) { | ||
615 | d = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc); | ||
616 | result = usb_ep_enable(ep, d); | ||
617 | if (result == 0) { | ||
618 | ep->driver_data = dev; | ||
619 | if (source_sink_start_ep(ep) != NULL) { | ||
620 | dev->out_ep = ep; | ||
621 | continue; | ||
622 | } | ||
623 | usb_ep_disable(ep); | ||
624 | result = -EIO; | ||
625 | } | ||
626 | |||
627 | /* ignore any other endpoints */ | ||
628 | } else | ||
629 | continue; | ||
630 | |||
631 | /* stop on error */ | ||
632 | ERROR(dev, "can't start %s, result %d\n", ep->name, result); | ||
633 | break; | ||
634 | } | ||
635 | if (result == 0) | ||
636 | DBG(dev, "buflen %d\n", buflen); | ||
637 | |||
638 | /* caller is responsible for cleanup on error */ | ||
639 | return result; | ||
640 | } | ||
641 | |||
642 | /*-------------------------------------------------------------------------*/ | ||
643 | |||
644 | static void loopback_complete(struct usb_ep *ep, struct usb_request *req) | ||
645 | { | ||
646 | struct zero_dev *dev = ep->driver_data; | ||
647 | int status = req->status; | ||
648 | |||
649 | switch (status) { | ||
650 | |||
651 | case 0: /* normal completion? */ | ||
652 | if (ep == dev->out_ep) { | ||
653 | /* loop this OUT packet back IN to the host */ | ||
654 | req->zero = (req->actual < req->length); | ||
655 | req->length = req->actual; | ||
656 | status = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC); | ||
657 | if (status == 0) | ||
658 | return; | ||
659 | |||
660 | /* "should never get here" */ | ||
661 | ERROR(dev, "can't loop %s to %s: %d\n", | ||
662 | ep->name, dev->in_ep->name, | ||
663 | status); | ||
664 | } | ||
665 | |||
666 | /* queue the buffer for some later OUT packet */ | ||
667 | req->length = buflen; | ||
668 | status = usb_ep_queue(dev->out_ep, req, GFP_ATOMIC); | ||
669 | if (status == 0) | ||
670 | return; | ||
671 | |||
672 | /* "should never get here" */ | ||
673 | /* FALLTHROUGH */ | ||
674 | |||
675 | default: | ||
676 | ERROR(dev, "%s loop complete --> %d, %d/%d\n", ep->name, | ||
677 | status, req->actual, req->length); | ||
678 | /* FALLTHROUGH */ | ||
679 | |||
680 | /* NOTE: since this driver doesn't maintain an explicit record | ||
681 | * of requests it submitted (just maintains qlen count), we | ||
682 | * rely on the hardware driver to clean up on disconnect or | ||
683 | * endpoint disable. | ||
684 | */ | ||
685 | case -ECONNABORTED: /* hardware forced ep reset */ | ||
686 | case -ECONNRESET: /* request dequeued */ | ||
687 | case -ESHUTDOWN: /* disconnect from host */ | ||
688 | free_ep_req(ep, req); | ||
689 | return; | ||
690 | } | ||
691 | } | ||
692 | |||
693 | static int set_loopback_config(struct zero_dev *dev) | ||
694 | { | ||
695 | int result = 0; | ||
696 | struct usb_ep *ep; | ||
697 | struct usb_gadget *gadget = dev->gadget; | ||
698 | |||
699 | gadget_for_each_ep(ep, gadget) { | ||
700 | const struct usb_endpoint_descriptor *d; | ||
701 | |||
702 | /* one endpoint writes data back IN to the host */ | ||
703 | if (strcmp(ep->name, EP_IN_NAME) == 0) { | ||
704 | d = ep_desc(gadget, &hs_source_desc, &fs_source_desc); | ||
705 | result = usb_ep_enable(ep, d); | ||
706 | if (result == 0) { | ||
707 | ep->driver_data = dev; | ||
708 | dev->in_ep = ep; | ||
709 | continue; | ||
710 | } | ||
711 | |||
712 | /* one endpoint just reads OUT packets */ | ||
713 | } else if (strcmp(ep->name, EP_OUT_NAME) == 0) { | ||
714 | d = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc); | ||
715 | result = usb_ep_enable(ep, d); | ||
716 | if (result == 0) { | ||
717 | ep->driver_data = dev; | ||
718 | dev->out_ep = ep; | ||
719 | continue; | ||
720 | } | ||
721 | |||
722 | /* ignore any other endpoints */ | ||
723 | } else | ||
724 | continue; | ||
725 | |||
726 | /* stop on error */ | ||
727 | ERROR(dev, "can't enable %s, result %d\n", ep->name, result); | ||
728 | break; | ||
729 | } | ||
730 | |||
731 | /* allocate a bunch of read buffers and queue them all at once. | ||
732 | * we buffer at most 'qlen' transfers; fewer if any need more | ||
733 | * than 'buflen' bytes each. | ||
734 | */ | ||
735 | if (result == 0) { | ||
736 | struct usb_request *req; | ||
737 | unsigned i; | ||
738 | |||
739 | ep = dev->out_ep; | ||
740 | for (i = 0; i < qlen && result == 0; i++) { | ||
741 | req = alloc_ep_req(ep, buflen); | ||
742 | if (req) { | ||
743 | req->complete = loopback_complete; | ||
744 | result = usb_ep_queue(ep, req, GFP_ATOMIC); | ||
745 | if (result) | ||
746 | DBG(dev, "%s queue req --> %d\n", | ||
747 | ep->name, result); | ||
748 | } else | ||
749 | result = -ENOMEM; | ||
750 | } | ||
751 | } | ||
752 | if (result == 0) | ||
753 | DBG(dev, "qlen %d, buflen %d\n", qlen, buflen); | ||
754 | |||
755 | /* caller is responsible for cleanup on error */ | ||
756 | return result; | ||
757 | } | ||
758 | |||
759 | /*-------------------------------------------------------------------------*/ | ||
760 | |||
761 | static void zero_reset_config(struct zero_dev *dev) | ||
762 | { | ||
763 | if (dev->config == 0) | ||
764 | return; | ||
765 | |||
766 | DBG(dev, "reset config\n"); | ||
767 | |||
768 | /* just disable endpoints, forcing completion of pending i/o. | ||
769 | * all our completion handlers free their requests in this case. | ||
770 | */ | ||
771 | if (dev->in_ep) { | ||
772 | usb_ep_disable(dev->in_ep); | ||
773 | dev->in_ep = NULL; | ||
774 | } | ||
775 | if (dev->out_ep) { | ||
776 | usb_ep_disable(dev->out_ep); | ||
777 | dev->out_ep = NULL; | ||
778 | } | ||
779 | dev->config = 0; | ||
780 | del_timer(&dev->resume); | ||
781 | } | ||
782 | |||
783 | /* change our operational config. this code must agree with the code | ||
784 | * that returns config descriptors, and altsetting code. | ||
785 | * | ||
786 | * it's also responsible for power management interactions. some | ||
787 | * configurations might not work with our current power sources. | ||
788 | * | ||
789 | * note that some device controller hardware will constrain what this | ||
790 | * code can do, perhaps by disallowing more than one configuration or | ||
791 | * by limiting configuration choices (like the pxa2xx). | ||
792 | */ | ||
793 | static int zero_set_config(struct zero_dev *dev, unsigned number) | ||
794 | { | ||
795 | int result = 0; | ||
796 | struct usb_gadget *gadget = dev->gadget; | ||
797 | |||
798 | if (number == dev->config) | ||
799 | return 0; | ||
800 | |||
801 | if (gadget_is_sa1100(gadget) && dev->config) { | ||
802 | /* tx fifo is full, but we can't clear it...*/ | ||
803 | ERROR(dev, "can't change configurations\n"); | ||
804 | return -ESPIPE; | ||
805 | } | ||
806 | zero_reset_config(dev); | ||
807 | |||
808 | switch (number) { | ||
809 | case CONFIG_SOURCE_SINK: | ||
810 | result = set_source_sink_config(dev); | ||
811 | break; | ||
812 | case CONFIG_LOOPBACK: | ||
813 | result = set_loopback_config(dev); | ||
814 | break; | ||
815 | default: | ||
816 | result = -EINVAL; | ||
817 | /* FALL THROUGH */ | ||
818 | case 0: | ||
819 | return result; | ||
820 | } | ||
821 | |||
822 | if (!result && (!dev->in_ep || !dev->out_ep)) | ||
823 | result = -ENODEV; | ||
824 | if (result) | ||
825 | zero_reset_config(dev); | ||
826 | else { | ||
827 | char *speed; | ||
828 | |||
829 | switch (gadget->speed) { | ||
830 | case USB_SPEED_LOW: speed = "low"; break; | ||
831 | case USB_SPEED_FULL: speed = "full"; break; | ||
832 | case USB_SPEED_HIGH: speed = "high"; break; | ||
833 | default: speed = "?"; break; | ||
834 | } | ||
835 | |||
836 | dev->config = number; | ||
837 | INFO(dev, "%s speed config #%d: %s\n", speed, number, | ||
838 | (number == CONFIG_SOURCE_SINK) | ||
839 | ? source_sink : loopback); | ||
840 | } | ||
841 | return result; | ||
842 | } | ||
843 | |||
844 | /*-------------------------------------------------------------------------*/ | ||
845 | |||
846 | static void zero_setup_complete(struct usb_ep *ep, struct usb_request *req) | ||
847 | { | ||
848 | if (req->status || req->actual != req->length) | ||
849 | DBG((struct zero_dev *) ep->driver_data, | ||
850 | "setup complete --> %d, %d/%d\n", | ||
851 | req->status, req->actual, req->length); | ||
852 | } | ||
853 | |||
854 | /* | ||
855 | * The setup() callback implements all the ep0 functionality that's | ||
856 | * not handled lower down, in hardware or the hardware driver (like | ||
857 | * device and endpoint feature flags, and their status). It's all | ||
858 | * housekeeping for the gadget function we're implementing. Most of | ||
859 | * the work is in config-specific setup. | ||
860 | */ | ||
861 | static int | ||
862 | zero_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl) | ||
863 | { | ||
864 | struct zero_dev *dev = get_gadget_data(gadget); | ||
865 | struct usb_request *req = dev->req; | ||
866 | int value = -EOPNOTSUPP; | ||
867 | u16 w_index = le16_to_cpu(ctrl->wIndex); | ||
868 | u16 w_value = le16_to_cpu(ctrl->wValue); | ||
869 | u16 w_length = le16_to_cpu(ctrl->wLength); | ||
870 | |||
871 | /* usually this stores reply data in the pre-allocated ep0 buffer, | ||
872 | * but config change events will reconfigure hardware. | ||
873 | */ | ||
874 | req->zero = 0; | ||
875 | switch (ctrl->bRequest) { | ||
876 | |||
877 | case USB_REQ_GET_DESCRIPTOR: | ||
878 | if (ctrl->bRequestType != USB_DIR_IN) | ||
879 | goto unknown; | ||
880 | switch (w_value >> 8) { | ||
881 | |||
882 | case USB_DT_DEVICE: | ||
883 | value = min(w_length, (u16) sizeof device_desc); | ||
884 | memcpy(req->buf, &device_desc, value); | ||
885 | break; | ||
886 | case USB_DT_DEVICE_QUALIFIER: | ||
887 | if (!gadget_is_dualspeed(gadget)) | ||
888 | break; | ||
889 | value = min(w_length, (u16) sizeof dev_qualifier); | ||
890 | memcpy(req->buf, &dev_qualifier, value); | ||
891 | break; | ||
892 | |||
893 | case USB_DT_OTHER_SPEED_CONFIG: | ||
894 | if (!gadget_is_dualspeed(gadget)) | ||
895 | break; | ||
896 | // FALLTHROUGH | ||
897 | case USB_DT_CONFIG: | ||
898 | value = config_buf(gadget, req->buf, | ||
899 | w_value >> 8, | ||
900 | w_value & 0xff); | ||
901 | if (value >= 0) | ||
902 | value = min(w_length, (u16) value); | ||
903 | break; | ||
904 | |||
905 | case USB_DT_STRING: | ||
906 | /* wIndex == language code. | ||
907 | * this driver only handles one language, you can | ||
908 | * add string tables for other languages, using | ||
909 | * any UTF-8 characters | ||
910 | */ | ||
911 | value = usb_gadget_get_string(&stringtab, | ||
912 | w_value & 0xff, req->buf); | ||
913 | if (value >= 0) | ||
914 | value = min(w_length, (u16) value); | ||
915 | break; | ||
916 | } | ||
917 | break; | ||
918 | |||
919 | /* currently two configs, two speeds */ | ||
920 | case USB_REQ_SET_CONFIGURATION: | ||
921 | if (ctrl->bRequestType != 0) | ||
922 | goto unknown; | ||
923 | if (gadget->a_hnp_support) | ||
924 | DBG(dev, "HNP available\n"); | ||
925 | else if (gadget->a_alt_hnp_support) | ||
926 | DBG(dev, "HNP needs a different root port\n"); | ||
927 | else | ||
928 | VDBG(dev, "HNP inactive\n"); | ||
929 | spin_lock(&dev->lock); | ||
930 | value = zero_set_config(dev, w_value); | ||
931 | spin_unlock(&dev->lock); | ||
932 | break; | ||
933 | case USB_REQ_GET_CONFIGURATION: | ||
934 | if (ctrl->bRequestType != USB_DIR_IN) | ||
935 | goto unknown; | ||
936 | *(u8 *)req->buf = dev->config; | ||
937 | value = min(w_length, (u16) 1); | ||
938 | break; | ||
939 | |||
940 | /* until we add altsetting support, or other interfaces, | ||
941 | * only 0/0 are possible. pxa2xx only supports 0/0 (poorly) | ||
942 | * and already killed pending endpoint I/O. | ||
943 | */ | ||
944 | case USB_REQ_SET_INTERFACE: | ||
945 | if (ctrl->bRequestType != USB_RECIP_INTERFACE) | ||
946 | goto unknown; | ||
947 | spin_lock(&dev->lock); | ||
948 | if (dev->config && w_index == 0 && w_value == 0) { | ||
949 | u8 config = dev->config; | ||
950 | |||
951 | /* resets interface configuration, forgets about | ||
952 | * previous transaction state (queued bufs, etc) | ||
953 | * and re-inits endpoint state (toggle etc) | ||
954 | * no response queued, just zero status == success. | ||
955 | * if we had more than one interface we couldn't | ||
956 | * use this "reset the config" shortcut. | ||
957 | */ | ||
958 | zero_reset_config(dev); | ||
959 | zero_set_config(dev, config); | ||
960 | value = 0; | ||
961 | } | ||
962 | spin_unlock(&dev->lock); | ||
963 | break; | ||
964 | case USB_REQ_GET_INTERFACE: | ||
965 | if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)) | ||
966 | goto unknown; | ||
967 | if (!dev->config) | ||
968 | break; | ||
969 | if (w_index != 0) { | ||
970 | value = -EDOM; | ||
971 | break; | ||
972 | } | ||
973 | *(u8 *)req->buf = 0; | ||
974 | value = min(w_length, (u16) 1); | ||
975 | break; | ||
976 | |||
977 | /* | ||
978 | * These are the same vendor-specific requests supported by | ||
979 | * Intel's USB 2.0 compliance test devices. We exceed that | ||
980 | * device spec by allowing multiple-packet requests. | ||
981 | */ | ||
982 | case 0x5b: /* control WRITE test -- fill the buffer */ | ||
983 | if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR)) | ||
984 | goto unknown; | ||
985 | if (w_value || w_index) | ||
986 | break; | ||
987 | /* just read that many bytes into the buffer */ | ||
988 | if (w_length > USB_BUFSIZ) | ||
989 | break; | ||
990 | value = w_length; | ||
991 | break; | ||
992 | case 0x5c: /* control READ test -- return the buffer */ | ||
993 | if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR)) | ||
994 | goto unknown; | ||
995 | if (w_value || w_index) | ||
996 | break; | ||
997 | /* expect those bytes are still in the buffer; send back */ | ||
998 | if (w_length > USB_BUFSIZ | ||
999 | || w_length != req->length) | ||
1000 | break; | ||
1001 | value = w_length; | ||
1002 | break; | ||
1003 | |||
1004 | default: | ||
1005 | unknown: | ||
1006 | VDBG(dev, | ||
1007 | "unknown control req%02x.%02x v%04x i%04x l%d\n", | ||
1008 | ctrl->bRequestType, ctrl->bRequest, | ||
1009 | w_value, w_index, w_length); | ||
1010 | } | ||
1011 | |||
1012 | /* respond with data transfer before status phase? */ | ||
1013 | if (value >= 0) { | ||
1014 | req->length = value; | ||
1015 | req->zero = value < w_length; | ||
1016 | value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC); | ||
1017 | if (value < 0) { | ||
1018 | DBG(dev, "ep_queue --> %d\n", value); | ||
1019 | req->status = 0; | ||
1020 | zero_setup_complete(gadget->ep0, req); | ||
1021 | } | ||
1022 | } | ||
1023 | |||
1024 | /* device either stalls (value < 0) or reports success */ | ||
1025 | return value; | ||
1026 | } | ||
1027 | |||
1028 | static void zero_disconnect(struct usb_gadget *gadget) | ||
1029 | { | ||
1030 | struct zero_dev *dev = get_gadget_data(gadget); | ||
1031 | unsigned long flags; | ||
1032 | |||
1033 | spin_lock_irqsave(&dev->lock, flags); | ||
1034 | zero_reset_config(dev); | ||
1035 | |||
1036 | /* a more significant application might have some non-usb | ||
1037 | * activities to quiesce here, saving resources like power | ||
1038 | * or pushing the notification up a network stack. | ||
1039 | */ | ||
1040 | spin_unlock_irqrestore(&dev->lock, flags); | ||
1041 | |||
1042 | /* next we may get setup() calls to enumerate new connections; | ||
1043 | * or an unbind() during shutdown (including removing module). | ||
1044 | */ | ||
1045 | } | ||
1046 | |||
1047 | static void zero_autoresume(unsigned long _dev) | ||
1048 | { | ||
1049 | struct zero_dev *dev = (struct zero_dev *) _dev; | ||
1050 | int status; | ||
1051 | |||
1052 | /* normally the host would be woken up for something | ||
1053 | * more significant than just a timer firing... | ||
1054 | */ | ||
1055 | if (dev->gadget->speed != USB_SPEED_UNKNOWN) { | ||
1056 | status = usb_gadget_wakeup(dev->gadget); | ||
1057 | DBG(dev, "wakeup --> %d\n", status); | ||
1058 | } | ||
1059 | } | 194 | } |
1060 | 195 | ||
1061 | /*-------------------------------------------------------------------------*/ | 196 | /*-------------------------------------------------------------------------*/ |
1062 | 197 | ||
1063 | static void zero_unbind(struct usb_gadget *gadget) | 198 | static int __init zero_bind(struct usb_composite_dev *cdev) |
1064 | { | 199 | { |
1065 | struct zero_dev *dev = get_gadget_data(gadget); | ||
1066 | |||
1067 | DBG(dev, "unbind\n"); | ||
1068 | |||
1069 | /* we've already been disconnected ... no i/o is active */ | ||
1070 | if (dev->req) { | ||
1071 | dev->req->length = USB_BUFSIZ; | ||
1072 | free_ep_req(gadget->ep0, dev->req); | ||
1073 | } | ||
1074 | del_timer_sync(&dev->resume); | ||
1075 | kfree(dev); | ||
1076 | set_gadget_data(gadget, NULL); | ||
1077 | } | ||
1078 | |||
1079 | static int __init zero_bind(struct usb_gadget *gadget) | ||
1080 | { | ||
1081 | struct zero_dev *dev; | ||
1082 | struct usb_ep *ep; | ||
1083 | int gcnum; | 200 | int gcnum; |
201 | struct usb_gadget *gadget = cdev->gadget; | ||
202 | int id; | ||
1084 | 203 | ||
1085 | /* FIXME this can't yet work right with SH ... it has only | 204 | /* Allocate string descriptor numbers ... note that string |
1086 | * one configuration, numbered one. | 205 | * contents can be overridden by the composite_dev glue. |
1087 | */ | 206 | */ |
1088 | if (gadget_is_sh(gadget)) | 207 | id = usb_string_id(cdev); |
1089 | return -ENODEV; | 208 | if (id < 0) |
1090 | 209 | return id; | |
1091 | /* Bulk-only drivers like this one SHOULD be able to | 210 | strings_dev[STRING_MANUFACTURER_IDX].id = id; |
1092 | * autoconfigure on any sane usb controller driver, | 211 | device_desc.iManufacturer = id; |
1093 | * but there may also be important quirks to address. | 212 | |
213 | id = usb_string_id(cdev); | ||
214 | if (id < 0) | ||
215 | return id; | ||
216 | strings_dev[STRING_PRODUCT_IDX].id = id; | ||
217 | device_desc.iProduct = id; | ||
218 | |||
219 | id = usb_string_id(cdev); | ||
220 | if (id < 0) | ||
221 | return id; | ||
222 | strings_dev[STRING_SERIAL_IDX].id = id; | ||
223 | device_desc.iSerialNumber = id; | ||
224 | |||
225 | /* Register primary, then secondary configuration. Note that | ||
226 | * SH3 only allows one config... | ||
1094 | */ | 227 | */ |
1095 | usb_ep_autoconfig_reset(gadget); | 228 | if (loopdefault) { |
1096 | ep = usb_ep_autoconfig(gadget, &fs_source_desc); | 229 | loopback_add(cdev); |
1097 | if (!ep) { | 230 | if (!gadget_is_sh(gadget)) |
1098 | autoconf_fail: | 231 | sourcesink_add(cdev); |
1099 | pr_err("%s: can't autoconfigure on %s\n", | 232 | } else { |
1100 | shortname, gadget->name); | 233 | sourcesink_add(cdev); |
1101 | return -ENODEV; | 234 | if (!gadget_is_sh(gadget)) |
235 | loopback_add(cdev); | ||
1102 | } | 236 | } |
1103 | EP_IN_NAME = ep->name; | ||
1104 | ep->driver_data = ep; /* claim */ | ||
1105 | |||
1106 | ep = usb_ep_autoconfig(gadget, &fs_sink_desc); | ||
1107 | if (!ep) | ||
1108 | goto autoconf_fail; | ||
1109 | EP_OUT_NAME = ep->name; | ||
1110 | ep->driver_data = ep; /* claim */ | ||
1111 | 237 | ||
1112 | gcnum = usb_gadget_controller_number(gadget); | 238 | gcnum = usb_gadget_controller_number(gadget); |
1113 | if (gcnum >= 0) | 239 | if (gcnum >= 0) |
@@ -1115,144 +241,44 @@ autoconf_fail: | |||
1115 | else { | 241 | else { |
1116 | /* gadget zero is so simple (for now, no altsettings) that | 242 | /* gadget zero is so simple (for now, no altsettings) that |
1117 | * it SHOULD NOT have problems with bulk-capable hardware. | 243 | * it SHOULD NOT have problems with bulk-capable hardware. |
1118 | * so warn about unrcognized controllers, don't panic. | 244 | * so just warn about unrcognized controllers -- don't panic. |
1119 | * | 245 | * |
1120 | * things like configuration and altsetting numbering | 246 | * things like configuration and altsetting numbering |
1121 | * can need hardware-specific attention though. | 247 | * can need hardware-specific attention though. |
1122 | */ | 248 | */ |
1123 | pr_warning("%s: controller '%s' not recognized\n", | 249 | pr_warning("%s: controller '%s' not recognized\n", |
1124 | shortname, gadget->name); | 250 | longname, gadget->name); |
1125 | device_desc.bcdDevice = __constant_cpu_to_le16(0x9999); | 251 | device_desc.bcdDevice = __constant_cpu_to_le16(0x9999); |
1126 | } | 252 | } |
1127 | 253 | ||
1128 | 254 | ||
1129 | /* ok, we made sense of the hardware ... */ | 255 | INFO(cdev, "%s, version: " DRIVER_VERSION "\n", longname); |
1130 | dev = kzalloc(sizeof(*dev), GFP_KERNEL); | ||
1131 | if (!dev) | ||
1132 | return -ENOMEM; | ||
1133 | spin_lock_init(&dev->lock); | ||
1134 | dev->gadget = gadget; | ||
1135 | set_gadget_data(gadget, dev); | ||
1136 | |||
1137 | init_timer(&dev->resume); | ||
1138 | dev->resume.function = zero_autoresume; | ||
1139 | dev->resume.data = (unsigned long) dev; | ||
1140 | |||
1141 | /* preallocate control response and buffer */ | ||
1142 | dev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL); | ||
1143 | if (!dev->req) | ||
1144 | goto enomem; | ||
1145 | dev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL); | ||
1146 | if (!dev->req->buf) | ||
1147 | goto enomem; | ||
1148 | |||
1149 | dev->req->complete = zero_setup_complete; | ||
1150 | |||
1151 | device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket; | ||
1152 | |||
1153 | if (gadget_is_dualspeed(gadget)) { | ||
1154 | /* assume ep0 uses the same value for both speeds ... */ | ||
1155 | dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0; | ||
1156 | |||
1157 | /* and that all endpoints are dual-speed */ | ||
1158 | hs_source_desc.bEndpointAddress = | ||
1159 | fs_source_desc.bEndpointAddress; | ||
1160 | hs_sink_desc.bEndpointAddress = | ||
1161 | fs_sink_desc.bEndpointAddress; | ||
1162 | } | ||
1163 | |||
1164 | if (gadget_is_otg(gadget)) { | ||
1165 | otg_descriptor.bmAttributes |= USB_OTG_HNP, | ||
1166 | source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP; | ||
1167 | loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP; | ||
1168 | } | ||
1169 | |||
1170 | usb_gadget_set_selfpowered(gadget); | ||
1171 | |||
1172 | if (autoresume) { | ||
1173 | source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP; | ||
1174 | loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP; | ||
1175 | } | ||
1176 | |||
1177 | gadget->ep0->driver_data = dev; | ||
1178 | |||
1179 | INFO(dev, "%s, version: " DRIVER_VERSION "\n", longname); | ||
1180 | INFO(dev, "using %s, OUT %s IN %s\n", gadget->name, | ||
1181 | EP_OUT_NAME, EP_IN_NAME); | ||
1182 | 256 | ||
1183 | snprintf(manufacturer, sizeof manufacturer, "%s %s with %s", | 257 | snprintf(manufacturer, sizeof manufacturer, "%s %s with %s", |
1184 | init_utsname()->sysname, init_utsname()->release, | 258 | init_utsname()->sysname, init_utsname()->release, |
1185 | gadget->name); | 259 | gadget->name); |
1186 | 260 | ||
1187 | return 0; | 261 | return 0; |
1188 | |||
1189 | enomem: | ||
1190 | zero_unbind(gadget); | ||
1191 | return -ENOMEM; | ||
1192 | } | 262 | } |
1193 | 263 | ||
1194 | /*-------------------------------------------------------------------------*/ | 264 | static struct usb_composite_driver zero_driver = { |
1195 | 265 | .name = "zero", | |
1196 | static void zero_suspend(struct usb_gadget *gadget) | 266 | .dev = &device_desc, |
1197 | { | 267 | .strings = dev_strings, |
1198 | struct zero_dev *dev = get_gadget_data(gadget); | ||
1199 | |||
1200 | if (gadget->speed == USB_SPEED_UNKNOWN) | ||
1201 | return; | ||
1202 | |||
1203 | if (autoresume) { | ||
1204 | mod_timer(&dev->resume, jiffies + (HZ * autoresume)); | ||
1205 | DBG(dev, "suspend, wakeup in %d seconds\n", autoresume); | ||
1206 | } else | ||
1207 | DBG(dev, "suspend\n"); | ||
1208 | } | ||
1209 | |||
1210 | static void zero_resume(struct usb_gadget *gadget) | ||
1211 | { | ||
1212 | struct zero_dev *dev = get_gadget_data(gadget); | ||
1213 | |||
1214 | DBG(dev, "resume\n"); | ||
1215 | del_timer(&dev->resume); | ||
1216 | } | ||
1217 | |||
1218 | |||
1219 | /*-------------------------------------------------------------------------*/ | ||
1220 | |||
1221 | static struct usb_gadget_driver zero_driver = { | ||
1222 | #ifdef CONFIG_USB_GADGET_DUALSPEED | ||
1223 | .speed = USB_SPEED_HIGH, | ||
1224 | #else | ||
1225 | .speed = USB_SPEED_FULL, | ||
1226 | #endif | ||
1227 | .function = (char *) longname, | ||
1228 | .bind = zero_bind, | 268 | .bind = zero_bind, |
1229 | .unbind = __exit_p(zero_unbind), | ||
1230 | |||
1231 | .setup = zero_setup, | ||
1232 | .disconnect = zero_disconnect, | ||
1233 | |||
1234 | .suspend = zero_suspend, | ||
1235 | .resume = zero_resume, | ||
1236 | |||
1237 | .driver = { | ||
1238 | .name = (char *) shortname, | ||
1239 | .owner = THIS_MODULE, | ||
1240 | }, | ||
1241 | }; | 269 | }; |
1242 | 270 | ||
1243 | MODULE_AUTHOR("David Brownell"); | 271 | MODULE_AUTHOR("David Brownell"); |
1244 | MODULE_LICENSE("GPL"); | 272 | MODULE_LICENSE("GPL"); |
1245 | 273 | ||
1246 | |||
1247 | static int __init init(void) | 274 | static int __init init(void) |
1248 | { | 275 | { |
1249 | return usb_gadget_register_driver(&zero_driver); | 276 | return usb_composite_register(&zero_driver); |
1250 | } | 277 | } |
1251 | module_init(init); | 278 | module_init(init); |
1252 | 279 | ||
1253 | static void __exit cleanup(void) | 280 | static void __exit cleanup(void) |
1254 | { | 281 | { |
1255 | usb_gadget_unregister_driver(&zero_driver); | 282 | usb_composite_unregister(&zero_driver); |
1256 | } | 283 | } |
1257 | module_exit(cleanup); | 284 | module_exit(cleanup); |
1258 | |||