projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'iommu-fixes-v4.0-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git...
[deliverable/linux.git] / drivers / usb / gadget / function / f_sourcesink.c
1 /*
2 * f_sourcesink.c - USB peripheral source/sink configuration driver
3 *
4 * Copyright (C) 2003-2008 David Brownell
5 * Copyright (C) 2008 by Nokia Corporation
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
13 /* #define VERBOSE_DEBUG */
14
15 #include <linux/slab.h>
16 #include <linux/kernel.h>
17 #include <linux/device.h>
18 #include <linux/module.h>
19 #include <linux/usb/composite.h>
20 #include <linux/err.h>
21
22 #include "g_zero.h"
23 #include "gadget_chips.h"
24 #include "u_f.h"
25
26 #define USB_MS_TO_SS_INTERVAL(x) USB_MS_TO_HS_INTERVAL(x)
27
28 enum eptype {
29 EP_CONTROL = 0,
30 EP_BULK,
31 EP_ISOC,
32 EP_INTERRUPT,
33 };
34
35 /*
36 * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripheral
37 * controller drivers.
38 *
39 * This just sinks bulk packets OUT to the peripheral and sources them IN
40 * to the host, optionally with specific data patterns for integrity tests.
41 * As such it supports basic functionality and load tests.
42 *
43 * In terms of control messaging, this supports all the standard requests
44 * plus two that support control-OUT tests. If the optional "autoresume"
45 * mode is enabled, it provides good functional coverage for the "USBCV"
46 * test harness from USB-IF.
47 *
48 * Note that because this doesn't queue more than one request at a time,
49 * some other function must be used to test queueing logic. The network
50 * link (g_ether) is the best overall option for that, since its TX and RX
51 * queues are relatively independent, will receive a range of packet sizes,
52 * and can often be made to run out completely. Those issues are important
53 * when stress testing peripheral controller drivers.
54 *
55 *
56 * This is currently packaged as a configuration driver, which can't be
57 * combined with other functions to make composite devices. However, it
58 * can be combined with other independent configurations.
59 */
60 struct f_sourcesink {
61 struct usb_function function;
62
63 struct usb_ep *in_ep;
64 struct usb_ep *out_ep;
65 struct usb_ep *iso_in_ep;
66 struct usb_ep *iso_out_ep;
67 struct usb_ep *int_in_ep;
68 struct usb_ep *int_out_ep;
69 int cur_alt;
70 };
71
72 static inline struct f_sourcesink *func_to_ss(struct usb_function *f)
73 {
74 return container_of(f, struct f_sourcesink, function);
75 }
76
77 static unsigned pattern;
78 static unsigned isoc_interval;
79 static unsigned isoc_maxpacket;
80 static unsigned isoc_mult;
81 static unsigned isoc_maxburst;
82 static unsigned int_interval; /* In ms */
83 static unsigned int_maxpacket;
84 static unsigned int_mult;
85 static unsigned int_maxburst;
86 static unsigned buflen;
87
88 /*-------------------------------------------------------------------------*/
89
90 static struct usb_interface_descriptor source_sink_intf_alt0 = {
91 .bLength = USB_DT_INTERFACE_SIZE,
92 .bDescriptorType = USB_DT_INTERFACE,
93
94 .bAlternateSetting = 0,
95 .bNumEndpoints = 2,
96 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
97 /* .iInterface = DYNAMIC */
98 };
99
100 static struct usb_interface_descriptor source_sink_intf_alt1 = {
101 .bLength = USB_DT_INTERFACE_SIZE,
102 .bDescriptorType = USB_DT_INTERFACE,
103
104 .bAlternateSetting = 1,
105 .bNumEndpoints = 4,
106 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
107 /* .iInterface = DYNAMIC */
108 };
109
110 static struct usb_interface_descriptor source_sink_intf_alt2 = {
111 .bLength = USB_DT_INTERFACE_SIZE,
112 .bDescriptorType = USB_DT_INTERFACE,
113
114 .bAlternateSetting = 2,
115 .bNumEndpoints = 2,
116 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
117 /* .iInterface = DYNAMIC */
118 };
119
120 /* full speed support: */
121
122 static struct usb_endpoint_descriptor fs_source_desc = {
123 .bLength = USB_DT_ENDPOINT_SIZE,
124 .bDescriptorType = USB_DT_ENDPOINT,
125
126 .bEndpointAddress = USB_DIR_IN,
127 .bmAttributes = USB_ENDPOINT_XFER_BULK,
128 };
129
130 static struct usb_endpoint_descriptor fs_sink_desc = {
131 .bLength = USB_DT_ENDPOINT_SIZE,
132 .bDescriptorType = USB_DT_ENDPOINT,
133
134 .bEndpointAddress = USB_DIR_OUT,
135 .bmAttributes = USB_ENDPOINT_XFER_BULK,
136 };
137
138 static struct usb_endpoint_descriptor fs_iso_source_desc = {
139 .bLength = USB_DT_ENDPOINT_SIZE,
140 .bDescriptorType = USB_DT_ENDPOINT,
141
142 .bEndpointAddress = USB_DIR_IN,
143 .bmAttributes = USB_ENDPOINT_XFER_ISOC,
144 .wMaxPacketSize = cpu_to_le16(1023),
145 .bInterval = 4,
146 };
147
148 static struct usb_endpoint_descriptor fs_iso_sink_desc = {
149 .bLength = USB_DT_ENDPOINT_SIZE,
150 .bDescriptorType = USB_DT_ENDPOINT,
151
152 .bEndpointAddress = USB_DIR_OUT,
153 .bmAttributes = USB_ENDPOINT_XFER_ISOC,
154 .wMaxPacketSize = cpu_to_le16(1023),
155 .bInterval = 4,
156 };
157
158 static struct usb_endpoint_descriptor fs_int_source_desc = {
159 .bLength = USB_DT_ENDPOINT_SIZE,
160 .bDescriptorType = USB_DT_ENDPOINT,
161
162 .bEndpointAddress = USB_DIR_IN,
163 .bmAttributes = USB_ENDPOINT_XFER_INT,
164 .wMaxPacketSize = cpu_to_le16(64),
165 .bInterval = GZERO_INT_INTERVAL,
166 };
167
168 static struct usb_endpoint_descriptor fs_int_sink_desc = {
169 .bLength = USB_DT_ENDPOINT_SIZE,
170 .bDescriptorType = USB_DT_ENDPOINT,
171
172 .bEndpointAddress = USB_DIR_OUT,
173 .bmAttributes = USB_ENDPOINT_XFER_INT,
174 .wMaxPacketSize = cpu_to_le16(64),
175 .bInterval = GZERO_INT_INTERVAL,
176 };
177
178 static struct usb_descriptor_header *fs_source_sink_descs[] = {
179 (struct usb_descriptor_header *) &source_sink_intf_alt0,
180 (struct usb_descriptor_header *) &fs_sink_desc,
181 (struct usb_descriptor_header *) &fs_source_desc,
182 (struct usb_descriptor_header *) &source_sink_intf_alt1,
183 #define FS_ALT_IFC_1_OFFSET 3
184 (struct usb_descriptor_header *) &fs_sink_desc,
185 (struct usb_descriptor_header *) &fs_source_desc,
186 (struct usb_descriptor_header *) &fs_iso_sink_desc,
187 (struct usb_descriptor_header *) &fs_iso_source_desc,
188 (struct usb_descriptor_header *) &source_sink_intf_alt2,
189 #define FS_ALT_IFC_2_OFFSET 8
190 (struct usb_descriptor_header *) &fs_int_sink_desc,
191 (struct usb_descriptor_header *) &fs_int_source_desc,
192 NULL,
193 };
194
195 /* high speed support: */
196
197 static struct usb_endpoint_descriptor hs_source_desc = {
198 .bLength = USB_DT_ENDPOINT_SIZE,
199 .bDescriptorType = USB_DT_ENDPOINT,
200
201 .bmAttributes = USB_ENDPOINT_XFER_BULK,
202 .wMaxPacketSize = cpu_to_le16(512),
203 };
204
205 static struct usb_endpoint_descriptor hs_sink_desc = {
206 .bLength = USB_DT_ENDPOINT_SIZE,
207 .bDescriptorType = USB_DT_ENDPOINT,
208
209 .bmAttributes = USB_ENDPOINT_XFER_BULK,
210 .wMaxPacketSize = cpu_to_le16(512),
211 };
212
213 static struct usb_endpoint_descriptor hs_iso_source_desc = {
214 .bLength = USB_DT_ENDPOINT_SIZE,
215 .bDescriptorType = USB_DT_ENDPOINT,
216
217 .bmAttributes = USB_ENDPOINT_XFER_ISOC,
218 .wMaxPacketSize = cpu_to_le16(1024),
219 .bInterval = 4,
220 };
221
222 static struct usb_endpoint_descriptor hs_iso_sink_desc = {
223 .bLength = USB_DT_ENDPOINT_SIZE,
224 .bDescriptorType = USB_DT_ENDPOINT,
225
226 .bmAttributes = USB_ENDPOINT_XFER_ISOC,
227 .wMaxPacketSize = cpu_to_le16(1024),
228 .bInterval = 4,
229 };
230
231 static struct usb_endpoint_descriptor hs_int_source_desc = {
232 .bLength = USB_DT_ENDPOINT_SIZE,
233 .bDescriptorType = USB_DT_ENDPOINT,
234
235 .bmAttributes = USB_ENDPOINT_XFER_INT,
236 .wMaxPacketSize = cpu_to_le16(1024),
237 .bInterval = USB_MS_TO_HS_INTERVAL(GZERO_INT_INTERVAL),
238 };
239
240 static struct usb_endpoint_descriptor hs_int_sink_desc = {
241 .bLength = USB_DT_ENDPOINT_SIZE,
242 .bDescriptorType = USB_DT_ENDPOINT,
243
244 .bmAttributes = USB_ENDPOINT_XFER_INT,
245 .wMaxPacketSize = cpu_to_le16(1024),
246 .bInterval = USB_MS_TO_HS_INTERVAL(GZERO_INT_INTERVAL),
247 };
248
249 static struct usb_descriptor_header *hs_source_sink_descs[] = {
250 (struct usb_descriptor_header *) &source_sink_intf_alt0,
251 (struct usb_descriptor_header *) &hs_source_desc,
252 (struct usb_descriptor_header *) &hs_sink_desc,
253 (struct usb_descriptor_header *) &source_sink_intf_alt1,
254 #define HS_ALT_IFC_1_OFFSET 3
255 (struct usb_descriptor_header *) &hs_source_desc,
256 (struct usb_descriptor_header *) &hs_sink_desc,
257 (struct usb_descriptor_header *) &hs_iso_source_desc,
258 (struct usb_descriptor_header *) &hs_iso_sink_desc,
259 (struct usb_descriptor_header *) &source_sink_intf_alt2,
260 #define HS_ALT_IFC_2_OFFSET 8
261 (struct usb_descriptor_header *) &hs_int_source_desc,
262 (struct usb_descriptor_header *) &hs_int_sink_desc,
263 NULL,
264 };
265
266 /* super speed support: */
267
268 static struct usb_endpoint_descriptor ss_source_desc = {
269 .bLength = USB_DT_ENDPOINT_SIZE,
270 .bDescriptorType = USB_DT_ENDPOINT,
271
272 .bmAttributes = USB_ENDPOINT_XFER_BULK,
273 .wMaxPacketSize = cpu_to_le16(1024),
274 };
275
276 static struct usb_ss_ep_comp_descriptor ss_source_comp_desc = {
277 .bLength = USB_DT_SS_EP_COMP_SIZE,
278 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
279
280 .bMaxBurst = 0,
281 .bmAttributes = 0,
282 .wBytesPerInterval = 0,
283 };
284
285 static struct usb_endpoint_descriptor ss_sink_desc = {
286 .bLength = USB_DT_ENDPOINT_SIZE,
287 .bDescriptorType = USB_DT_ENDPOINT,
288
289 .bmAttributes = USB_ENDPOINT_XFER_BULK,
290 .wMaxPacketSize = cpu_to_le16(1024),
291 };
292
293 static struct usb_ss_ep_comp_descriptor ss_sink_comp_desc = {
294 .bLength = USB_DT_SS_EP_COMP_SIZE,
295 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
296
297 .bMaxBurst = 0,
298 .bmAttributes = 0,
299 .wBytesPerInterval = 0,
300 };
301
302 static struct usb_endpoint_descriptor ss_iso_source_desc = {
303 .bLength = USB_DT_ENDPOINT_SIZE,
304 .bDescriptorType = USB_DT_ENDPOINT,
305
306 .bmAttributes = USB_ENDPOINT_XFER_ISOC,
307 .wMaxPacketSize = cpu_to_le16(1024),
308 .bInterval = 4,
309 };
310
311 static struct usb_ss_ep_comp_descriptor ss_iso_source_comp_desc = {
312 .bLength = USB_DT_SS_EP_COMP_SIZE,
313 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
314
315 .bMaxBurst = 0,
316 .bmAttributes = 0,
317 .wBytesPerInterval = cpu_to_le16(1024),
318 };
319
320 static struct usb_endpoint_descriptor ss_iso_sink_desc = {
321 .bLength = USB_DT_ENDPOINT_SIZE,
322 .bDescriptorType = USB_DT_ENDPOINT,
323
324 .bmAttributes = USB_ENDPOINT_XFER_ISOC,
325 .wMaxPacketSize = cpu_to_le16(1024),
326 .bInterval = 4,
327 };
328
329 static struct usb_ss_ep_comp_descriptor ss_iso_sink_comp_desc = {
330 .bLength = USB_DT_SS_EP_COMP_SIZE,
331 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
332
333 .bMaxBurst = 0,
334 .bmAttributes = 0,
335 .wBytesPerInterval = cpu_to_le16(1024),
336 };
337
338 static struct usb_endpoint_descriptor ss_int_source_desc = {
339 .bLength = USB_DT_ENDPOINT_SIZE,
340 .bDescriptorType = USB_DT_ENDPOINT,
341
342 .bmAttributes = USB_ENDPOINT_XFER_INT,
343 .wMaxPacketSize = cpu_to_le16(1024),
344 .bInterval = USB_MS_TO_SS_INTERVAL(GZERO_INT_INTERVAL),
345 };
346
347 static struct usb_ss_ep_comp_descriptor ss_int_source_comp_desc = {
348 .bLength = USB_DT_SS_EP_COMP_SIZE,
349 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
350
351 .bMaxBurst = 0,
352 .bmAttributes = 0,
353 .wBytesPerInterval = cpu_to_le16(1024),
354 };
355
356 static struct usb_endpoint_descriptor ss_int_sink_desc = {
357 .bLength = USB_DT_ENDPOINT_SIZE,
358 .bDescriptorType = USB_DT_ENDPOINT,
359
360 .bmAttributes = USB_ENDPOINT_XFER_INT,
361 .wMaxPacketSize = cpu_to_le16(1024),
362 .bInterval = USB_MS_TO_SS_INTERVAL(GZERO_INT_INTERVAL),
363 };
364
365 static struct usb_ss_ep_comp_descriptor ss_int_sink_comp_desc = {
366 .bLength = USB_DT_SS_EP_COMP_SIZE,
367 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
368
369 .bMaxBurst = 0,
370 .bmAttributes = 0,
371 .wBytesPerInterval = cpu_to_le16(1024),
372 };
373
374 static struct usb_descriptor_header *ss_source_sink_descs[] = {
375 (struct usb_descriptor_header *) &source_sink_intf_alt0,
376 (struct usb_descriptor_header *) &ss_source_desc,
377 (struct usb_descriptor_header *) &ss_source_comp_desc,
378 (struct usb_descriptor_header *) &ss_sink_desc,
379 (struct usb_descriptor_header *) &ss_sink_comp_desc,
380 (struct usb_descriptor_header *) &source_sink_intf_alt1,
381 #define SS_ALT_IFC_1_OFFSET 5
382 (struct usb_descriptor_header *) &ss_source_desc,
383 (struct usb_descriptor_header *) &ss_source_comp_desc,
384 (struct usb_descriptor_header *) &ss_sink_desc,
385 (struct usb_descriptor_header *) &ss_sink_comp_desc,
386 (struct usb_descriptor_header *) &ss_iso_source_desc,
387 (struct usb_descriptor_header *) &ss_iso_source_comp_desc,
388 (struct usb_descriptor_header *) &ss_iso_sink_desc,
389 (struct usb_descriptor_header *) &ss_iso_sink_comp_desc,
390 (struct usb_descriptor_header *) &source_sink_intf_alt2,
391 #define SS_ALT_IFC_2_OFFSET 14
392 (struct usb_descriptor_header *) &ss_int_source_desc,
393 (struct usb_descriptor_header *) &ss_int_source_comp_desc,
394 (struct usb_descriptor_header *) &ss_int_sink_desc,
395 (struct usb_descriptor_header *) &ss_int_sink_comp_desc,
396 NULL,
397 };
398
399 /* function-specific strings: */
400
401 static struct usb_string strings_sourcesink[] = {
402 [0].s = "source and sink data",
403 { } /* end of list */
404 };
405
406 static struct usb_gadget_strings stringtab_sourcesink = {
407 .language = 0x0409, /* en-us */
408 .strings = strings_sourcesink,
409 };
410
411 static struct usb_gadget_strings *sourcesink_strings[] = {
412 &stringtab_sourcesink,
413 NULL,
414 };
415
416 /*-------------------------------------------------------------------------*/
417 static const char *get_ep_string(enum eptype ep_type)
418 {
419 switch (ep_type) {
420 case EP_ISOC:
421 return "ISOC-";
422 case EP_INTERRUPT:
423 return "INTERRUPT-";
424 case EP_CONTROL:
425 return "CTRL-";
426 case EP_BULK:
427 return "BULK-";
428 default:
429 return "UNKNOWN-";
430 }
431 }
432
433 static inline struct usb_request *ss_alloc_ep_req(struct usb_ep *ep, int len)
434 {
435 return alloc_ep_req(ep, len, buflen);
436 }
437
438 void free_ep_req(struct usb_ep *ep, struct usb_request *req)
439 {
440 kfree(req->buf);
441 usb_ep_free_request(ep, req);
442 }
443
444 static void disable_ep(struct usb_composite_dev *cdev, struct usb_ep *ep)
445 {
446 int value;
447
448 if (ep->driver_data) {
449 value = usb_ep_disable(ep);
450 if (value < 0)
451 DBG(cdev, "disable %s --> %d\n",
452 ep->name, value);
453 ep->driver_data = NULL;
454 }
455 }
456
457 void disable_endpoints(struct usb_composite_dev *cdev,
458 struct usb_ep *in, struct usb_ep *out,
459 struct usb_ep *iso_in, struct usb_ep *iso_out,
460 struct usb_ep *int_in, struct usb_ep *int_out)
461 {
462 disable_ep(cdev, in);
463 disable_ep(cdev, out);
464 if (iso_in)
465 disable_ep(cdev, iso_in);
466 if (iso_out)
467 disable_ep(cdev, iso_out);
468 if (int_in)
469 disable_ep(cdev, int_in);
470 if (int_out)
471 disable_ep(cdev, int_out);
472 }
473
474 static int
475 sourcesink_bind(struct usb_configuration *c, struct usb_function *f)
476 {
477 struct usb_composite_dev *cdev = c->cdev;
478 struct f_sourcesink *ss = func_to_ss(f);
479 int id;
480 int ret;
481
482 /* allocate interface ID(s) */
483 id = usb_interface_id(c, f);
484 if (id < 0)
485 return id;
486 source_sink_intf_alt0.bInterfaceNumber = id;
487 source_sink_intf_alt1.bInterfaceNumber = id;
488 source_sink_intf_alt2.bInterfaceNumber = id;
489
490 /* allocate bulk endpoints */
491 ss->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc);
492 if (!ss->in_ep) {
493 autoconf_fail:
494 ERROR(cdev, "%s: can't autoconfigure on %s\n",
495 f->name, cdev->gadget->name);
496 return -ENODEV;
497 }
498 ss->in_ep->driver_data = cdev; /* claim */
499
500 ss->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_sink_desc);
501 if (!ss->out_ep)
502 goto autoconf_fail;
503 ss->out_ep->driver_data = cdev; /* claim */
504
505 /* sanity check the isoc module parameters */
506 if (isoc_interval < 1)
507 isoc_interval = 1;
508 if (isoc_interval > 16)
509 isoc_interval = 16;
510 if (isoc_mult > 2)
511 isoc_mult = 2;
512 if (isoc_maxburst > 15)
513 isoc_maxburst = 15;
514
515 /* fill in the FS isoc descriptors from the module parameters */
516 fs_iso_source_desc.wMaxPacketSize = isoc_maxpacket > 1023 ?
517 1023 : isoc_maxpacket;
518 fs_iso_source_desc.bInterval = isoc_interval;
519 fs_iso_sink_desc.wMaxPacketSize = isoc_maxpacket > 1023 ?
520 1023 : isoc_maxpacket;
521 fs_iso_sink_desc.bInterval = isoc_interval;
522
523 /* allocate iso endpoints */
524 ss->iso_in_ep = usb_ep_autoconfig(cdev->gadget, &fs_iso_source_desc);
525 if (!ss->iso_in_ep)
526 goto no_iso;
527 ss->iso_in_ep->driver_data = cdev; /* claim */
528
529 ss->iso_out_ep = usb_ep_autoconfig(cdev->gadget, &fs_iso_sink_desc);
530 if (ss->iso_out_ep) {
531 ss->iso_out_ep->driver_data = cdev; /* claim */
532 } else {
533 ss->iso_in_ep->driver_data = NULL;
534 ss->iso_in_ep = NULL;
535 no_iso:
536 /*
537 * We still want to work even if the UDC doesn't have isoc
538 * endpoints, so null out the alt interface that contains
539 * them and continue.
540 */
541 fs_source_sink_descs[FS_ALT_IFC_1_OFFSET] = NULL;
542 hs_source_sink_descs[HS_ALT_IFC_1_OFFSET] = NULL;
543 ss_source_sink_descs[SS_ALT_IFC_1_OFFSET] = NULL;
544 }
545
546 if (isoc_maxpacket > 1024)
547 isoc_maxpacket = 1024;
548
549 /* sanity check the interrupt module parameters */
550 if (int_interval < 1)
551 int_interval = 1;
552 if (int_interval > 4096)
553 int_interval = 4096;
554 if (int_mult > 2)
555 int_mult = 2;
556 if (int_maxburst > 15)
557 int_maxburst = 15;
558
559 /* fill in the FS interrupt descriptors from the module parameters */
560 fs_int_source_desc.wMaxPacketSize = int_maxpacket > 64 ?
561 64 : int_maxpacket;
562 fs_int_source_desc.bInterval = int_interval > 255 ?
563 255 : int_interval;
564 fs_int_sink_desc.wMaxPacketSize = int_maxpacket > 64 ?
565 64 : int_maxpacket;
566 fs_int_sink_desc.bInterval = int_interval > 255 ?
567 255 : int_interval;
568
569 /* allocate int endpoints */
570 ss->int_in_ep = usb_ep_autoconfig(cdev->gadget, &fs_int_source_desc);
571 if (!ss->int_in_ep)
572 goto no_int;
573 ss->int_in_ep->driver_data = cdev; /* claim */
574
575 ss->int_out_ep = usb_ep_autoconfig(cdev->gadget, &fs_int_sink_desc);
576 if (ss->int_out_ep) {
577 ss->int_out_ep->driver_data = cdev; /* claim */
578 } else {
579 ss->int_in_ep->driver_data = NULL;
580 ss->int_in_ep = NULL;
581 no_int:
582 fs_source_sink_descs[FS_ALT_IFC_2_OFFSET] = NULL;
583 hs_source_sink_descs[HS_ALT_IFC_2_OFFSET] = NULL;
584 ss_source_sink_descs[SS_ALT_IFC_2_OFFSET] = NULL;
585 }
586
587 if (int_maxpacket > 1024)
588 int_maxpacket = 1024;
589
590 /* support high speed hardware */
591 hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress;
592 hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress;
593
594 /*
595 * Fill in the HS isoc and interrupt descriptors from the module
596 * parameters. We assume that the user knows what they are doing and
597 * won't give parameters that their UDC doesn't support.
598 */
599 hs_iso_source_desc.wMaxPacketSize = isoc_maxpacket;
600 hs_iso_source_desc.wMaxPacketSize |= isoc_mult << 11;
601 hs_iso_source_desc.bInterval = isoc_interval;
602 hs_iso_source_desc.bEndpointAddress =
603 fs_iso_source_desc.bEndpointAddress;
604
605 hs_iso_sink_desc.wMaxPacketSize = isoc_maxpacket;
606 hs_iso_sink_desc.wMaxPacketSize |= isoc_mult << 11;
607 hs_iso_sink_desc.bInterval = isoc_interval;
608 hs_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;
609
610 hs_int_source_desc.wMaxPacketSize = int_maxpacket;
611 hs_int_source_desc.wMaxPacketSize |= int_mult << 11;
612 hs_int_source_desc.bInterval = USB_MS_TO_HS_INTERVAL(int_interval);
613 hs_int_source_desc.bEndpointAddress =
614 fs_int_source_desc.bEndpointAddress;
615
616 hs_int_sink_desc.wMaxPacketSize = int_maxpacket;
617 hs_int_sink_desc.wMaxPacketSize |= int_mult << 11;
618 hs_int_sink_desc.bInterval = USB_MS_TO_HS_INTERVAL(int_interval);
619 hs_int_sink_desc.bEndpointAddress = fs_int_sink_desc.bEndpointAddress;
620
621 /* support super speed hardware */
622 ss_source_desc.bEndpointAddress =
623 fs_source_desc.bEndpointAddress;
624 ss_sink_desc.bEndpointAddress =
625 fs_sink_desc.bEndpointAddress;
626
627 /*
628 * Fill in the SS isoc and interrupt descriptors from the module
629 * parameters. We assume that the user knows what they are doing and
630 * won't give parameters that their UDC doesn't support.
631 */
632 ss_iso_source_desc.wMaxPacketSize = isoc_maxpacket;
633 ss_iso_source_desc.bInterval = isoc_interval;
634 ss_iso_source_comp_desc.bmAttributes = isoc_mult;
635 ss_iso_source_comp_desc.bMaxBurst = isoc_maxburst;
636 ss_iso_source_comp_desc.wBytesPerInterval =
637 isoc_maxpacket * (isoc_mult + 1) * (isoc_maxburst + 1);
638 ss_iso_source_desc.bEndpointAddress =
639 fs_iso_source_desc.bEndpointAddress;
640
641 ss_iso_sink_desc.wMaxPacketSize = isoc_maxpacket;
642 ss_iso_sink_desc.bInterval = isoc_interval;
643 ss_iso_sink_comp_desc.bmAttributes = isoc_mult;
644 ss_iso_sink_comp_desc.bMaxBurst = isoc_maxburst;
645 ss_iso_sink_comp_desc.wBytesPerInterval =
646 isoc_maxpacket * (isoc_mult + 1) * (isoc_maxburst + 1);
647 ss_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;
648
649 ss_int_source_desc.wMaxPacketSize = int_maxpacket;
650 ss_int_source_desc.bInterval = USB_MS_TO_SS_INTERVAL(int_interval);
651 ss_int_source_comp_desc.bmAttributes = int_mult;
652 ss_int_source_comp_desc.bMaxBurst = int_maxburst;
653 ss_int_source_comp_desc.wBytesPerInterval =
654 int_maxpacket * (int_mult + 1) * (int_maxburst + 1);
655 ss_int_source_desc.bEndpointAddress =
656 fs_int_source_desc.bEndpointAddress;
657
658 ss_int_sink_desc.wMaxPacketSize = int_maxpacket;
659 ss_int_sink_desc.bInterval = USB_MS_TO_SS_INTERVAL(int_interval);
660 ss_int_sink_comp_desc.bmAttributes = int_mult;
661 ss_int_sink_comp_desc.bMaxBurst = int_maxburst;
662 ss_int_sink_comp_desc.wBytesPerInterval =
663 int_maxpacket * (int_mult + 1) * (int_maxburst + 1);
664 ss_int_sink_desc.bEndpointAddress = fs_int_sink_desc.bEndpointAddress;
665
666 ret = usb_assign_descriptors(f, fs_source_sink_descs,
667 hs_source_sink_descs, ss_source_sink_descs);
668 if (ret)
669 return ret;
670
671 DBG(cdev, "%s speed %s: IN/%s, OUT/%s, ISO-IN/%s, ISO-OUT/%s, "
672 "INT-IN/%s, INT-OUT/%s\n",
673 (gadget_is_superspeed(c->cdev->gadget) ? "super" :
674 (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")),
675 f->name, ss->in_ep->name, ss->out_ep->name,
676 ss->iso_in_ep ? ss->iso_in_ep->name : "<none>",
677 ss->iso_out_ep ? ss->iso_out_ep->name : "<none>",
678 ss->int_in_ep ? ss->int_in_ep->name : "<none>",
679 ss->int_out_ep ? ss->int_out_ep->name : "<none>");
680 return 0;
681 }
682
683 static void
684 sourcesink_free_func(struct usb_function *f)
685 {
686 struct f_ss_opts *opts;
687
688 opts = container_of(f->fi, struct f_ss_opts, func_inst);
689
690 mutex_lock(&opts->lock);
691 opts->refcnt--;
692 mutex_unlock(&opts->lock);
693
694 usb_free_all_descriptors(f);
695 kfree(func_to_ss(f));
696 }
697
698 /* optionally require specific source/sink data patterns */
699 static int check_read_data(struct f_sourcesink *ss, struct usb_request *req)
700 {
701 unsigned i;
702 u8 *buf = req->buf;
703 struct usb_composite_dev *cdev = ss->function.config->cdev;
704
705 if (pattern == 2)
706 return 0;
707
708 for (i = 0; i < req->actual; i++, buf++) {
709 switch (pattern) {
710
711 /* all-zeroes has no synchronization issues */
712 case 0:
713 if (*buf == 0)
714 continue;
715 break;
716
717 /* "mod63" stays in sync with short-terminated transfers,
718 * OR otherwise when host and gadget agree on how large
719 * each usb transfer request should be. Resync is done
720 * with set_interface or set_config. (We *WANT* it to
721 * get quickly out of sync if controllers or their drivers
722 * stutter for any reason, including buffer duplication...)
723 */
724 case 1:
725 if (*buf == (u8)(i % 63))
726 continue;
727 break;
728 }
729 ERROR(cdev, "bad OUT byte, buf[%d] = %d\n", i, *buf);
730 usb_ep_set_halt(ss->out_ep);
731 return -EINVAL;
732 }
733 return 0;
734 }
735
736 static void reinit_write_data(struct usb_ep *ep, struct usb_request *req)
737 {
738 unsigned i;
739 u8 *buf = req->buf;
740
741 switch (pattern) {
742 case 0:
743 memset(req->buf, 0, req->length);
744 break;
745 case 1:
746 for (i = 0; i < req->length; i++)
747 *buf++ = (u8) (i % 63);
748 break;
749 case 2:
750 break;
751 }
752 }
753
754 static void source_sink_complete(struct usb_ep *ep, struct usb_request *req)
755 {
756 struct usb_composite_dev *cdev;
757 struct f_sourcesink *ss = ep->driver_data;
758 int status = req->status;
759
760 /* driver_data will be null if ep has been disabled */
761 if (!ss)
762 return;
763
764 cdev = ss->function.config->cdev;
765
766 switch (status) {
767
768 case 0: /* normal completion? */
769 if (ep == ss->out_ep) {
770 check_read_data(ss, req);
771 if (pattern != 2)
772 memset(req->buf, 0x55, req->length);
773 }
774 break;
775
776 /* this endpoint is normally active while we're configured */
777 case -ECONNABORTED: /* hardware forced ep reset */
778 case -ECONNRESET: /* request dequeued */
779 case -ESHUTDOWN: /* disconnect from host */
780 VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status,
781 req->actual, req->length);
782 if (ep == ss->out_ep)
783 check_read_data(ss, req);
784 free_ep_req(ep, req);
785 return;
786
787 case -EOVERFLOW: /* buffer overrun on read means that
788 * we didn't provide a big enough
789 * buffer.
790 */
791 default:
792 #if 1
793 DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name,
794 status, req->actual, req->length);
795 #endif
796 case -EREMOTEIO: /* short read */
797 break;
798 }
799
800 status = usb_ep_queue(ep, req, GFP_ATOMIC);
801 if (status) {
802 ERROR(cdev, "kill %s: resubmit %d bytes --> %d\n",
803 ep->name, req->length, status);
804 usb_ep_set_halt(ep);
805 /* FIXME recover later ... somehow */
806 }
807 }
808
809 static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in,
810 enum eptype ep_type, int speed)
811 {
812 struct usb_ep *ep;
813 struct usb_request *req;
814 int i, size, status;
815
816 for (i = 0; i < 8; i++) {
817 switch (ep_type) {
818 case EP_ISOC:
819 switch (speed) {
820 case USB_SPEED_SUPER:
821 size = isoc_maxpacket * (isoc_mult + 1) *
822 (isoc_maxburst + 1);
823 break;
824 case USB_SPEED_HIGH:
825 size = isoc_maxpacket * (isoc_mult + 1);
826 break;
827 default:
828 size = isoc_maxpacket > 1023 ?
829 1023 : isoc_maxpacket;
830 break;
831 }
832 ep = is_in ? ss->iso_in_ep : ss->iso_out_ep;
833 req = ss_alloc_ep_req(ep, size);
834 break;
835 case EP_INTERRUPT:
836 switch (speed) {
837 case USB_SPEED_SUPER:
838 size = int_maxpacket * (int_mult + 1) *
839 (int_maxburst + 1);
840 break;
841 case USB_SPEED_HIGH:
842 size = int_maxpacket * (int_mult + 1);
843 break;
844 default:
845 size = int_maxpacket > 1023 ?
846 1023 : int_maxpacket;
847 break;
848 }
849 ep = is_in ? ss->int_in_ep : ss->int_out_ep;
850 req = ss_alloc_ep_req(ep, size);
851 break;
852 default:
853 ep = is_in ? ss->in_ep : ss->out_ep;
854 req = ss_alloc_ep_req(ep, 0);
855 break;
856 }
857
858 if (!req)
859 return -ENOMEM;
860
861 req->complete = source_sink_complete;
862 if (is_in)
863 reinit_write_data(ep, req);
864 else if (pattern != 2)
865 memset(req->buf, 0x55, req->length);
866
867 status = usb_ep_queue(ep, req, GFP_ATOMIC);
868 if (status) {
869 struct usb_composite_dev *cdev;
870
871 cdev = ss->function.config->cdev;
872 ERROR(cdev, "start %s%s %s --> %d\n",
873 get_ep_string(ep_type), is_in ? "IN" : "OUT",
874 ep->name, status);
875 free_ep_req(ep, req);
876 }
877
878 if (!(ep_type == EP_ISOC))
879 break;
880 }
881
882 return status;
883 }
884
885 static void disable_source_sink(struct f_sourcesink *ss)
886 {
887 struct usb_composite_dev *cdev;
888
889 cdev = ss->function.config->cdev;
890 disable_endpoints(cdev, ss->in_ep, ss->out_ep, ss->iso_in_ep,
891 ss->iso_out_ep, ss->int_in_ep, ss->int_out_ep);
892 VDBG(cdev, "%s disabled\n", ss->function.name);
893 }
894
895 static int
896 enable_source_sink(struct usb_composite_dev *cdev, struct f_sourcesink *ss,
897 int alt)
898 {
899 int result = 0;
900 int speed = cdev->gadget->speed;
901 struct usb_ep *ep;
902
903 if (alt == 2) {
904 /* Configure for periodic interrupt endpoint */
905 ep = ss->int_in_ep;
906 if (ep) {
907 result = config_ep_by_speed(cdev->gadget,
908 &(ss->function), ep);
909 if (result)
910 return result;
911
912 result = usb_ep_enable(ep);
913 if (result < 0)
914 return result;
915
916 ep->driver_data = ss;
917 result = source_sink_start_ep(ss, true, EP_INTERRUPT,
918 speed);
919 if (result < 0) {
920 fail1:
921 ep = ss->int_in_ep;
922 if (ep) {
923 usb_ep_disable(ep);
924 ep->driver_data = NULL;
925 }
926 return result;
927 }
928 }
929
930 /*
931 * one interrupt endpoint reads (sinks) anything OUT (from the
932 * host)
933 */
934 ep = ss->int_out_ep;
935 if (ep) {
936 result = config_ep_by_speed(cdev->gadget,
937 &(ss->function), ep);
938 if (result)
939 goto fail1;
940
941 result = usb_ep_enable(ep);
942 if (result < 0)
943 goto fail1;
944
945 ep->driver_data = ss;
946 result = source_sink_start_ep(ss, false, EP_INTERRUPT,
947 speed);
948 if (result < 0) {
949 ep = ss->int_out_ep;
950 usb_ep_disable(ep);
951 ep->driver_data = NULL;
952 goto fail1;
953 }
954 }
955
956 goto out;
957 }
958
959 /* one bulk endpoint writes (sources) zeroes IN (to the host) */
960 ep = ss->in_ep;
961 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
962 if (result)
963 return result;
964 result = usb_ep_enable(ep);
965 if (result < 0)
966 return result;
967 ep->driver_data = ss;
968
969 result = source_sink_start_ep(ss, true, EP_BULK, speed);
970 if (result < 0) {
971 fail:
972 ep = ss->in_ep;
973 usb_ep_disable(ep);
974 ep->driver_data = NULL;
975 return result;
976 }
977
978 /* one bulk endpoint reads (sinks) anything OUT (from the host) */
979 ep = ss->out_ep;
980 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
981 if (result)
982 goto fail;
983 result = usb_ep_enable(ep);
984 if (result < 0)
985 goto fail;
986 ep->driver_data = ss;
987
988 result = source_sink_start_ep(ss, false, EP_BULK, speed);
989 if (result < 0) {
990 fail2:
991 ep = ss->out_ep;
992 usb_ep_disable(ep);
993 ep->driver_data = NULL;
994 goto fail;
995 }
996
997 if (alt == 0)
998 goto out;
999
1000 /* one iso endpoint writes (sources) zeroes IN (to the host) */
1001 ep = ss->iso_in_ep;
1002 if (ep) {
1003 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
1004 if (result)
1005 goto fail2;
1006 result = usb_ep_enable(ep);
1007 if (result < 0)
1008 goto fail2;
1009 ep->driver_data = ss;
1010
1011 result = source_sink_start_ep(ss, true, EP_ISOC, speed);
1012 if (result < 0) {
1013 fail3:
1014 ep = ss->iso_in_ep;
1015 if (ep) {
1016 usb_ep_disable(ep);
1017 ep->driver_data = NULL;
1018 }
1019 goto fail2;
1020 }
1021 }
1022
1023 /* one iso endpoint reads (sinks) anything OUT (from the host) */
1024 ep = ss->iso_out_ep;
1025 if (ep) {
1026 result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
1027 if (result)
1028 goto fail3;
1029 result = usb_ep_enable(ep);
1030 if (result < 0)
1031 goto fail3;
1032 ep->driver_data = ss;
1033
1034 result = source_sink_start_ep(ss, false, EP_ISOC, speed);
1035 if (result < 0) {
1036 usb_ep_disable(ep);
1037 ep->driver_data = NULL;
1038 goto fail3;
1039 }
1040 }
1041
1042 out:
1043 ss->cur_alt = alt;
1044
1045 DBG(cdev, "%s enabled, alt intf %d\n", ss->function.name, alt);
1046 return result;
1047 }
1048
1049 static int sourcesink_set_alt(struct usb_function *f,
1050 unsigned intf, unsigned alt)
1051 {
1052 struct f_sourcesink *ss = func_to_ss(f);
1053 struct usb_composite_dev *cdev = f->config->cdev;
1054
1055 if (ss->in_ep->driver_data)
1056 disable_source_sink(ss);
1057 else if (alt == 2 && ss->int_in_ep->driver_data)
1058 disable_source_sink(ss);
1059 return enable_source_sink(cdev, ss, alt);
1060 }
1061
1062 static int sourcesink_get_alt(struct usb_function *f, unsigned intf)
1063 {
1064 struct f_sourcesink *ss = func_to_ss(f);
1065
1066 return ss->cur_alt;
1067 }
1068
1069 static void sourcesink_disable(struct usb_function *f)
1070 {
1071 struct f_sourcesink *ss = func_to_ss(f);
1072
1073 disable_source_sink(ss);
1074 }
1075
1076 /*-------------------------------------------------------------------------*/
1077
1078 static int sourcesink_setup(struct usb_function *f,
1079 const struct usb_ctrlrequest *ctrl)
1080 {
1081 struct usb_configuration *c = f->config;
1082 struct usb_request *req = c->cdev->req;
1083 int value = -EOPNOTSUPP;
1084 u16 w_index = le16_to_cpu(ctrl->wIndex);
1085 u16 w_value = le16_to_cpu(ctrl->wValue);
1086 u16 w_length = le16_to_cpu(ctrl->wLength);
1087
1088 req->length = USB_COMP_EP0_BUFSIZ;
1089
1090 /* composite driver infrastructure handles everything except
1091 * the two control test requests.
1092 */
1093 switch (ctrl->bRequest) {
1094
1095 /*
1096 * These are the same vendor-specific requests supported by
1097 * Intel's USB 2.0 compliance test devices. We exceed that
1098 * device spec by allowing multiple-packet requests.
1099 *
1100 * NOTE: the Control-OUT data stays in req->buf ... better
1101 * would be copying it into a scratch buffer, so that other
1102 * requests may safely intervene.
1103 */
1104 case 0x5b: /* control WRITE test -- fill the buffer */
1105 if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
1106 goto unknown;
1107 if (w_value || w_index)
1108 break;
1109 /* just read that many bytes into the buffer */
1110 if (w_length > req->length)
1111 break;
1112 value = w_length;
1113 break;
1114 case 0x5c: /* control READ test -- return the buffer */
1115 if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
1116 goto unknown;
1117 if (w_value || w_index)
1118 break;
1119 /* expect those bytes are still in the buffer; send back */
1120 if (w_length > req->length)
1121 break;
1122 value = w_length;
1123 break;
1124
1125 default:
1126 unknown:
1127 VDBG(c->cdev,
1128 "unknown control req%02x.%02x v%04x i%04x l%d\n",
1129 ctrl->bRequestType, ctrl->bRequest,
1130 w_value, w_index, w_length);
1131 }
1132
1133 /* respond with data transfer or status phase? */
1134 if (value >= 0) {
1135 VDBG(c->cdev, "source/sink req%02x.%02x v%04x i%04x l%d\n",
1136 ctrl->bRequestType, ctrl->bRequest,
1137 w_value, w_index, w_length);
1138 req->zero = 0;
1139 req->length = value;
1140 value = usb_ep_queue(c->cdev->gadget->ep0, req, GFP_ATOMIC);
1141 if (value < 0)
1142 ERROR(c->cdev, "source/sink response, err %d\n",
1143 value);
1144 }
1145
1146 /* device either stalls (value < 0) or reports success */
1147 return value;
1148 }
1149
1150 static struct usb_function *source_sink_alloc_func(
1151 struct usb_function_instance *fi)
1152 {
1153 struct f_sourcesink *ss;
1154 struct f_ss_opts *ss_opts;
1155
1156 ss = kzalloc(sizeof(*ss), GFP_KERNEL);
1157 if (!ss)
1158 return NULL;
1159
1160 ss_opts = container_of(fi, struct f_ss_opts, func_inst);
1161
1162 mutex_lock(&ss_opts->lock);
1163 ss_opts->refcnt++;
1164 mutex_unlock(&ss_opts->lock);
1165
1166 pattern = ss_opts->pattern;
1167 isoc_interval = ss_opts->isoc_interval;
1168 isoc_maxpacket = ss_opts->isoc_maxpacket;
1169 isoc_mult = ss_opts->isoc_mult;
1170 isoc_maxburst = ss_opts->isoc_maxburst;
1171 int_interval = ss_opts->int_interval;
1172 int_maxpacket = ss_opts->int_maxpacket;
1173 int_mult = ss_opts->int_mult;
1174 int_maxburst = ss_opts->int_maxburst;
1175 buflen = ss_opts->bulk_buflen;
1176
1177 ss->function.name = "source/sink";
1178 ss->function.bind = sourcesink_bind;
1179 ss->function.set_alt = sourcesink_set_alt;
1180 ss->function.get_alt = sourcesink_get_alt;
1181 ss->function.disable = sourcesink_disable;
1182 ss->function.setup = sourcesink_setup;
1183 ss->function.strings = sourcesink_strings;
1184
1185 ss->function.free_func = sourcesink_free_func;
1186
1187 return &ss->function;
1188 }
1189
1190 static inline struct f_ss_opts *to_f_ss_opts(struct config_item *item)
1191 {
1192 return container_of(to_config_group(item), struct f_ss_opts,
1193 func_inst.group);
1194 }
1195
1196 CONFIGFS_ATTR_STRUCT(f_ss_opts);
1197 CONFIGFS_ATTR_OPS(f_ss_opts);
1198
1199 static void ss_attr_release(struct config_item *item)
1200 {
1201 struct f_ss_opts *ss_opts = to_f_ss_opts(item);
1202
1203 usb_put_function_instance(&ss_opts->func_inst);
1204 }
1205
1206 static struct configfs_item_operations ss_item_ops = {
1207 .release = ss_attr_release,
1208 .show_attribute = f_ss_opts_attr_show,
1209 .store_attribute = f_ss_opts_attr_store,
1210 };
1211
1212 static ssize_t f_ss_opts_pattern_show(struct f_ss_opts *opts, char *page)
1213 {
1214 int result;
1215
1216 mutex_lock(&opts->lock);
1217 result = sprintf(page, "%u", opts->pattern);
1218 mutex_unlock(&opts->lock);
1219
1220 return result;
1221 }
1222
1223 static ssize_t f_ss_opts_pattern_store(struct f_ss_opts *opts,
1224 const char *page, size_t len)
1225 {
1226 int ret;
1227 u8 num;
1228
1229 mutex_lock(&opts->lock);
1230 if (opts->refcnt) {
1231 ret = -EBUSY;
1232 goto end;
1233 }
1234
1235 ret = kstrtou8(page, 0, &num);
1236 if (ret)
1237 goto end;
1238
1239 if (num != 0 && num != 1 && num != 2) {
1240 ret = -EINVAL;
1241 goto end;
1242 }
1243
1244 opts->pattern = num;
1245 ret = len;
1246 end:
1247 mutex_unlock(&opts->lock);
1248 return ret;
1249 }
1250
1251 static struct f_ss_opts_attribute f_ss_opts_pattern =
1252 __CONFIGFS_ATTR(pattern, S_IRUGO | S_IWUSR,
1253 f_ss_opts_pattern_show,
1254 f_ss_opts_pattern_store);
1255
1256 static ssize_t f_ss_opts_isoc_interval_show(struct f_ss_opts *opts, char *page)
1257 {
1258 int result;
1259
1260 mutex_lock(&opts->lock);
1261 result = sprintf(page, "%u", opts->isoc_interval);
1262 mutex_unlock(&opts->lock);
1263
1264 return result;
1265 }
1266
1267 static ssize_t f_ss_opts_isoc_interval_store(struct f_ss_opts *opts,
1268 const char *page, size_t len)
1269 {
1270 int ret;
1271 u8 num;
1272
1273 mutex_lock(&opts->lock);
1274 if (opts->refcnt) {
1275 ret = -EBUSY;
1276 goto end;
1277 }
1278
1279 ret = kstrtou8(page, 0, &num);
1280 if (ret)
1281 goto end;
1282
1283 if (num > 16) {
1284 ret = -EINVAL;
1285 goto end;
1286 }
1287
1288 opts->isoc_interval = num;
1289 ret = len;
1290 end:
1291 mutex_unlock(&opts->lock);
1292 return ret;
1293 }
1294
1295 static struct f_ss_opts_attribute f_ss_opts_isoc_interval =
1296 __CONFIGFS_ATTR(isoc_interval, S_IRUGO | S_IWUSR,
1297 f_ss_opts_isoc_interval_show,
1298 f_ss_opts_isoc_interval_store);
1299
1300 static ssize_t f_ss_opts_isoc_maxpacket_show(struct f_ss_opts *opts, char *page)
1301 {
1302 int result;
1303
1304 mutex_lock(&opts->lock);
1305 result = sprintf(page, "%u", opts->isoc_maxpacket);
1306 mutex_unlock(&opts->lock);
1307
1308 return result;
1309 }
1310
1311 static ssize_t f_ss_opts_isoc_maxpacket_store(struct f_ss_opts *opts,
1312 const char *page, size_t len)
1313 {
1314 int ret;
1315 u16 num;
1316
1317 mutex_lock(&opts->lock);
1318 if (opts->refcnt) {
1319 ret = -EBUSY;
1320 goto end;
1321 }
1322
1323 ret = kstrtou16(page, 0, &num);
1324 if (ret)
1325 goto end;
1326
1327 if (num > 1024) {
1328 ret = -EINVAL;
1329 goto end;
1330 }
1331
1332 opts->isoc_maxpacket = num;
1333 ret = len;
1334 end:
1335 mutex_unlock(&opts->lock);
1336 return ret;
1337 }
1338
1339 static struct f_ss_opts_attribute f_ss_opts_isoc_maxpacket =
1340 __CONFIGFS_ATTR(isoc_maxpacket, S_IRUGO | S_IWUSR,
1341 f_ss_opts_isoc_maxpacket_show,
1342 f_ss_opts_isoc_maxpacket_store);
1343
1344 static ssize_t f_ss_opts_isoc_mult_show(struct f_ss_opts *opts, char *page)
1345 {
1346 int result;
1347
1348 mutex_lock(&opts->lock);
1349 result = sprintf(page, "%u", opts->isoc_mult);
1350 mutex_unlock(&opts->lock);
1351
1352 return result;
1353 }
1354
1355 static ssize_t f_ss_opts_isoc_mult_store(struct f_ss_opts *opts,
1356 const char *page, size_t len)
1357 {
1358 int ret;
1359 u8 num;
1360
1361 mutex_lock(&opts->lock);
1362 if (opts->refcnt) {
1363 ret = -EBUSY;
1364 goto end;
1365 }
1366
1367 ret = kstrtou8(page, 0, &num);
1368 if (ret)
1369 goto end;
1370
1371 if (num > 2) {
1372 ret = -EINVAL;
1373 goto end;
1374 }
1375
1376 opts->isoc_mult = num;
1377 ret = len;
1378 end:
1379 mutex_unlock(&opts->lock);
1380 return ret;
1381 }
1382
1383 static struct f_ss_opts_attribute f_ss_opts_isoc_mult =
1384 __CONFIGFS_ATTR(isoc_mult, S_IRUGO | S_IWUSR,
1385 f_ss_opts_isoc_mult_show,
1386 f_ss_opts_isoc_mult_store);
1387
1388 static ssize_t f_ss_opts_isoc_maxburst_show(struct f_ss_opts *opts, char *page)
1389 {
1390 int result;
1391
1392 mutex_lock(&opts->lock);
1393 result = sprintf(page, "%u", opts->isoc_maxburst);
1394 mutex_unlock(&opts->lock);
1395
1396 return result;
1397 }
1398
1399 static ssize_t f_ss_opts_isoc_maxburst_store(struct f_ss_opts *opts,
1400 const char *page, size_t len)
1401 {
1402 int ret;
1403 u8 num;
1404
1405 mutex_lock(&opts->lock);
1406 if (opts->refcnt) {
1407 ret = -EBUSY;
1408 goto end;
1409 }
1410
1411 ret = kstrtou8(page, 0, &num);
1412 if (ret)
1413 goto end;
1414
1415 if (num > 15) {
1416 ret = -EINVAL;
1417 goto end;
1418 }
1419
1420 opts->isoc_maxburst = num;
1421 ret = len;
1422 end:
1423 mutex_unlock(&opts->lock);
1424 return ret;
1425 }
1426
1427 static struct f_ss_opts_attribute f_ss_opts_isoc_maxburst =
1428 __CONFIGFS_ATTR(isoc_maxburst, S_IRUGO | S_IWUSR,
1429 f_ss_opts_isoc_maxburst_show,
1430 f_ss_opts_isoc_maxburst_store);
1431
1432 static ssize_t f_ss_opts_bulk_buflen_show(struct f_ss_opts *opts, char *page)
1433 {
1434 int result;
1435
1436 mutex_lock(&opts->lock);
1437 result = sprintf(page, "%u", opts->bulk_buflen);
1438 mutex_unlock(&opts->lock);
1439
1440 return result;
1441 }
1442
1443 static ssize_t f_ss_opts_bulk_buflen_store(struct f_ss_opts *opts,
1444 const char *page, size_t len)
1445 {
1446 int ret;
1447 u32 num;
1448
1449 mutex_lock(&opts->lock);
1450 if (opts->refcnt) {
1451 ret = -EBUSY;
1452 goto end;
1453 }
1454
1455 ret = kstrtou32(page, 0, &num);
1456 if (ret)
1457 goto end;
1458
1459 opts->bulk_buflen = num;
1460 ret = len;
1461 end:
1462 mutex_unlock(&opts->lock);
1463 return ret;
1464 }
1465
1466 static struct f_ss_opts_attribute f_ss_opts_bulk_buflen =
1467 __CONFIGFS_ATTR(buflen, S_IRUGO | S_IWUSR,
1468 f_ss_opts_bulk_buflen_show,
1469 f_ss_opts_bulk_buflen_store);
1470
1471 static ssize_t f_ss_opts_int_interval_show(struct f_ss_opts *opts, char *page)
1472 {
1473 int result;
1474
1475 mutex_lock(&opts->lock);
1476 result = sprintf(page, "%u", opts->int_interval);
1477 mutex_unlock(&opts->lock);
1478
1479 return result;
1480 }
1481
1482 static ssize_t f_ss_opts_int_interval_store(struct f_ss_opts *opts,
1483 const char *page, size_t len)
1484 {
1485 int ret;
1486 u32 num;
1487
1488 mutex_lock(&opts->lock);
1489 if (opts->refcnt) {
1490 ret = -EBUSY;
1491 goto end;
1492 }
1493
1494 ret = kstrtou32(page, 0, &num);
1495 if (ret)
1496 goto end;
1497
1498 if (num > 4096) {
1499 ret = -EINVAL;
1500 goto end;
1501 }
1502
1503 opts->int_interval = num;
1504 ret = len;
1505 end:
1506 mutex_unlock(&opts->lock);
1507 return ret;
1508 }
1509
1510 static struct f_ss_opts_attribute f_ss_opts_int_interval =
1511 __CONFIGFS_ATTR(int_interval, S_IRUGO | S_IWUSR,
1512 f_ss_opts_int_interval_show,
1513 f_ss_opts_int_interval_store);
1514
1515 static ssize_t f_ss_opts_int_maxpacket_show(struct f_ss_opts *opts, char *page)
1516 {
1517 int result;
1518
1519 mutex_lock(&opts->lock);
1520 result = sprintf(page, "%u", opts->int_maxpacket);
1521 mutex_unlock(&opts->lock);
1522
1523 return result;
1524 }
1525
1526 static ssize_t f_ss_opts_int_maxpacket_store(struct f_ss_opts *opts,
1527 const char *page, size_t len)
1528 {
1529 int ret;
1530 u16 num;
1531
1532 mutex_lock(&opts->lock);
1533 if (opts->refcnt) {
1534 ret = -EBUSY;
1535 goto end;
1536 }
1537
1538 ret = kstrtou16(page, 0, &num);
1539 if (ret)
1540 goto end;
1541
1542 if (num > 1024) {
1543 ret = -EINVAL;
1544 goto end;
1545 }
1546
1547 opts->int_maxpacket = num;
1548 ret = len;
1549 end:
1550 mutex_unlock(&opts->lock);
1551 return ret;
1552 }
1553
1554 static struct f_ss_opts_attribute f_ss_opts_int_maxpacket =
1555 __CONFIGFS_ATTR(int_maxpacket, S_IRUGO | S_IWUSR,
1556 f_ss_opts_int_maxpacket_show,
1557 f_ss_opts_int_maxpacket_store);
1558
1559 static ssize_t f_ss_opts_int_mult_show(struct f_ss_opts *opts, char *page)
1560 {
1561 int result;
1562
1563 mutex_lock(&opts->lock);
1564 result = sprintf(page, "%u", opts->int_mult);
1565 mutex_unlock(&opts->lock);
1566
1567 return result;
1568 }
1569
1570 static ssize_t f_ss_opts_int_mult_store(struct f_ss_opts *opts,
1571 const char *page, size_t len)
1572 {
1573 int ret;
1574 u8 num;
1575
1576 mutex_lock(&opts->lock);
1577 if (opts->refcnt) {
1578 ret = -EBUSY;
1579 goto end;
1580 }
1581
1582 ret = kstrtou8(page, 0, &num);
1583 if (ret)
1584 goto end;
1585
1586 if (num > 2) {
1587 ret = -EINVAL;
1588 goto end;
1589 }
1590
1591 opts->int_mult = num;
1592 ret = len;
1593 end:
1594 mutex_unlock(&opts->lock);
1595 return ret;
1596 }
1597
1598 static struct f_ss_opts_attribute f_ss_opts_int_mult =
1599 __CONFIGFS_ATTR(int_mult, S_IRUGO | S_IWUSR,
1600 f_ss_opts_int_mult_show,
1601 f_ss_opts_int_mult_store);
1602
1603 static ssize_t f_ss_opts_int_maxburst_show(struct f_ss_opts *opts, char *page)
1604 {
1605 int result;
1606
1607 mutex_lock(&opts->lock);
1608 result = sprintf(page, "%u", opts->int_maxburst);
1609 mutex_unlock(&opts->lock);
1610
1611 return result;
1612 }
1613
1614 static ssize_t f_ss_opts_int_maxburst_store(struct f_ss_opts *opts,
1615 const char *page, size_t len)
1616 {
1617 int ret;
1618 u8 num;
1619
1620 mutex_lock(&opts->lock);
1621 if (opts->refcnt) {
1622 ret = -EBUSY;
1623 goto end;
1624 }
1625
1626 ret = kstrtou8(page, 0, &num);
1627 if (ret)
1628 goto end;
1629
1630 if (num > 15) {
1631 ret = -EINVAL;
1632 goto end;
1633 }
1634
1635 opts->int_maxburst = num;
1636 ret = len;
1637 end:
1638 mutex_unlock(&opts->lock);
1639 return ret;
1640 }
1641
1642 static struct f_ss_opts_attribute f_ss_opts_int_maxburst =
1643 __CONFIGFS_ATTR(int_maxburst, S_IRUGO | S_IWUSR,
1644 f_ss_opts_int_maxburst_show,
1645 f_ss_opts_int_maxburst_store);
1646
1647 static struct configfs_attribute *ss_attrs[] = {
1648 &f_ss_opts_pattern.attr,
1649 &f_ss_opts_isoc_interval.attr,
1650 &f_ss_opts_isoc_maxpacket.attr,
1651 &f_ss_opts_isoc_mult.attr,
1652 &f_ss_opts_isoc_maxburst.attr,
1653 &f_ss_opts_bulk_buflen.attr,
1654 &f_ss_opts_int_interval.attr,
1655 &f_ss_opts_int_maxpacket.attr,
1656 &f_ss_opts_int_mult.attr,
1657 &f_ss_opts_int_maxburst.attr,
1658 NULL,
1659 };
1660
1661 static struct config_item_type ss_func_type = {
1662 .ct_item_ops = &ss_item_ops,
1663 .ct_attrs = ss_attrs,
1664 .ct_owner = THIS_MODULE,
1665 };
1666
1667 static void source_sink_free_instance(struct usb_function_instance *fi)
1668 {
1669 struct f_ss_opts *ss_opts;
1670
1671 ss_opts = container_of(fi, struct f_ss_opts, func_inst);
1672 kfree(ss_opts);
1673 }
1674
1675 static struct usb_function_instance *source_sink_alloc_inst(void)
1676 {
1677 struct f_ss_opts *ss_opts;
1678
1679 ss_opts = kzalloc(sizeof(*ss_opts), GFP_KERNEL);
1680 if (!ss_opts)
1681 return ERR_PTR(-ENOMEM);
1682 mutex_init(&ss_opts->lock);
1683 ss_opts->func_inst.free_func_inst = source_sink_free_instance;
1684 ss_opts->isoc_interval = GZERO_ISOC_INTERVAL;
1685 ss_opts->isoc_maxpacket = GZERO_ISOC_MAXPACKET;
1686 ss_opts->bulk_buflen = GZERO_BULK_BUFLEN;
1687 ss_opts->int_interval = GZERO_INT_INTERVAL;
1688 ss_opts->int_maxpacket = GZERO_INT_MAXPACKET;
1689
1690 config_group_init_type_name(&ss_opts->func_inst.group, "",
1691 &ss_func_type);
1692
1693 return &ss_opts->func_inst;
1694 }
1695 DECLARE_USB_FUNCTION(SourceSink, source_sink_alloc_inst,
1696 source_sink_alloc_func);
1697
1698 static int __init sslb_modinit(void)
1699 {
1700 int ret;
1701
1702 ret = usb_function_register(&SourceSinkusb_func);
1703 if (ret)
1704 return ret;
1705 ret = lb_modinit();
1706 if (ret)
1707 usb_function_unregister(&SourceSinkusb_func);
1708 return ret;
1709 }
1710 static void __exit sslb_modexit(void)
1711 {
1712 usb_function_unregister(&SourceSinkusb_func);
1713 lb_modexit();
1714 }
1715 module_init(sslb_modinit);
1716 module_exit(sslb_modexit);
1717
1718 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.075103 seconds and 6 git commands to generate.