1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42#include <linux/kernel.h>
43#include <linux/slab.h>
44#include <linux/device.h>
45#include <linux/module.h>
46#include <linux/err.h>
47#include <linux/usb/composite.h>
48
49#include "g_zero.h"
50
51USB_GADGET_COMPOSITE_OPTIONS();
52
53#define DRIVER_VERSION "Cinco de Mayo 2008"
54
55static const char longname[] = "Gadget Zero";
56
57
58
59
60
61
62
63static bool loopdefault = 0;
64module_param(loopdefault, bool, S_IRUGO|S_IWUSR);
65
66static struct usb_zero_options gzero_options = {
67 .isoc_interval = 4,
68 .isoc_maxpacket = 1024,
69 .bulk_buflen = 4096,
70 .qlen = 32,
71};
72
73
74
75
76
77
78
79
80#ifndef CONFIG_USB_ZERO_HNPTEST
81#define DRIVER_VENDOR_NUM 0x0525
82#define DRIVER_PRODUCT_NUM 0xa4a0
83#define DEFAULT_AUTORESUME 0
84#else
85#define DRIVER_VENDOR_NUM 0x1a0a
86#define DRIVER_PRODUCT_NUM 0xbadd
87#define DEFAULT_AUTORESUME 5
88#endif
89
90
91
92
93
94unsigned autoresume = DEFAULT_AUTORESUME;
95module_param(autoresume, uint, S_IRUGO);
96MODULE_PARM_DESC(autoresume, "zero, or seconds before remote wakeup");
97
98
99
100static struct usb_device_descriptor device_desc = {
101 .bLength = sizeof device_desc,
102 .bDescriptorType = USB_DT_DEVICE,
103
104 .bcdUSB = cpu_to_le16(0x0200),
105 .bDeviceClass = USB_CLASS_VENDOR_SPEC,
106
107 .idVendor = cpu_to_le16(DRIVER_VENDOR_NUM),
108 .idProduct = cpu_to_le16(DRIVER_PRODUCT_NUM),
109 .bNumConfigurations = 2,
110};
111
112#ifdef CONFIG_USB_OTG
113static struct usb_otg_descriptor otg_descriptor = {
114 .bLength = sizeof otg_descriptor,
115 .bDescriptorType = USB_DT_OTG,
116
117
118
119
120 .bmAttributes = USB_OTG_SRP | USB_OTG_HNP,
121};
122
123static const struct usb_descriptor_header *otg_desc[] = {
124 (struct usb_descriptor_header *) &otg_descriptor,
125 NULL,
126};
127#else
128#define otg_desc NULL
129#endif
130
131
132
133static char serial[] = "0123456789.0123456789.0123456789";
134
135#define USB_GZERO_SS_DESC (USB_GADGET_FIRST_AVAIL_IDX + 0)
136#define USB_GZERO_LB_DESC (USB_GADGET_FIRST_AVAIL_IDX + 1)
137
138static struct usb_string strings_dev[] = {
139 [USB_GADGET_MANUFACTURER_IDX].s = "",
140 [USB_GADGET_PRODUCT_IDX].s = longname,
141 [USB_GADGET_SERIAL_IDX].s = serial,
142 [USB_GZERO_SS_DESC].s = "source and sink data",
143 [USB_GZERO_LB_DESC].s = "loop input to output",
144 { }
145};
146
147static struct usb_gadget_strings stringtab_dev = {
148 .language = 0x0409,
149 .strings = strings_dev,
150};
151
152static struct usb_gadget_strings *dev_strings[] = {
153 &stringtab_dev,
154 NULL,
155};
156
157
158
159static struct timer_list autoresume_timer;
160
161static void zero_autoresume(unsigned long _c)
162{
163 struct usb_composite_dev *cdev = (void *)_c;
164 struct usb_gadget *g = cdev->gadget;
165
166
167 if (!cdev->config)
168 return;
169
170
171
172
173
174 if (g->speed != USB_SPEED_UNKNOWN) {
175 int status = usb_gadget_wakeup(g);
176 INFO(cdev, "%s --> %d\n", __func__, status);
177 }
178}
179
180static void zero_suspend(struct usb_composite_dev *cdev)
181{
182 if (cdev->gadget->speed == USB_SPEED_UNKNOWN)
183 return;
184
185 if (autoresume) {
186 mod_timer(&autoresume_timer, jiffies + (HZ * autoresume));
187 DBG(cdev, "suspend, wakeup in %d seconds\n", autoresume);
188 } else
189 DBG(cdev, "%s\n", __func__);
190}
191
192static void zero_resume(struct usb_composite_dev *cdev)
193{
194 DBG(cdev, "%s\n", __func__);
195 del_timer(&autoresume_timer);
196}
197
198
199
200static struct usb_configuration loopback_driver = {
201 .label = "loopback",
202 .bConfigurationValue = 2,
203 .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
204
205};
206
207static struct usb_function *func_ss;
208static struct usb_function_instance *func_inst_ss;
209
210static int ss_config_setup(struct usb_configuration *c,
211 const struct usb_ctrlrequest *ctrl)
212{
213 switch (ctrl->bRequest) {
214 case 0x5b:
215 case 0x5c:
216 return func_ss->setup(func_ss, ctrl);
217 default:
218 return -EOPNOTSUPP;
219 }
220}
221
222static struct usb_configuration sourcesink_driver = {
223 .label = "source/sink",
224 .setup = ss_config_setup,
225 .bConfigurationValue = 3,
226 .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
227
228};
229
230module_param_named(buflen, gzero_options.bulk_buflen, uint, 0);
231module_param_named(pattern, gzero_options.pattern, uint, S_IRUGO|S_IWUSR);
232MODULE_PARM_DESC(pattern, "0 = all zeroes, 1 = mod63, 2 = none");
233
234module_param_named(isoc_interval, gzero_options.isoc_interval, uint,
235 S_IRUGO|S_IWUSR);
236MODULE_PARM_DESC(isoc_interval, "1 - 16");
237
238module_param_named(isoc_maxpacket, gzero_options.isoc_maxpacket, uint,
239 S_IRUGO|S_IWUSR);
240MODULE_PARM_DESC(isoc_maxpacket, "0 - 1023 (fs), 0 - 1024 (hs/ss)");
241
242module_param_named(isoc_mult, gzero_options.isoc_mult, uint, S_IRUGO|S_IWUSR);
243MODULE_PARM_DESC(isoc_mult, "0 - 2 (hs/ss only)");
244
245module_param_named(isoc_maxburst, gzero_options.isoc_maxburst, uint,
246 S_IRUGO|S_IWUSR);
247MODULE_PARM_DESC(isoc_maxburst, "0 - 15 (ss only)");
248
249static struct usb_function *func_lb;
250static struct usb_function_instance *func_inst_lb;
251
252module_param_named(qlen, gzero_options.qlen, uint, S_IRUGO|S_IWUSR);
253MODULE_PARM_DESC(qlen, "depth of loopback queue");
254
255static int __init zero_bind(struct usb_composite_dev *cdev)
256{
257 struct f_ss_opts *ss_opts;
258 struct f_lb_opts *lb_opts;
259 int status;
260
261
262
263
264 status = usb_string_ids_tab(cdev, strings_dev);
265 if (status < 0)
266 return status;
267
268 device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
269 device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
270 device_desc.iSerialNumber = strings_dev[USB_GADGET_SERIAL_IDX].id;
271
272 setup_timer(&autoresume_timer, zero_autoresume, (unsigned long) cdev);
273
274 func_inst_ss = usb_get_function_instance("SourceSink");
275 if (IS_ERR(func_inst_ss))
276 return PTR_ERR(func_inst_ss);
277
278 ss_opts = container_of(func_inst_ss, struct f_ss_opts, func_inst);
279 ss_opts->pattern = gzero_options.pattern;
280 ss_opts->isoc_interval = gzero_options.isoc_interval;
281 ss_opts->isoc_maxpacket = gzero_options.isoc_maxpacket;
282 ss_opts->isoc_mult = gzero_options.isoc_mult;
283 ss_opts->isoc_maxburst = gzero_options.isoc_maxpacket;
284 ss_opts->bulk_buflen = gzero_options.bulk_buflen;
285
286 func_ss = usb_get_function(func_inst_ss);
287 if (IS_ERR(func_ss)) {
288 status = PTR_ERR(func_ss);
289 goto err_put_func_inst_ss;
290 }
291
292 func_inst_lb = usb_get_function_instance("Loopback");
293 if (IS_ERR(func_inst_lb)) {
294 status = PTR_ERR(func_inst_lb);
295 goto err_put_func_ss;
296 }
297
298 lb_opts = container_of(func_inst_lb, struct f_lb_opts, func_inst);
299 lb_opts->bulk_buflen = gzero_options.bulk_buflen;
300 lb_opts->qlen = gzero_options.qlen;
301
302 func_lb = usb_get_function(func_inst_lb);
303 if (IS_ERR(func_lb)) {
304 status = PTR_ERR(func_lb);
305 goto err_put_func_inst_lb;
306 }
307
308 sourcesink_driver.iConfiguration = strings_dev[USB_GZERO_SS_DESC].id;
309 loopback_driver.iConfiguration = strings_dev[USB_GZERO_LB_DESC].id;
310
311
312 sourcesink_driver.bmAttributes &= ~USB_CONFIG_ATT_WAKEUP;
313 loopback_driver.bmAttributes &= ~USB_CONFIG_ATT_WAKEUP;
314 sourcesink_driver.descriptors = NULL;
315 loopback_driver.descriptors = NULL;
316 if (autoresume) {
317 sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
318 loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
319 }
320
321
322 if (gadget_is_otg(cdev->gadget)) {
323 sourcesink_driver.descriptors = otg_desc;
324 sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
325 loopback_driver.descriptors = otg_desc;
326 loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
327 }
328
329
330
331
332 if (loopdefault) {
333 usb_add_config_only(cdev, &loopback_driver);
334 usb_add_config_only(cdev, &sourcesink_driver);
335 } else {
336 usb_add_config_only(cdev, &sourcesink_driver);
337 usb_add_config_only(cdev, &loopback_driver);
338 }
339 status = usb_add_function(&sourcesink_driver, func_ss);
340 if (status)
341 goto err_conf_flb;
342
343 usb_ep_autoconfig_reset(cdev->gadget);
344 status = usb_add_function(&loopback_driver, func_lb);
345 if (status)
346 goto err_conf_flb;
347
348 usb_ep_autoconfig_reset(cdev->gadget);
349 usb_composite_overwrite_options(cdev, &coverwrite);
350
351 INFO(cdev, "%s, version: " DRIVER_VERSION "\n", longname);
352
353 return 0;
354
355err_conf_flb:
356 usb_put_function(func_lb);
357 func_lb = NULL;
358err_put_func_inst_lb:
359 usb_put_function_instance(func_inst_lb);
360 func_inst_lb = NULL;
361err_put_func_ss:
362 usb_put_function(func_ss);
363 func_ss = NULL;
364err_put_func_inst_ss:
365 usb_put_function_instance(func_inst_ss);
366 func_inst_ss = NULL;
367 return status;
368}
369
370static int zero_unbind(struct usb_composite_dev *cdev)
371{
372 del_timer_sync(&autoresume_timer);
373 if (!IS_ERR_OR_NULL(func_ss))
374 usb_put_function(func_ss);
375 usb_put_function_instance(func_inst_ss);
376 if (!IS_ERR_OR_NULL(func_lb))
377 usb_put_function(func_lb);
378 usb_put_function_instance(func_inst_lb);
379 return 0;
380}
381
382static __refdata struct usb_composite_driver zero_driver = {
383 .name = "zero",
384 .dev = &device_desc,
385 .strings = dev_strings,
386 .max_speed = USB_SPEED_SUPER,
387 .bind = zero_bind,
388 .unbind = zero_unbind,
389 .suspend = zero_suspend,
390 .resume = zero_resume,
391};
392
393MODULE_AUTHOR("David Brownell");
394MODULE_LICENSE("GPL");
395
396static int __init init(void)
397{
398 return usb_composite_probe(&zero_driver);
399}
400module_init(init);
401
402static void __exit cleanup(void)
403{
404 usb_composite_unregister(&zero_driver);
405}
406module_exit(cleanup);
407