2 * f_sourcesink.c - USB peripheral source/sink configuration driver
4 * Copyright (C) 2003-2008 David Brownell
5 * Copyright (C) 2008 by Nokia Corporation
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.
13 /* #define VERBOSE_DEBUG */
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>
26 * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripheral
29 * This just sinks bulk packets OUT to the peripheral and sources them IN
30 * to the host, optionally with specific data patterns for integrity tests.
31 * As such it supports basic functionality and load tests.
33 * In terms of control messaging, this supports all the standard requests
34 * plus two that support control-OUT tests. If the optional "autoresume"
35 * mode is enabled, it provides good functional coverage for the "USBCV"
36 * test harness from USB-IF.
38 * Note that because this doesn't queue more than one request at a time,
39 * some other function must be used to test queueing logic. The network
40 * link (g_ether) is the best overall option for that, since its TX and RX
41 * queues are relatively independent, will receive a range of packet sizes,
42 * and can often be made to run out completely. Those issues are important
43 * when stress testing peripheral controller drivers.
46 struct usb_function function
;
49 struct usb_ep
*out_ep
;
50 struct usb_ep
*iso_in_ep
;
51 struct usb_ep
*iso_out_ep
;
55 unsigned isoc_interval
;
56 unsigned isoc_maxpacket
;
58 unsigned isoc_maxburst
;
62 static inline struct f_sourcesink
*func_to_ss(struct usb_function
*f
)
64 return container_of(f
, struct f_sourcesink
, function
);
67 /*-------------------------------------------------------------------------*/
69 static struct usb_interface_descriptor source_sink_intf_alt0
= {
70 .bLength
= USB_DT_INTERFACE_SIZE
,
71 .bDescriptorType
= USB_DT_INTERFACE
,
73 .bAlternateSetting
= 0,
75 .bInterfaceClass
= USB_CLASS_VENDOR_SPEC
,
76 /* .iInterface = DYNAMIC */
79 static struct usb_interface_descriptor source_sink_intf_alt1
= {
80 .bLength
= USB_DT_INTERFACE_SIZE
,
81 .bDescriptorType
= USB_DT_INTERFACE
,
83 .bAlternateSetting
= 1,
85 .bInterfaceClass
= USB_CLASS_VENDOR_SPEC
,
86 /* .iInterface = DYNAMIC */
89 /* full speed support: */
91 static struct usb_endpoint_descriptor fs_source_desc
= {
92 .bLength
= USB_DT_ENDPOINT_SIZE
,
93 .bDescriptorType
= USB_DT_ENDPOINT
,
95 .bEndpointAddress
= USB_DIR_IN
,
96 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
99 static struct usb_endpoint_descriptor fs_sink_desc
= {
100 .bLength
= USB_DT_ENDPOINT_SIZE
,
101 .bDescriptorType
= USB_DT_ENDPOINT
,
103 .bEndpointAddress
= USB_DIR_OUT
,
104 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
107 static struct usb_endpoint_descriptor fs_iso_source_desc
= {
108 .bLength
= USB_DT_ENDPOINT_SIZE
,
109 .bDescriptorType
= USB_DT_ENDPOINT
,
111 .bEndpointAddress
= USB_DIR_IN
,
112 .bmAttributes
= USB_ENDPOINT_XFER_ISOC
,
113 .wMaxPacketSize
= cpu_to_le16(1023),
117 static struct usb_endpoint_descriptor fs_iso_sink_desc
= {
118 .bLength
= USB_DT_ENDPOINT_SIZE
,
119 .bDescriptorType
= USB_DT_ENDPOINT
,
121 .bEndpointAddress
= USB_DIR_OUT
,
122 .bmAttributes
= USB_ENDPOINT_XFER_ISOC
,
123 .wMaxPacketSize
= cpu_to_le16(1023),
127 static struct usb_descriptor_header
*fs_source_sink_descs
[] = {
128 (struct usb_descriptor_header
*) &source_sink_intf_alt0
,
129 (struct usb_descriptor_header
*) &fs_sink_desc
,
130 (struct usb_descriptor_header
*) &fs_source_desc
,
131 (struct usb_descriptor_header
*) &source_sink_intf_alt1
,
132 #define FS_ALT_IFC_1_OFFSET 3
133 (struct usb_descriptor_header
*) &fs_sink_desc
,
134 (struct usb_descriptor_header
*) &fs_source_desc
,
135 (struct usb_descriptor_header
*) &fs_iso_sink_desc
,
136 (struct usb_descriptor_header
*) &fs_iso_source_desc
,
140 /* high speed support: */
142 static struct usb_endpoint_descriptor hs_source_desc
= {
143 .bLength
= USB_DT_ENDPOINT_SIZE
,
144 .bDescriptorType
= USB_DT_ENDPOINT
,
146 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
147 .wMaxPacketSize
= cpu_to_le16(512),
150 static struct usb_endpoint_descriptor hs_sink_desc
= {
151 .bLength
= USB_DT_ENDPOINT_SIZE
,
152 .bDescriptorType
= USB_DT_ENDPOINT
,
154 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
155 .wMaxPacketSize
= cpu_to_le16(512),
158 static struct usb_endpoint_descriptor hs_iso_source_desc
= {
159 .bLength
= USB_DT_ENDPOINT_SIZE
,
160 .bDescriptorType
= USB_DT_ENDPOINT
,
162 .bmAttributes
= USB_ENDPOINT_XFER_ISOC
,
163 .wMaxPacketSize
= cpu_to_le16(1024),
167 static struct usb_endpoint_descriptor hs_iso_sink_desc
= {
168 .bLength
= USB_DT_ENDPOINT_SIZE
,
169 .bDescriptorType
= USB_DT_ENDPOINT
,
171 .bmAttributes
= USB_ENDPOINT_XFER_ISOC
,
172 .wMaxPacketSize
= cpu_to_le16(1024),
176 static struct usb_descriptor_header
*hs_source_sink_descs
[] = {
177 (struct usb_descriptor_header
*) &source_sink_intf_alt0
,
178 (struct usb_descriptor_header
*) &hs_source_desc
,
179 (struct usb_descriptor_header
*) &hs_sink_desc
,
180 (struct usb_descriptor_header
*) &source_sink_intf_alt1
,
181 #define HS_ALT_IFC_1_OFFSET 3
182 (struct usb_descriptor_header
*) &hs_source_desc
,
183 (struct usb_descriptor_header
*) &hs_sink_desc
,
184 (struct usb_descriptor_header
*) &hs_iso_source_desc
,
185 (struct usb_descriptor_header
*) &hs_iso_sink_desc
,
189 /* super speed support: */
191 static struct usb_endpoint_descriptor ss_source_desc
= {
192 .bLength
= USB_DT_ENDPOINT_SIZE
,
193 .bDescriptorType
= USB_DT_ENDPOINT
,
195 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
196 .wMaxPacketSize
= cpu_to_le16(1024),
199 static struct usb_ss_ep_comp_descriptor ss_source_comp_desc
= {
200 .bLength
= USB_DT_SS_EP_COMP_SIZE
,
201 .bDescriptorType
= USB_DT_SS_ENDPOINT_COMP
,
205 .wBytesPerInterval
= 0,
208 static struct usb_endpoint_descriptor ss_sink_desc
= {
209 .bLength
= USB_DT_ENDPOINT_SIZE
,
210 .bDescriptorType
= USB_DT_ENDPOINT
,
212 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
213 .wMaxPacketSize
= cpu_to_le16(1024),
216 static struct usb_ss_ep_comp_descriptor ss_sink_comp_desc
= {
217 .bLength
= USB_DT_SS_EP_COMP_SIZE
,
218 .bDescriptorType
= USB_DT_SS_ENDPOINT_COMP
,
222 .wBytesPerInterval
= 0,
225 static struct usb_endpoint_descriptor ss_iso_source_desc
= {
226 .bLength
= USB_DT_ENDPOINT_SIZE
,
227 .bDescriptorType
= USB_DT_ENDPOINT
,
229 .bmAttributes
= USB_ENDPOINT_XFER_ISOC
,
230 .wMaxPacketSize
= cpu_to_le16(1024),
234 static struct usb_ss_ep_comp_descriptor ss_iso_source_comp_desc
= {
235 .bLength
= USB_DT_SS_EP_COMP_SIZE
,
236 .bDescriptorType
= USB_DT_SS_ENDPOINT_COMP
,
240 .wBytesPerInterval
= cpu_to_le16(1024),
243 static struct usb_endpoint_descriptor ss_iso_sink_desc
= {
244 .bLength
= USB_DT_ENDPOINT_SIZE
,
245 .bDescriptorType
= USB_DT_ENDPOINT
,
247 .bmAttributes
= USB_ENDPOINT_XFER_ISOC
,
248 .wMaxPacketSize
= cpu_to_le16(1024),
252 static struct usb_ss_ep_comp_descriptor ss_iso_sink_comp_desc
= {
253 .bLength
= USB_DT_SS_EP_COMP_SIZE
,
254 .bDescriptorType
= USB_DT_SS_ENDPOINT_COMP
,
258 .wBytesPerInterval
= cpu_to_le16(1024),
261 static struct usb_descriptor_header
*ss_source_sink_descs
[] = {
262 (struct usb_descriptor_header
*) &source_sink_intf_alt0
,
263 (struct usb_descriptor_header
*) &ss_source_desc
,
264 (struct usb_descriptor_header
*) &ss_source_comp_desc
,
265 (struct usb_descriptor_header
*) &ss_sink_desc
,
266 (struct usb_descriptor_header
*) &ss_sink_comp_desc
,
267 (struct usb_descriptor_header
*) &source_sink_intf_alt1
,
268 #define SS_ALT_IFC_1_OFFSET 5
269 (struct usb_descriptor_header
*) &ss_source_desc
,
270 (struct usb_descriptor_header
*) &ss_source_comp_desc
,
271 (struct usb_descriptor_header
*) &ss_sink_desc
,
272 (struct usb_descriptor_header
*) &ss_sink_comp_desc
,
273 (struct usb_descriptor_header
*) &ss_iso_source_desc
,
274 (struct usb_descriptor_header
*) &ss_iso_source_comp_desc
,
275 (struct usb_descriptor_header
*) &ss_iso_sink_desc
,
276 (struct usb_descriptor_header
*) &ss_iso_sink_comp_desc
,
280 /* function-specific strings: */
282 static struct usb_string strings_sourcesink
[] = {
283 [0].s
= "source and sink data",
284 { } /* end of list */
287 static struct usb_gadget_strings stringtab_sourcesink
= {
288 .language
= 0x0409, /* en-us */
289 .strings
= strings_sourcesink
,
292 static struct usb_gadget_strings
*sourcesink_strings
[] = {
293 &stringtab_sourcesink
,
297 /*-------------------------------------------------------------------------*/
299 static inline struct usb_request
*ss_alloc_ep_req(struct usb_ep
*ep
, int len
)
301 struct f_sourcesink
*ss
= ep
->driver_data
;
303 return alloc_ep_req(ep
, len
, ss
->buflen
);
306 void free_ep_req(struct usb_ep
*ep
, struct usb_request
*req
)
309 usb_ep_free_request(ep
, req
);
312 static void disable_ep(struct usb_composite_dev
*cdev
, struct usb_ep
*ep
)
316 value
= usb_ep_disable(ep
);
318 DBG(cdev
, "disable %s --> %d\n", ep
->name
, value
);
321 void disable_endpoints(struct usb_composite_dev
*cdev
,
322 struct usb_ep
*in
, struct usb_ep
*out
,
323 struct usb_ep
*iso_in
, struct usb_ep
*iso_out
)
325 disable_ep(cdev
, in
);
326 disable_ep(cdev
, out
);
328 disable_ep(cdev
, iso_in
);
330 disable_ep(cdev
, iso_out
);
334 sourcesink_bind(struct usb_configuration
*c
, struct usb_function
*f
)
336 struct usb_composite_dev
*cdev
= c
->cdev
;
337 struct f_sourcesink
*ss
= func_to_ss(f
);
341 /* allocate interface ID(s) */
342 id
= usb_interface_id(c
, f
);
345 source_sink_intf_alt0
.bInterfaceNumber
= id
;
346 source_sink_intf_alt1
.bInterfaceNumber
= id
;
348 /* allocate bulk endpoints */
349 ss
->in_ep
= usb_ep_autoconfig(cdev
->gadget
, &fs_source_desc
);
352 ERROR(cdev
, "%s: can't autoconfigure on %s\n",
353 f
->name
, cdev
->gadget
->name
);
357 ss
->out_ep
= usb_ep_autoconfig(cdev
->gadget
, &fs_sink_desc
);
361 /* sanity check the isoc module parameters */
362 if (ss
->isoc_interval
< 1)
363 ss
->isoc_interval
= 1;
364 if (ss
->isoc_interval
> 16)
365 ss
->isoc_interval
= 16;
366 if (ss
->isoc_mult
> 2)
368 if (ss
->isoc_maxburst
> 15)
369 ss
->isoc_maxburst
= 15;
371 /* fill in the FS isoc descriptors from the module parameters */
372 fs_iso_source_desc
.wMaxPacketSize
= ss
->isoc_maxpacket
> 1023 ?
373 1023 : ss
->isoc_maxpacket
;
374 fs_iso_source_desc
.bInterval
= ss
->isoc_interval
;
375 fs_iso_sink_desc
.wMaxPacketSize
= ss
->isoc_maxpacket
> 1023 ?
376 1023 : ss
->isoc_maxpacket
;
377 fs_iso_sink_desc
.bInterval
= ss
->isoc_interval
;
379 /* allocate iso endpoints */
380 ss
->iso_in_ep
= usb_ep_autoconfig(cdev
->gadget
, &fs_iso_source_desc
);
384 ss
->iso_out_ep
= usb_ep_autoconfig(cdev
->gadget
, &fs_iso_sink_desc
);
385 if (!ss
->iso_out_ep
) {
386 usb_ep_autoconfig_release(ss
->iso_in_ep
);
387 ss
->iso_in_ep
= NULL
;
390 * We still want to work even if the UDC doesn't have isoc
391 * endpoints, so null out the alt interface that contains
394 fs_source_sink_descs
[FS_ALT_IFC_1_OFFSET
] = NULL
;
395 hs_source_sink_descs
[HS_ALT_IFC_1_OFFSET
] = NULL
;
396 ss_source_sink_descs
[SS_ALT_IFC_1_OFFSET
] = NULL
;
399 if (ss
->isoc_maxpacket
> 1024)
400 ss
->isoc_maxpacket
= 1024;
402 /* support high speed hardware */
403 hs_source_desc
.bEndpointAddress
= fs_source_desc
.bEndpointAddress
;
404 hs_sink_desc
.bEndpointAddress
= fs_sink_desc
.bEndpointAddress
;
407 * Fill in the HS isoc descriptors from the module parameters.
408 * We assume that the user knows what they are doing and won't
409 * give parameters that their UDC doesn't support.
411 hs_iso_source_desc
.wMaxPacketSize
= ss
->isoc_maxpacket
;
412 hs_iso_source_desc
.wMaxPacketSize
|= ss
->isoc_mult
<< 11;
413 hs_iso_source_desc
.bInterval
= ss
->isoc_interval
;
414 hs_iso_source_desc
.bEndpointAddress
=
415 fs_iso_source_desc
.bEndpointAddress
;
417 hs_iso_sink_desc
.wMaxPacketSize
= ss
->isoc_maxpacket
;
418 hs_iso_sink_desc
.wMaxPacketSize
|= ss
->isoc_mult
<< 11;
419 hs_iso_sink_desc
.bInterval
= ss
->isoc_interval
;
420 hs_iso_sink_desc
.bEndpointAddress
= fs_iso_sink_desc
.bEndpointAddress
;
422 /* support super speed hardware */
423 ss_source_desc
.bEndpointAddress
=
424 fs_source_desc
.bEndpointAddress
;
425 ss_sink_desc
.bEndpointAddress
=
426 fs_sink_desc
.bEndpointAddress
;
429 * Fill in the SS isoc descriptors from the module parameters.
430 * We assume that the user knows what they are doing and won't
431 * give parameters that their UDC doesn't support.
433 ss_iso_source_desc
.wMaxPacketSize
= ss
->isoc_maxpacket
;
434 ss_iso_source_desc
.bInterval
= ss
->isoc_interval
;
435 ss_iso_source_comp_desc
.bmAttributes
= ss
->isoc_mult
;
436 ss_iso_source_comp_desc
.bMaxBurst
= ss
->isoc_maxburst
;
437 ss_iso_source_comp_desc
.wBytesPerInterval
= ss
->isoc_maxpacket
*
438 (ss
->isoc_mult
+ 1) * (ss
->isoc_maxburst
+ 1);
439 ss_iso_source_desc
.bEndpointAddress
=
440 fs_iso_source_desc
.bEndpointAddress
;
442 ss_iso_sink_desc
.wMaxPacketSize
= ss
->isoc_maxpacket
;
443 ss_iso_sink_desc
.bInterval
= ss
->isoc_interval
;
444 ss_iso_sink_comp_desc
.bmAttributes
= ss
->isoc_mult
;
445 ss_iso_sink_comp_desc
.bMaxBurst
= ss
->isoc_maxburst
;
446 ss_iso_sink_comp_desc
.wBytesPerInterval
= ss
->isoc_maxpacket
*
447 (ss
->isoc_mult
+ 1) * (ss
->isoc_maxburst
+ 1);
448 ss_iso_sink_desc
.bEndpointAddress
= fs_iso_sink_desc
.bEndpointAddress
;
450 ret
= usb_assign_descriptors(f
, fs_source_sink_descs
,
451 hs_source_sink_descs
, ss_source_sink_descs
);
455 DBG(cdev
, "%s speed %s: IN/%s, OUT/%s, ISO-IN/%s, ISO-OUT/%s\n",
456 (gadget_is_superspeed(c
->cdev
->gadget
) ? "super" :
457 (gadget_is_dualspeed(c
->cdev
->gadget
) ? "dual" : "full")),
458 f
->name
, ss
->in_ep
->name
, ss
->out_ep
->name
,
459 ss
->iso_in_ep
? ss
->iso_in_ep
->name
: "<none>",
460 ss
->iso_out_ep
? ss
->iso_out_ep
->name
: "<none>");
465 sourcesink_free_func(struct usb_function
*f
)
467 struct f_ss_opts
*opts
;
469 opts
= container_of(f
->fi
, struct f_ss_opts
, func_inst
);
471 mutex_lock(&opts
->lock
);
473 mutex_unlock(&opts
->lock
);
475 usb_free_all_descriptors(f
);
476 kfree(func_to_ss(f
));
479 /* optionally require specific source/sink data patterns */
480 static int check_read_data(struct f_sourcesink
*ss
, struct usb_request
*req
)
484 struct usb_composite_dev
*cdev
= ss
->function
.config
->cdev
;
485 int max_packet_size
= le16_to_cpu(ss
->out_ep
->desc
->wMaxPacketSize
);
487 if (ss
->pattern
== 2)
490 for (i
= 0; i
< req
->actual
; i
++, buf
++) {
491 switch (ss
->pattern
) {
493 /* all-zeroes has no synchronization issues */
499 /* "mod63" stays in sync with short-terminated transfers,
500 * OR otherwise when host and gadget agree on how large
501 * each usb transfer request should be. Resync is done
502 * with set_interface or set_config. (We *WANT* it to
503 * get quickly out of sync if controllers or their drivers
504 * stutter for any reason, including buffer duplication...)
507 if (*buf
== (u8
)((i
% max_packet_size
) % 63))
511 ERROR(cdev
, "bad OUT byte, buf[%d] = %d\n", i
, *buf
);
512 usb_ep_set_halt(ss
->out_ep
);
518 static void reinit_write_data(struct usb_ep
*ep
, struct usb_request
*req
)
522 int max_packet_size
= le16_to_cpu(ep
->desc
->wMaxPacketSize
);
523 struct f_sourcesink
*ss
= ep
->driver_data
;
525 switch (ss
->pattern
) {
527 memset(req
->buf
, 0, req
->length
);
530 for (i
= 0; i
< req
->length
; i
++)
531 *buf
++ = (u8
) ((i
% max_packet_size
) % 63);
538 static void source_sink_complete(struct usb_ep
*ep
, struct usb_request
*req
)
540 struct usb_composite_dev
*cdev
;
541 struct f_sourcesink
*ss
= ep
->driver_data
;
542 int status
= req
->status
;
544 /* driver_data will be null if ep has been disabled */
548 cdev
= ss
->function
.config
->cdev
;
552 case 0: /* normal completion? */
553 if (ep
== ss
->out_ep
) {
554 check_read_data(ss
, req
);
555 if (ss
->pattern
!= 2)
556 memset(req
->buf
, 0x55, req
->length
);
560 /* this endpoint is normally active while we're configured */
561 case -ECONNABORTED
: /* hardware forced ep reset */
562 case -ECONNRESET
: /* request dequeued */
563 case -ESHUTDOWN
: /* disconnect from host */
564 VDBG(cdev
, "%s gone (%d), %d/%d\n", ep
->name
, status
,
565 req
->actual
, req
->length
);
566 if (ep
== ss
->out_ep
)
567 check_read_data(ss
, req
);
568 free_ep_req(ep
, req
);
571 case -EOVERFLOW
: /* buffer overrun on read means that
572 * we didn't provide a big enough
577 DBG(cdev
, "%s complete --> %d, %d/%d\n", ep
->name
,
578 status
, req
->actual
, req
->length
);
580 case -EREMOTEIO
: /* short read */
584 status
= usb_ep_queue(ep
, req
, GFP_ATOMIC
);
586 ERROR(cdev
, "kill %s: resubmit %d bytes --> %d\n",
587 ep
->name
, req
->length
, status
);
589 /* FIXME recover later ... somehow */
593 static int source_sink_start_ep(struct f_sourcesink
*ss
, bool is_in
,
594 bool is_iso
, int speed
)
597 struct usb_request
*req
;
600 for (i
= 0; i
< 8; i
++) {
603 case USB_SPEED_SUPER
:
604 size
= ss
->isoc_maxpacket
*
605 (ss
->isoc_mult
+ 1) *
606 (ss
->isoc_maxburst
+ 1);
609 size
= ss
->isoc_maxpacket
* (ss
->isoc_mult
+ 1);
612 size
= ss
->isoc_maxpacket
> 1023 ?
613 1023 : ss
->isoc_maxpacket
;
616 ep
= is_in
? ss
->iso_in_ep
: ss
->iso_out_ep
;
617 req
= ss_alloc_ep_req(ep
, size
);
619 ep
= is_in
? ss
->in_ep
: ss
->out_ep
;
620 req
= ss_alloc_ep_req(ep
, 0);
626 req
->complete
= source_sink_complete
;
628 reinit_write_data(ep
, req
);
629 else if (ss
->pattern
!= 2)
630 memset(req
->buf
, 0x55, req
->length
);
632 status
= usb_ep_queue(ep
, req
, GFP_ATOMIC
);
634 struct usb_composite_dev
*cdev
;
636 cdev
= ss
->function
.config
->cdev
;
637 ERROR(cdev
, "start %s%s %s --> %d\n",
638 is_iso
? "ISO-" : "", is_in
? "IN" : "OUT",
640 free_ep_req(ep
, req
);
650 static void disable_source_sink(struct f_sourcesink
*ss
)
652 struct usb_composite_dev
*cdev
;
654 cdev
= ss
->function
.config
->cdev
;
655 disable_endpoints(cdev
, ss
->in_ep
, ss
->out_ep
, ss
->iso_in_ep
,
657 VDBG(cdev
, "%s disabled\n", ss
->function
.name
);
661 enable_source_sink(struct usb_composite_dev
*cdev
, struct f_sourcesink
*ss
,
665 int speed
= cdev
->gadget
->speed
;
668 /* one bulk endpoint writes (sources) zeroes IN (to the host) */
670 result
= config_ep_by_speed(cdev
->gadget
, &(ss
->function
), ep
);
673 result
= usb_ep_enable(ep
);
676 ep
->driver_data
= ss
;
678 result
= source_sink_start_ep(ss
, true, false, speed
);
686 /* one bulk endpoint reads (sinks) anything OUT (from the host) */
688 result
= config_ep_by_speed(cdev
->gadget
, &(ss
->function
), ep
);
691 result
= usb_ep_enable(ep
);
694 ep
->driver_data
= ss
;
696 result
= source_sink_start_ep(ss
, false, false, speed
);
707 /* one iso endpoint writes (sources) zeroes IN (to the host) */
710 result
= config_ep_by_speed(cdev
->gadget
, &(ss
->function
), ep
);
713 result
= usb_ep_enable(ep
);
716 ep
->driver_data
= ss
;
718 result
= source_sink_start_ep(ss
, true, true, speed
);
728 /* one iso endpoint reads (sinks) anything OUT (from the host) */
731 result
= config_ep_by_speed(cdev
->gadget
, &(ss
->function
), ep
);
734 result
= usb_ep_enable(ep
);
737 ep
->driver_data
= ss
;
739 result
= source_sink_start_ep(ss
, false, true, speed
);
748 DBG(cdev
, "%s enabled, alt intf %d\n", ss
->function
.name
, alt
);
752 static int sourcesink_set_alt(struct usb_function
*f
,
753 unsigned intf
, unsigned alt
)
755 struct f_sourcesink
*ss
= func_to_ss(f
);
756 struct usb_composite_dev
*cdev
= f
->config
->cdev
;
758 disable_source_sink(ss
);
759 return enable_source_sink(cdev
, ss
, alt
);
762 static int sourcesink_get_alt(struct usb_function
*f
, unsigned intf
)
764 struct f_sourcesink
*ss
= func_to_ss(f
);
769 static void sourcesink_disable(struct usb_function
*f
)
771 struct f_sourcesink
*ss
= func_to_ss(f
);
773 disable_source_sink(ss
);
776 /*-------------------------------------------------------------------------*/
778 static int sourcesink_setup(struct usb_function
*f
,
779 const struct usb_ctrlrequest
*ctrl
)
781 struct usb_configuration
*c
= f
->config
;
782 struct usb_request
*req
= c
->cdev
->req
;
783 int value
= -EOPNOTSUPP
;
784 u16 w_index
= le16_to_cpu(ctrl
->wIndex
);
785 u16 w_value
= le16_to_cpu(ctrl
->wValue
);
786 u16 w_length
= le16_to_cpu(ctrl
->wLength
);
788 req
->length
= USB_COMP_EP0_BUFSIZ
;
790 /* composite driver infrastructure handles everything except
791 * the two control test requests.
793 switch (ctrl
->bRequest
) {
796 * These are the same vendor-specific requests supported by
797 * Intel's USB 2.0 compliance test devices. We exceed that
798 * device spec by allowing multiple-packet requests.
800 * NOTE: the Control-OUT data stays in req->buf ... better
801 * would be copying it into a scratch buffer, so that other
802 * requests may safely intervene.
804 case 0x5b: /* control WRITE test -- fill the buffer */
805 if (ctrl
->bRequestType
!= (USB_DIR_OUT
|USB_TYPE_VENDOR
))
807 if (w_value
|| w_index
)
809 /* just read that many bytes into the buffer */
810 if (w_length
> req
->length
)
814 case 0x5c: /* control READ test -- return the buffer */
815 if (ctrl
->bRequestType
!= (USB_DIR_IN
|USB_TYPE_VENDOR
))
817 if (w_value
|| w_index
)
819 /* expect those bytes are still in the buffer; send back */
820 if (w_length
> req
->length
)
828 "unknown control req%02x.%02x v%04x i%04x l%d\n",
829 ctrl
->bRequestType
, ctrl
->bRequest
,
830 w_value
, w_index
, w_length
);
833 /* respond with data transfer or status phase? */
835 VDBG(c
->cdev
, "source/sink req%02x.%02x v%04x i%04x l%d\n",
836 ctrl
->bRequestType
, ctrl
->bRequest
,
837 w_value
, w_index
, w_length
);
840 value
= usb_ep_queue(c
->cdev
->gadget
->ep0
, req
, GFP_ATOMIC
);
842 ERROR(c
->cdev
, "source/sink response, err %d\n",
846 /* device either stalls (value < 0) or reports success */
850 static struct usb_function
*source_sink_alloc_func(
851 struct usb_function_instance
*fi
)
853 struct f_sourcesink
*ss
;
854 struct f_ss_opts
*ss_opts
;
856 ss
= kzalloc(sizeof(*ss
), GFP_KERNEL
);
860 ss_opts
= container_of(fi
, struct f_ss_opts
, func_inst
);
862 mutex_lock(&ss_opts
->lock
);
864 mutex_unlock(&ss_opts
->lock
);
866 ss
->pattern
= ss_opts
->pattern
;
867 ss
->isoc_interval
= ss_opts
->isoc_interval
;
868 ss
->isoc_maxpacket
= ss_opts
->isoc_maxpacket
;
869 ss
->isoc_mult
= ss_opts
->isoc_mult
;
870 ss
->isoc_maxburst
= ss_opts
->isoc_maxburst
;
871 ss
->buflen
= ss_opts
->bulk_buflen
;
873 ss
->function
.name
= "source/sink";
874 ss
->function
.bind
= sourcesink_bind
;
875 ss
->function
.set_alt
= sourcesink_set_alt
;
876 ss
->function
.get_alt
= sourcesink_get_alt
;
877 ss
->function
.disable
= sourcesink_disable
;
878 ss
->function
.setup
= sourcesink_setup
;
879 ss
->function
.strings
= sourcesink_strings
;
881 ss
->function
.free_func
= sourcesink_free_func
;
883 return &ss
->function
;
886 static inline struct f_ss_opts
*to_f_ss_opts(struct config_item
*item
)
888 return container_of(to_config_group(item
), struct f_ss_opts
,
892 static void ss_attr_release(struct config_item
*item
)
894 struct f_ss_opts
*ss_opts
= to_f_ss_opts(item
);
896 usb_put_function_instance(&ss_opts
->func_inst
);
899 static struct configfs_item_operations ss_item_ops
= {
900 .release
= ss_attr_release
,
903 static ssize_t
f_ss_opts_pattern_show(struct config_item
*item
, char *page
)
905 struct f_ss_opts
*opts
= to_f_ss_opts(item
);
908 mutex_lock(&opts
->lock
);
909 result
= sprintf(page
, "%u\n", opts
->pattern
);
910 mutex_unlock(&opts
->lock
);
915 static ssize_t
f_ss_opts_pattern_store(struct config_item
*item
,
916 const char *page
, size_t len
)
918 struct f_ss_opts
*opts
= to_f_ss_opts(item
);
922 mutex_lock(&opts
->lock
);
928 ret
= kstrtou8(page
, 0, &num
);
932 if (num
!= 0 && num
!= 1 && num
!= 2) {
940 mutex_unlock(&opts
->lock
);
944 CONFIGFS_ATTR(f_ss_opts_
, pattern
);
946 static ssize_t
f_ss_opts_isoc_interval_show(struct config_item
*item
, char *page
)
948 struct f_ss_opts
*opts
= to_f_ss_opts(item
);
951 mutex_lock(&opts
->lock
);
952 result
= sprintf(page
, "%u\n", opts
->isoc_interval
);
953 mutex_unlock(&opts
->lock
);
958 static ssize_t
f_ss_opts_isoc_interval_store(struct config_item
*item
,
959 const char *page
, size_t len
)
961 struct f_ss_opts
*opts
= to_f_ss_opts(item
);
965 mutex_lock(&opts
->lock
);
971 ret
= kstrtou8(page
, 0, &num
);
980 opts
->isoc_interval
= num
;
983 mutex_unlock(&opts
->lock
);
987 CONFIGFS_ATTR(f_ss_opts_
, isoc_interval
);
989 static ssize_t
f_ss_opts_isoc_maxpacket_show(struct config_item
*item
, char *page
)
991 struct f_ss_opts
*opts
= to_f_ss_opts(item
);
994 mutex_lock(&opts
->lock
);
995 result
= sprintf(page
, "%u\n", opts
->isoc_maxpacket
);
996 mutex_unlock(&opts
->lock
);
1001 static ssize_t
f_ss_opts_isoc_maxpacket_store(struct config_item
*item
,
1002 const char *page
, size_t len
)
1004 struct f_ss_opts
*opts
= to_f_ss_opts(item
);
1008 mutex_lock(&opts
->lock
);
1014 ret
= kstrtou16(page
, 0, &num
);
1023 opts
->isoc_maxpacket
= num
;
1026 mutex_unlock(&opts
->lock
);
1030 CONFIGFS_ATTR(f_ss_opts_
, isoc_maxpacket
);
1032 static ssize_t
f_ss_opts_isoc_mult_show(struct config_item
*item
, char *page
)
1034 struct f_ss_opts
*opts
= to_f_ss_opts(item
);
1037 mutex_lock(&opts
->lock
);
1038 result
= sprintf(page
, "%u\n", opts
->isoc_mult
);
1039 mutex_unlock(&opts
->lock
);
1044 static ssize_t
f_ss_opts_isoc_mult_store(struct config_item
*item
,
1045 const char *page
, size_t len
)
1047 struct f_ss_opts
*opts
= to_f_ss_opts(item
);
1051 mutex_lock(&opts
->lock
);
1057 ret
= kstrtou8(page
, 0, &num
);
1066 opts
->isoc_mult
= num
;
1069 mutex_unlock(&opts
->lock
);
1073 CONFIGFS_ATTR(f_ss_opts_
, isoc_mult
);
1075 static ssize_t
f_ss_opts_isoc_maxburst_show(struct config_item
*item
, char *page
)
1077 struct f_ss_opts
*opts
= to_f_ss_opts(item
);
1080 mutex_lock(&opts
->lock
);
1081 result
= sprintf(page
, "%u\n", opts
->isoc_maxburst
);
1082 mutex_unlock(&opts
->lock
);
1087 static ssize_t
f_ss_opts_isoc_maxburst_store(struct config_item
*item
,
1088 const char *page
, size_t len
)
1090 struct f_ss_opts
*opts
= to_f_ss_opts(item
);
1094 mutex_lock(&opts
->lock
);
1100 ret
= kstrtou8(page
, 0, &num
);
1109 opts
->isoc_maxburst
= num
;
1112 mutex_unlock(&opts
->lock
);
1116 CONFIGFS_ATTR(f_ss_opts_
, isoc_maxburst
);
1118 static ssize_t
f_ss_opts_bulk_buflen_show(struct config_item
*item
, char *page
)
1120 struct f_ss_opts
*opts
= to_f_ss_opts(item
);
1123 mutex_lock(&opts
->lock
);
1124 result
= sprintf(page
, "%u\n", opts
->bulk_buflen
);
1125 mutex_unlock(&opts
->lock
);
1130 static ssize_t
f_ss_opts_bulk_buflen_store(struct config_item
*item
,
1131 const char *page
, size_t len
)
1133 struct f_ss_opts
*opts
= to_f_ss_opts(item
);
1137 mutex_lock(&opts
->lock
);
1143 ret
= kstrtou32(page
, 0, &num
);
1147 opts
->bulk_buflen
= num
;
1150 mutex_unlock(&opts
->lock
);
1154 CONFIGFS_ATTR(f_ss_opts_
, bulk_buflen
);
1156 static struct configfs_attribute
*ss_attrs
[] = {
1157 &f_ss_opts_attr_pattern
,
1158 &f_ss_opts_attr_isoc_interval
,
1159 &f_ss_opts_attr_isoc_maxpacket
,
1160 &f_ss_opts_attr_isoc_mult
,
1161 &f_ss_opts_attr_isoc_maxburst
,
1162 &f_ss_opts_attr_bulk_buflen
,
1166 static struct config_item_type ss_func_type
= {
1167 .ct_item_ops
= &ss_item_ops
,
1168 .ct_attrs
= ss_attrs
,
1169 .ct_owner
= THIS_MODULE
,
1172 static void source_sink_free_instance(struct usb_function_instance
*fi
)
1174 struct f_ss_opts
*ss_opts
;
1176 ss_opts
= container_of(fi
, struct f_ss_opts
, func_inst
);
1180 static struct usb_function_instance
*source_sink_alloc_inst(void)
1182 struct f_ss_opts
*ss_opts
;
1184 ss_opts
= kzalloc(sizeof(*ss_opts
), GFP_KERNEL
);
1186 return ERR_PTR(-ENOMEM
);
1187 mutex_init(&ss_opts
->lock
);
1188 ss_opts
->func_inst
.free_func_inst
= source_sink_free_instance
;
1189 ss_opts
->isoc_interval
= GZERO_ISOC_INTERVAL
;
1190 ss_opts
->isoc_maxpacket
= GZERO_ISOC_MAXPACKET
;
1191 ss_opts
->bulk_buflen
= GZERO_BULK_BUFLEN
;
1193 config_group_init_type_name(&ss_opts
->func_inst
.group
, "",
1196 return &ss_opts
->func_inst
;
1198 DECLARE_USB_FUNCTION(SourceSink
, source_sink_alloc_inst
,
1199 source_sink_alloc_func
);
1201 static int __init
sslb_modinit(void)
1205 ret
= usb_function_register(&SourceSinkusb_func
);
1210 usb_function_unregister(&SourceSinkusb_func
);
1213 static void __exit
sslb_modexit(void)
1215 usb_function_unregister(&SourceSinkusb_func
);
1218 module_init(sslb_modinit
);
1219 module_exit(sslb_modexit
);
1221 MODULE_LICENSE("GPL");