1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * f_sourcesink.c - USB peripheral source/sink configuration driver |
4 | * |
5 | * Copyright (C) 2003-2008 David Brownell |
6 | * Copyright (C) 2008 by Nokia Corporation |
7 | */ |
8 | |
9 | /* #define VERBOSE_DEBUG */ |
10 | |
11 | #include <linux/slab.h> |
12 | #include <linux/kernel.h> |
13 | #include <linux/device.h> |
14 | #include <linux/module.h> |
15 | #include <linux/usb/composite.h> |
16 | #include <linux/err.h> |
17 | |
18 | #include "g_zero.h" |
19 | #include "u_f.h" |
20 | |
21 | /* |
22 | * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripheral |
23 | * controller drivers. |
24 | * |
25 | * This just sinks bulk packets OUT to the peripheral and sources them IN |
26 | * to the host, optionally with specific data patterns for integrity tests. |
27 | * As such it supports basic functionality and load tests. |
28 | * |
29 | * In terms of control messaging, this supports all the standard requests |
30 | * plus two that support control-OUT tests. If the optional "autoresume" |
31 | * mode is enabled, it provides good functional coverage for the "USBCV" |
32 | * test harness from USB-IF. |
33 | */ |
34 | struct f_sourcesink { |
35 | struct usb_function function; |
36 | |
37 | struct usb_ep *in_ep; |
38 | struct usb_ep *out_ep; |
39 | struct usb_ep *iso_in_ep; |
40 | struct usb_ep *iso_out_ep; |
41 | int cur_alt; |
42 | |
43 | unsigned pattern; |
44 | unsigned isoc_interval; |
45 | unsigned isoc_maxpacket; |
46 | unsigned isoc_mult; |
47 | unsigned isoc_maxburst; |
48 | unsigned buflen; |
49 | unsigned bulk_qlen; |
50 | unsigned iso_qlen; |
51 | }; |
52 | |
53 | static inline struct f_sourcesink *func_to_ss(struct usb_function *f) |
54 | { |
55 | return container_of(f, struct f_sourcesink, function); |
56 | } |
57 | |
58 | /*-------------------------------------------------------------------------*/ |
59 | |
60 | static struct usb_interface_descriptor source_sink_intf_alt0 = { |
61 | .bLength = USB_DT_INTERFACE_SIZE, |
62 | .bDescriptorType = USB_DT_INTERFACE, |
63 | |
64 | .bAlternateSetting = 0, |
65 | .bNumEndpoints = 2, |
66 | .bInterfaceClass = USB_CLASS_VENDOR_SPEC, |
67 | /* .iInterface = DYNAMIC */ |
68 | }; |
69 | |
70 | static struct usb_interface_descriptor source_sink_intf_alt1 = { |
71 | .bLength = USB_DT_INTERFACE_SIZE, |
72 | .bDescriptorType = USB_DT_INTERFACE, |
73 | |
74 | .bAlternateSetting = 1, |
75 | .bNumEndpoints = 4, |
76 | .bInterfaceClass = USB_CLASS_VENDOR_SPEC, |
77 | /* .iInterface = DYNAMIC */ |
78 | }; |
79 | |
80 | /* full speed support: */ |
81 | |
82 | static struct usb_endpoint_descriptor fs_source_desc = { |
83 | .bLength = USB_DT_ENDPOINT_SIZE, |
84 | .bDescriptorType = USB_DT_ENDPOINT, |
85 | |
86 | .bEndpointAddress = USB_DIR_IN, |
87 | .bmAttributes = USB_ENDPOINT_XFER_BULK, |
88 | }; |
89 | |
90 | static struct usb_endpoint_descriptor fs_sink_desc = { |
91 | .bLength = USB_DT_ENDPOINT_SIZE, |
92 | .bDescriptorType = USB_DT_ENDPOINT, |
93 | |
94 | .bEndpointAddress = USB_DIR_OUT, |
95 | .bmAttributes = USB_ENDPOINT_XFER_BULK, |
96 | }; |
97 | |
98 | static struct usb_endpoint_descriptor fs_iso_source_desc = { |
99 | .bLength = USB_DT_ENDPOINT_SIZE, |
100 | .bDescriptorType = USB_DT_ENDPOINT, |
101 | |
102 | .bEndpointAddress = USB_DIR_IN, |
103 | .bmAttributes = USB_ENDPOINT_XFER_ISOC, |
104 | .wMaxPacketSize = cpu_to_le16(1023), |
105 | .bInterval = 4, |
106 | }; |
107 | |
108 | static struct usb_endpoint_descriptor fs_iso_sink_desc = { |
109 | .bLength = USB_DT_ENDPOINT_SIZE, |
110 | .bDescriptorType = USB_DT_ENDPOINT, |
111 | |
112 | .bEndpointAddress = USB_DIR_OUT, |
113 | .bmAttributes = USB_ENDPOINT_XFER_ISOC, |
114 | .wMaxPacketSize = cpu_to_le16(1023), |
115 | .bInterval = 4, |
116 | }; |
117 | |
118 | static struct usb_descriptor_header *fs_source_sink_descs[] = { |
119 | (struct usb_descriptor_header *) &source_sink_intf_alt0, |
120 | (struct usb_descriptor_header *) &fs_sink_desc, |
121 | (struct usb_descriptor_header *) &fs_source_desc, |
122 | (struct usb_descriptor_header *) &source_sink_intf_alt1, |
123 | #define FS_ALT_IFC_1_OFFSET 3 |
124 | (struct usb_descriptor_header *) &fs_sink_desc, |
125 | (struct usb_descriptor_header *) &fs_source_desc, |
126 | (struct usb_descriptor_header *) &fs_iso_sink_desc, |
127 | (struct usb_descriptor_header *) &fs_iso_source_desc, |
128 | NULL, |
129 | }; |
130 | |
131 | /* high speed support: */ |
132 | |
133 | static struct usb_endpoint_descriptor hs_source_desc = { |
134 | .bLength = USB_DT_ENDPOINT_SIZE, |
135 | .bDescriptorType = USB_DT_ENDPOINT, |
136 | |
137 | .bmAttributes = USB_ENDPOINT_XFER_BULK, |
138 | .wMaxPacketSize = cpu_to_le16(512), |
139 | }; |
140 | |
141 | static struct usb_endpoint_descriptor hs_sink_desc = { |
142 | .bLength = USB_DT_ENDPOINT_SIZE, |
143 | .bDescriptorType = USB_DT_ENDPOINT, |
144 | |
145 | .bmAttributes = USB_ENDPOINT_XFER_BULK, |
146 | .wMaxPacketSize = cpu_to_le16(512), |
147 | }; |
148 | |
149 | static struct usb_endpoint_descriptor hs_iso_source_desc = { |
150 | .bLength = USB_DT_ENDPOINT_SIZE, |
151 | .bDescriptorType = USB_DT_ENDPOINT, |
152 | |
153 | .bmAttributes = USB_ENDPOINT_XFER_ISOC, |
154 | .wMaxPacketSize = cpu_to_le16(1024), |
155 | .bInterval = 4, |
156 | }; |
157 | |
158 | static struct usb_endpoint_descriptor hs_iso_sink_desc = { |
159 | .bLength = USB_DT_ENDPOINT_SIZE, |
160 | .bDescriptorType = USB_DT_ENDPOINT, |
161 | |
162 | .bmAttributes = USB_ENDPOINT_XFER_ISOC, |
163 | .wMaxPacketSize = cpu_to_le16(1024), |
164 | .bInterval = 4, |
165 | }; |
166 | |
167 | static struct usb_descriptor_header *hs_source_sink_descs[] = { |
168 | (struct usb_descriptor_header *) &source_sink_intf_alt0, |
169 | (struct usb_descriptor_header *) &hs_source_desc, |
170 | (struct usb_descriptor_header *) &hs_sink_desc, |
171 | (struct usb_descriptor_header *) &source_sink_intf_alt1, |
172 | #define HS_ALT_IFC_1_OFFSET 3 |
173 | (struct usb_descriptor_header *) &hs_source_desc, |
174 | (struct usb_descriptor_header *) &hs_sink_desc, |
175 | (struct usb_descriptor_header *) &hs_iso_source_desc, |
176 | (struct usb_descriptor_header *) &hs_iso_sink_desc, |
177 | NULL, |
178 | }; |
179 | |
180 | /* super speed support: */ |
181 | |
182 | static struct usb_endpoint_descriptor ss_source_desc = { |
183 | .bLength = USB_DT_ENDPOINT_SIZE, |
184 | .bDescriptorType = USB_DT_ENDPOINT, |
185 | |
186 | .bmAttributes = USB_ENDPOINT_XFER_BULK, |
187 | .wMaxPacketSize = cpu_to_le16(1024), |
188 | }; |
189 | |
190 | static struct usb_ss_ep_comp_descriptor ss_source_comp_desc = { |
191 | .bLength = USB_DT_SS_EP_COMP_SIZE, |
192 | .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, |
193 | |
194 | .bMaxBurst = 0, |
195 | .bmAttributes = 0, |
196 | .wBytesPerInterval = 0, |
197 | }; |
198 | |
199 | static struct usb_endpoint_descriptor ss_sink_desc = { |
200 | .bLength = USB_DT_ENDPOINT_SIZE, |
201 | .bDescriptorType = USB_DT_ENDPOINT, |
202 | |
203 | .bmAttributes = USB_ENDPOINT_XFER_BULK, |
204 | .wMaxPacketSize = cpu_to_le16(1024), |
205 | }; |
206 | |
207 | static struct usb_ss_ep_comp_descriptor ss_sink_comp_desc = { |
208 | .bLength = USB_DT_SS_EP_COMP_SIZE, |
209 | .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, |
210 | |
211 | .bMaxBurst = 0, |
212 | .bmAttributes = 0, |
213 | .wBytesPerInterval = 0, |
214 | }; |
215 | |
216 | static struct usb_endpoint_descriptor ss_iso_source_desc = { |
217 | .bLength = USB_DT_ENDPOINT_SIZE, |
218 | .bDescriptorType = USB_DT_ENDPOINT, |
219 | |
220 | .bmAttributes = USB_ENDPOINT_XFER_ISOC, |
221 | .wMaxPacketSize = cpu_to_le16(1024), |
222 | .bInterval = 4, |
223 | }; |
224 | |
225 | static struct usb_ss_ep_comp_descriptor ss_iso_source_comp_desc = { |
226 | .bLength = USB_DT_SS_EP_COMP_SIZE, |
227 | .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, |
228 | |
229 | .bMaxBurst = 0, |
230 | .bmAttributes = 0, |
231 | .wBytesPerInterval = cpu_to_le16(1024), |
232 | }; |
233 | |
234 | static struct usb_endpoint_descriptor ss_iso_sink_desc = { |
235 | .bLength = USB_DT_ENDPOINT_SIZE, |
236 | .bDescriptorType = USB_DT_ENDPOINT, |
237 | |
238 | .bmAttributes = USB_ENDPOINT_XFER_ISOC, |
239 | .wMaxPacketSize = cpu_to_le16(1024), |
240 | .bInterval = 4, |
241 | }; |
242 | |
243 | static struct usb_ss_ep_comp_descriptor ss_iso_sink_comp_desc = { |
244 | .bLength = USB_DT_SS_EP_COMP_SIZE, |
245 | .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, |
246 | |
247 | .bMaxBurst = 0, |
248 | .bmAttributes = 0, |
249 | .wBytesPerInterval = cpu_to_le16(1024), |
250 | }; |
251 | |
252 | static struct usb_descriptor_header *ss_source_sink_descs[] = { |
253 | (struct usb_descriptor_header *) &source_sink_intf_alt0, |
254 | (struct usb_descriptor_header *) &ss_source_desc, |
255 | (struct usb_descriptor_header *) &ss_source_comp_desc, |
256 | (struct usb_descriptor_header *) &ss_sink_desc, |
257 | (struct usb_descriptor_header *) &ss_sink_comp_desc, |
258 | (struct usb_descriptor_header *) &source_sink_intf_alt1, |
259 | #define SS_ALT_IFC_1_OFFSET 5 |
260 | (struct usb_descriptor_header *) &ss_source_desc, |
261 | (struct usb_descriptor_header *) &ss_source_comp_desc, |
262 | (struct usb_descriptor_header *) &ss_sink_desc, |
263 | (struct usb_descriptor_header *) &ss_sink_comp_desc, |
264 | (struct usb_descriptor_header *) &ss_iso_source_desc, |
265 | (struct usb_descriptor_header *) &ss_iso_source_comp_desc, |
266 | (struct usb_descriptor_header *) &ss_iso_sink_desc, |
267 | (struct usb_descriptor_header *) &ss_iso_sink_comp_desc, |
268 | NULL, |
269 | }; |
270 | |
271 | /* function-specific strings: */ |
272 | |
273 | static struct usb_string strings_sourcesink[] = { |
274 | [0].s = "source and sink data" , |
275 | { } /* end of list */ |
276 | }; |
277 | |
278 | static struct usb_gadget_strings stringtab_sourcesink = { |
279 | .language = 0x0409, /* en-us */ |
280 | .strings = strings_sourcesink, |
281 | }; |
282 | |
283 | static struct usb_gadget_strings *sourcesink_strings[] = { |
284 | &stringtab_sourcesink, |
285 | NULL, |
286 | }; |
287 | |
288 | /*-------------------------------------------------------------------------*/ |
289 | |
290 | static inline struct usb_request *ss_alloc_ep_req(struct usb_ep *ep, int len) |
291 | { |
292 | return alloc_ep_req(ep, len); |
293 | } |
294 | |
295 | static void disable_ep(struct usb_composite_dev *cdev, struct usb_ep *ep) |
296 | { |
297 | int value; |
298 | |
299 | value = usb_ep_disable(ep); |
300 | if (value < 0) |
301 | DBG(cdev, "disable %s --> %d\n" , ep->name, value); |
302 | } |
303 | |
304 | void disable_endpoints(struct usb_composite_dev *cdev, |
305 | struct usb_ep *in, struct usb_ep *out, |
306 | struct usb_ep *iso_in, struct usb_ep *iso_out) |
307 | { |
308 | disable_ep(cdev, ep: in); |
309 | disable_ep(cdev, ep: out); |
310 | if (iso_in) |
311 | disable_ep(cdev, ep: iso_in); |
312 | if (iso_out) |
313 | disable_ep(cdev, ep: iso_out); |
314 | } |
315 | |
316 | static int |
317 | sourcesink_bind(struct usb_configuration *c, struct usb_function *f) |
318 | { |
319 | struct usb_composite_dev *cdev = c->cdev; |
320 | struct f_sourcesink *ss = func_to_ss(f); |
321 | int id; |
322 | int ret; |
323 | |
324 | /* allocate interface ID(s) */ |
325 | id = usb_interface_id(c, f); |
326 | if (id < 0) |
327 | return id; |
328 | source_sink_intf_alt0.bInterfaceNumber = id; |
329 | source_sink_intf_alt1.bInterfaceNumber = id; |
330 | |
331 | /* allocate bulk endpoints */ |
332 | ss->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc); |
333 | if (!ss->in_ep) { |
334 | autoconf_fail: |
335 | ERROR(cdev, "%s: can't autoconfigure on %s\n" , |
336 | f->name, cdev->gadget->name); |
337 | return -ENODEV; |
338 | } |
339 | |
340 | ss->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_sink_desc); |
341 | if (!ss->out_ep) |
342 | goto autoconf_fail; |
343 | |
344 | /* sanity check the isoc module parameters */ |
345 | if (ss->isoc_interval < 1) |
346 | ss->isoc_interval = 1; |
347 | if (ss->isoc_interval > 16) |
348 | ss->isoc_interval = 16; |
349 | if (ss->isoc_mult > 2) |
350 | ss->isoc_mult = 2; |
351 | if (ss->isoc_maxburst > 15) |
352 | ss->isoc_maxburst = 15; |
353 | |
354 | /* fill in the FS isoc descriptors from the module parameters */ |
355 | fs_iso_source_desc.wMaxPacketSize = ss->isoc_maxpacket > 1023 ? |
356 | 1023 : ss->isoc_maxpacket; |
357 | fs_iso_source_desc.bInterval = ss->isoc_interval; |
358 | fs_iso_sink_desc.wMaxPacketSize = ss->isoc_maxpacket > 1023 ? |
359 | 1023 : ss->isoc_maxpacket; |
360 | fs_iso_sink_desc.bInterval = ss->isoc_interval; |
361 | |
362 | /* allocate iso endpoints */ |
363 | ss->iso_in_ep = usb_ep_autoconfig(cdev->gadget, &fs_iso_source_desc); |
364 | if (!ss->iso_in_ep) |
365 | goto no_iso; |
366 | |
367 | ss->iso_out_ep = usb_ep_autoconfig(cdev->gadget, &fs_iso_sink_desc); |
368 | if (!ss->iso_out_ep) { |
369 | usb_ep_autoconfig_release(ss->iso_in_ep); |
370 | ss->iso_in_ep = NULL; |
371 | no_iso: |
372 | /* |
373 | * We still want to work even if the UDC doesn't have isoc |
374 | * endpoints, so null out the alt interface that contains |
375 | * them and continue. |
376 | */ |
377 | fs_source_sink_descs[FS_ALT_IFC_1_OFFSET] = NULL; |
378 | hs_source_sink_descs[HS_ALT_IFC_1_OFFSET] = NULL; |
379 | ss_source_sink_descs[SS_ALT_IFC_1_OFFSET] = NULL; |
380 | } |
381 | |
382 | if (ss->isoc_maxpacket > 1024) |
383 | ss->isoc_maxpacket = 1024; |
384 | |
385 | /* support high speed hardware */ |
386 | hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress; |
387 | hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress; |
388 | |
389 | /* |
390 | * Fill in the HS isoc descriptors from the module parameters. |
391 | * We assume that the user knows what they are doing and won't |
392 | * give parameters that their UDC doesn't support. |
393 | */ |
394 | hs_iso_source_desc.wMaxPacketSize = ss->isoc_maxpacket; |
395 | hs_iso_source_desc.wMaxPacketSize |= ss->isoc_mult << 11; |
396 | hs_iso_source_desc.bInterval = ss->isoc_interval; |
397 | hs_iso_source_desc.bEndpointAddress = |
398 | fs_iso_source_desc.bEndpointAddress; |
399 | |
400 | hs_iso_sink_desc.wMaxPacketSize = ss->isoc_maxpacket; |
401 | hs_iso_sink_desc.wMaxPacketSize |= ss->isoc_mult << 11; |
402 | hs_iso_sink_desc.bInterval = ss->isoc_interval; |
403 | hs_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress; |
404 | |
405 | /* support super speed hardware */ |
406 | ss_source_desc.bEndpointAddress = |
407 | fs_source_desc.bEndpointAddress; |
408 | ss_sink_desc.bEndpointAddress = |
409 | fs_sink_desc.bEndpointAddress; |
410 | |
411 | /* |
412 | * Fill in the SS isoc descriptors from the module parameters. |
413 | * We assume that the user knows what they are doing and won't |
414 | * give parameters that their UDC doesn't support. |
415 | */ |
416 | ss_iso_source_desc.wMaxPacketSize = ss->isoc_maxpacket; |
417 | ss_iso_source_desc.bInterval = ss->isoc_interval; |
418 | ss_iso_source_comp_desc.bmAttributes = ss->isoc_mult; |
419 | ss_iso_source_comp_desc.bMaxBurst = ss->isoc_maxburst; |
420 | ss_iso_source_comp_desc.wBytesPerInterval = ss->isoc_maxpacket * |
421 | (ss->isoc_mult + 1) * (ss->isoc_maxburst + 1); |
422 | ss_iso_source_desc.bEndpointAddress = |
423 | fs_iso_source_desc.bEndpointAddress; |
424 | |
425 | ss_iso_sink_desc.wMaxPacketSize = ss->isoc_maxpacket; |
426 | ss_iso_sink_desc.bInterval = ss->isoc_interval; |
427 | ss_iso_sink_comp_desc.bmAttributes = ss->isoc_mult; |
428 | ss_iso_sink_comp_desc.bMaxBurst = ss->isoc_maxburst; |
429 | ss_iso_sink_comp_desc.wBytesPerInterval = ss->isoc_maxpacket * |
430 | (ss->isoc_mult + 1) * (ss->isoc_maxburst + 1); |
431 | ss_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress; |
432 | |
433 | ret = usb_assign_descriptors(f, fs: fs_source_sink_descs, |
434 | hs: hs_source_sink_descs, ss: ss_source_sink_descs, |
435 | ssp: ss_source_sink_descs); |
436 | if (ret) |
437 | return ret; |
438 | |
439 | DBG(cdev, "%s: IN/%s, OUT/%s, ISO-IN/%s, ISO-OUT/%s\n" , |
440 | f->name, ss->in_ep->name, ss->out_ep->name, |
441 | ss->iso_in_ep ? ss->iso_in_ep->name : "<none>" , |
442 | ss->iso_out_ep ? ss->iso_out_ep->name : "<none>" ); |
443 | return 0; |
444 | } |
445 | |
446 | static void |
447 | sourcesink_free_func(struct usb_function *f) |
448 | { |
449 | struct f_ss_opts *opts; |
450 | |
451 | opts = container_of(f->fi, struct f_ss_opts, func_inst); |
452 | |
453 | mutex_lock(&opts->lock); |
454 | opts->refcnt--; |
455 | mutex_unlock(lock: &opts->lock); |
456 | |
457 | usb_free_all_descriptors(f); |
458 | kfree(objp: func_to_ss(f)); |
459 | } |
460 | |
461 | /* optionally require specific source/sink data patterns */ |
462 | static int check_read_data(struct f_sourcesink *ss, struct usb_request *req) |
463 | { |
464 | unsigned i; |
465 | u8 *buf = req->buf; |
466 | struct usb_composite_dev *cdev = ss->function.config->cdev; |
467 | int max_packet_size = le16_to_cpu(ss->out_ep->desc->wMaxPacketSize); |
468 | |
469 | if (ss->pattern == 2) |
470 | return 0; |
471 | |
472 | for (i = 0; i < req->actual; i++, buf++) { |
473 | switch (ss->pattern) { |
474 | |
475 | /* all-zeroes has no synchronization issues */ |
476 | case 0: |
477 | if (*buf == 0) |
478 | continue; |
479 | break; |
480 | |
481 | /* "mod63" stays in sync with short-terminated transfers, |
482 | * OR otherwise when host and gadget agree on how large |
483 | * each usb transfer request should be. Resync is done |
484 | * with set_interface or set_config. (We *WANT* it to |
485 | * get quickly out of sync if controllers or their drivers |
486 | * stutter for any reason, including buffer duplication...) |
487 | */ |
488 | case 1: |
489 | if (*buf == (u8)((i % max_packet_size) % 63)) |
490 | continue; |
491 | break; |
492 | } |
493 | ERROR(cdev, "bad OUT byte, buf[%d] = %d\n" , i, *buf); |
494 | usb_ep_set_halt(ep: ss->out_ep); |
495 | return -EINVAL; |
496 | } |
497 | return 0; |
498 | } |
499 | |
500 | static void reinit_write_data(struct usb_ep *ep, struct usb_request *req) |
501 | { |
502 | unsigned i; |
503 | u8 *buf = req->buf; |
504 | int max_packet_size = le16_to_cpu(ep->desc->wMaxPacketSize); |
505 | struct f_sourcesink *ss = ep->driver_data; |
506 | |
507 | switch (ss->pattern) { |
508 | case 0: |
509 | memset(req->buf, 0, req->length); |
510 | break; |
511 | case 1: |
512 | for (i = 0; i < req->length; i++) |
513 | *buf++ = (u8) ((i % max_packet_size) % 63); |
514 | break; |
515 | case 2: |
516 | break; |
517 | } |
518 | } |
519 | |
520 | static void source_sink_complete(struct usb_ep *ep, struct usb_request *req) |
521 | { |
522 | struct usb_composite_dev *cdev; |
523 | struct f_sourcesink *ss = ep->driver_data; |
524 | int status = req->status; |
525 | |
526 | /* driver_data will be null if ep has been disabled */ |
527 | if (!ss) |
528 | return; |
529 | |
530 | cdev = ss->function.config->cdev; |
531 | |
532 | switch (status) { |
533 | |
534 | case 0: /* normal completion? */ |
535 | if (ep == ss->out_ep) { |
536 | check_read_data(ss, req); |
537 | if (ss->pattern != 2) |
538 | memset(req->buf, 0x55, req->length); |
539 | } |
540 | break; |
541 | |
542 | /* this endpoint is normally active while we're configured */ |
543 | case -ECONNABORTED: /* hardware forced ep reset */ |
544 | case -ECONNRESET: /* request dequeued */ |
545 | case -ESHUTDOWN: /* disconnect from host */ |
546 | VDBG(cdev, "%s gone (%d), %d/%d\n" , ep->name, status, |
547 | req->actual, req->length); |
548 | if (ep == ss->out_ep) |
549 | check_read_data(ss, req); |
550 | free_ep_req(ep, req); |
551 | return; |
552 | |
553 | case -EOVERFLOW: /* buffer overrun on read means that |
554 | * we didn't provide a big enough |
555 | * buffer. |
556 | */ |
557 | default: |
558 | #if 1 |
559 | DBG(cdev, "%s complete --> %d, %d/%d\n" , ep->name, |
560 | status, req->actual, req->length); |
561 | break; |
562 | #endif |
563 | case -EREMOTEIO: /* short read */ |
564 | break; |
565 | } |
566 | |
567 | status = usb_ep_queue(ep, req, GFP_ATOMIC); |
568 | if (status) { |
569 | ERROR(cdev, "kill %s: resubmit %d bytes --> %d\n" , |
570 | ep->name, req->length, status); |
571 | usb_ep_set_halt(ep); |
572 | /* FIXME recover later ... somehow */ |
573 | } |
574 | } |
575 | |
576 | static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in, |
577 | bool is_iso, int speed) |
578 | { |
579 | struct usb_ep *ep; |
580 | struct usb_request *req; |
581 | int i, size, qlen, status = 0; |
582 | |
583 | if (is_iso) { |
584 | switch (speed) { |
585 | case USB_SPEED_SUPER_PLUS: |
586 | case USB_SPEED_SUPER: |
587 | size = ss->isoc_maxpacket * |
588 | (ss->isoc_mult + 1) * |
589 | (ss->isoc_maxburst + 1); |
590 | break; |
591 | case USB_SPEED_HIGH: |
592 | size = ss->isoc_maxpacket * (ss->isoc_mult + 1); |
593 | break; |
594 | default: |
595 | size = ss->isoc_maxpacket > 1023 ? |
596 | 1023 : ss->isoc_maxpacket; |
597 | break; |
598 | } |
599 | ep = is_in ? ss->iso_in_ep : ss->iso_out_ep; |
600 | qlen = ss->iso_qlen; |
601 | } else { |
602 | ep = is_in ? ss->in_ep : ss->out_ep; |
603 | qlen = ss->bulk_qlen; |
604 | size = ss->buflen; |
605 | } |
606 | |
607 | for (i = 0; i < qlen; i++) { |
608 | req = ss_alloc_ep_req(ep, len: size); |
609 | if (!req) |
610 | return -ENOMEM; |
611 | |
612 | req->complete = source_sink_complete; |
613 | if (is_in) |
614 | reinit_write_data(ep, req); |
615 | else if (ss->pattern != 2) |
616 | memset(req->buf, 0x55, req->length); |
617 | |
618 | status = usb_ep_queue(ep, req, GFP_ATOMIC); |
619 | if (status) { |
620 | struct usb_composite_dev *cdev; |
621 | |
622 | cdev = ss->function.config->cdev; |
623 | ERROR(cdev, "start %s%s %s --> %d\n" , |
624 | is_iso ? "ISO-" : "" , is_in ? "IN" : "OUT" , |
625 | ep->name, status); |
626 | free_ep_req(ep, req); |
627 | return status; |
628 | } |
629 | } |
630 | |
631 | return status; |
632 | } |
633 | |
634 | static void disable_source_sink(struct f_sourcesink *ss) |
635 | { |
636 | struct usb_composite_dev *cdev; |
637 | |
638 | cdev = ss->function.config->cdev; |
639 | disable_endpoints(cdev, in: ss->in_ep, out: ss->out_ep, iso_in: ss->iso_in_ep, |
640 | iso_out: ss->iso_out_ep); |
641 | VDBG(cdev, "%s disabled\n" , ss->function.name); |
642 | } |
643 | |
644 | static int |
645 | enable_source_sink(struct usb_composite_dev *cdev, struct f_sourcesink *ss, |
646 | int alt) |
647 | { |
648 | int result = 0; |
649 | int speed = cdev->gadget->speed; |
650 | struct usb_ep *ep; |
651 | |
652 | /* one bulk endpoint writes (sources) zeroes IN (to the host) */ |
653 | ep = ss->in_ep; |
654 | result = config_ep_by_speed(g: cdev->gadget, f: &(ss->function), ep: ep); |
655 | if (result) |
656 | return result; |
657 | result = usb_ep_enable(ep); |
658 | if (result < 0) |
659 | return result; |
660 | ep->driver_data = ss; |
661 | |
662 | result = source_sink_start_ep(ss, is_in: true, is_iso: false, speed); |
663 | if (result < 0) { |
664 | fail: |
665 | ep = ss->in_ep; |
666 | usb_ep_disable(ep); |
667 | return result; |
668 | } |
669 | |
670 | /* one bulk endpoint reads (sinks) anything OUT (from the host) */ |
671 | ep = ss->out_ep; |
672 | result = config_ep_by_speed(g: cdev->gadget, f: &(ss->function), ep: ep); |
673 | if (result) |
674 | goto fail; |
675 | result = usb_ep_enable(ep); |
676 | if (result < 0) |
677 | goto fail; |
678 | ep->driver_data = ss; |
679 | |
680 | result = source_sink_start_ep(ss, is_in: false, is_iso: false, speed); |
681 | if (result < 0) { |
682 | fail2: |
683 | ep = ss->out_ep; |
684 | usb_ep_disable(ep); |
685 | goto fail; |
686 | } |
687 | |
688 | if (alt == 0) |
689 | goto out; |
690 | |
691 | /* one iso endpoint writes (sources) zeroes IN (to the host) */ |
692 | ep = ss->iso_in_ep; |
693 | if (ep) { |
694 | result = config_ep_by_speed(g: cdev->gadget, f: &(ss->function), ep: ep); |
695 | if (result) |
696 | goto fail2; |
697 | result = usb_ep_enable(ep); |
698 | if (result < 0) |
699 | goto fail2; |
700 | ep->driver_data = ss; |
701 | |
702 | result = source_sink_start_ep(ss, is_in: true, is_iso: true, speed); |
703 | if (result < 0) { |
704 | fail3: |
705 | ep = ss->iso_in_ep; |
706 | if (ep) |
707 | usb_ep_disable(ep); |
708 | goto fail2; |
709 | } |
710 | } |
711 | |
712 | /* one iso endpoint reads (sinks) anything OUT (from the host) */ |
713 | ep = ss->iso_out_ep; |
714 | if (ep) { |
715 | result = config_ep_by_speed(g: cdev->gadget, f: &(ss->function), ep: ep); |
716 | if (result) |
717 | goto fail3; |
718 | result = usb_ep_enable(ep); |
719 | if (result < 0) |
720 | goto fail3; |
721 | ep->driver_data = ss; |
722 | |
723 | result = source_sink_start_ep(ss, is_in: false, is_iso: true, speed); |
724 | if (result < 0) { |
725 | usb_ep_disable(ep); |
726 | goto fail3; |
727 | } |
728 | } |
729 | out: |
730 | ss->cur_alt = alt; |
731 | |
732 | DBG(cdev, "%s enabled, alt intf %d\n" , ss->function.name, alt); |
733 | return result; |
734 | } |
735 | |
736 | static int sourcesink_set_alt(struct usb_function *f, |
737 | unsigned intf, unsigned alt) |
738 | { |
739 | struct f_sourcesink *ss = func_to_ss(f); |
740 | struct usb_composite_dev *cdev = f->config->cdev; |
741 | |
742 | disable_source_sink(ss); |
743 | return enable_source_sink(cdev, ss, alt); |
744 | } |
745 | |
746 | static int sourcesink_get_alt(struct usb_function *f, unsigned intf) |
747 | { |
748 | struct f_sourcesink *ss = func_to_ss(f); |
749 | |
750 | return ss->cur_alt; |
751 | } |
752 | |
753 | static void sourcesink_disable(struct usb_function *f) |
754 | { |
755 | struct f_sourcesink *ss = func_to_ss(f); |
756 | |
757 | disable_source_sink(ss); |
758 | } |
759 | |
760 | /*-------------------------------------------------------------------------*/ |
761 | |
762 | static int sourcesink_setup(struct usb_function *f, |
763 | const struct usb_ctrlrequest *ctrl) |
764 | { |
765 | struct usb_configuration *c = f->config; |
766 | struct usb_request *req = c->cdev->req; |
767 | int value = -EOPNOTSUPP; |
768 | u16 w_index = le16_to_cpu(ctrl->wIndex); |
769 | u16 w_value = le16_to_cpu(ctrl->wValue); |
770 | u16 w_length = le16_to_cpu(ctrl->wLength); |
771 | |
772 | req->length = USB_COMP_EP0_BUFSIZ; |
773 | |
774 | /* composite driver infrastructure handles everything except |
775 | * the two control test requests. |
776 | */ |
777 | switch (ctrl->bRequest) { |
778 | |
779 | /* |
780 | * These are the same vendor-specific requests supported by |
781 | * Intel's USB 2.0 compliance test devices. We exceed that |
782 | * device spec by allowing multiple-packet requests. |
783 | * |
784 | * NOTE: the Control-OUT data stays in req->buf ... better |
785 | * would be copying it into a scratch buffer, so that other |
786 | * requests may safely intervene. |
787 | */ |
788 | case 0x5b: /* control WRITE test -- fill the buffer */ |
789 | if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR)) |
790 | goto unknown; |
791 | if (w_value || w_index) |
792 | break; |
793 | /* just read that many bytes into the buffer */ |
794 | if (w_length > req->length) |
795 | break; |
796 | value = w_length; |
797 | break; |
798 | case 0x5c: /* control READ test -- return the buffer */ |
799 | if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR)) |
800 | goto unknown; |
801 | if (w_value || w_index) |
802 | break; |
803 | /* expect those bytes are still in the buffer; send back */ |
804 | if (w_length > req->length) |
805 | break; |
806 | value = w_length; |
807 | break; |
808 | |
809 | default: |
810 | unknown: |
811 | VDBG(c->cdev, |
812 | "unknown control req%02x.%02x v%04x i%04x l%d\n" , |
813 | ctrl->bRequestType, ctrl->bRequest, |
814 | w_value, w_index, w_length); |
815 | } |
816 | |
817 | /* respond with data transfer or status phase? */ |
818 | if (value >= 0) { |
819 | VDBG(c->cdev, "source/sink req%02x.%02x v%04x i%04x l%d\n" , |
820 | ctrl->bRequestType, ctrl->bRequest, |
821 | w_value, w_index, w_length); |
822 | req->zero = 0; |
823 | req->length = value; |
824 | value = usb_ep_queue(ep: c->cdev->gadget->ep0, req, GFP_ATOMIC); |
825 | if (value < 0) |
826 | ERROR(c->cdev, "source/sink response, err %d\n" , |
827 | value); |
828 | } |
829 | |
830 | /* device either stalls (value < 0) or reports success */ |
831 | return value; |
832 | } |
833 | |
834 | static struct usb_function *source_sink_alloc_func( |
835 | struct usb_function_instance *fi) |
836 | { |
837 | struct f_sourcesink *ss; |
838 | struct f_ss_opts *ss_opts; |
839 | |
840 | ss = kzalloc(size: sizeof(*ss), GFP_KERNEL); |
841 | if (!ss) |
842 | return ERR_PTR(error: -ENOMEM); |
843 | |
844 | ss_opts = container_of(fi, struct f_ss_opts, func_inst); |
845 | |
846 | mutex_lock(&ss_opts->lock); |
847 | ss_opts->refcnt++; |
848 | mutex_unlock(lock: &ss_opts->lock); |
849 | |
850 | ss->pattern = ss_opts->pattern; |
851 | ss->isoc_interval = ss_opts->isoc_interval; |
852 | ss->isoc_maxpacket = ss_opts->isoc_maxpacket; |
853 | ss->isoc_mult = ss_opts->isoc_mult; |
854 | ss->isoc_maxburst = ss_opts->isoc_maxburst; |
855 | ss->buflen = ss_opts->bulk_buflen; |
856 | ss->bulk_qlen = ss_opts->bulk_qlen; |
857 | ss->iso_qlen = ss_opts->iso_qlen; |
858 | |
859 | ss->function.name = "source/sink" ; |
860 | ss->function.bind = sourcesink_bind; |
861 | ss->function.set_alt = sourcesink_set_alt; |
862 | ss->function.get_alt = sourcesink_get_alt; |
863 | ss->function.disable = sourcesink_disable; |
864 | ss->function.setup = sourcesink_setup; |
865 | ss->function.strings = sourcesink_strings; |
866 | |
867 | ss->function.free_func = sourcesink_free_func; |
868 | |
869 | return &ss->function; |
870 | } |
871 | |
872 | static inline struct f_ss_opts *to_f_ss_opts(struct config_item *item) |
873 | { |
874 | return container_of(to_config_group(item), struct f_ss_opts, |
875 | func_inst.group); |
876 | } |
877 | |
878 | static void ss_attr_release(struct config_item *item) |
879 | { |
880 | struct f_ss_opts *ss_opts = to_f_ss_opts(item); |
881 | |
882 | usb_put_function_instance(fi: &ss_opts->func_inst); |
883 | } |
884 | |
885 | static struct configfs_item_operations ss_item_ops = { |
886 | .release = ss_attr_release, |
887 | }; |
888 | |
889 | static ssize_t f_ss_opts_pattern_show(struct config_item *item, char *page) |
890 | { |
891 | struct f_ss_opts *opts = to_f_ss_opts(item); |
892 | int result; |
893 | |
894 | mutex_lock(&opts->lock); |
895 | result = sprintf(buf: page, fmt: "%u\n" , opts->pattern); |
896 | mutex_unlock(lock: &opts->lock); |
897 | |
898 | return result; |
899 | } |
900 | |
901 | static ssize_t f_ss_opts_pattern_store(struct config_item *item, |
902 | const char *page, size_t len) |
903 | { |
904 | struct f_ss_opts *opts = to_f_ss_opts(item); |
905 | int ret; |
906 | u8 num; |
907 | |
908 | mutex_lock(&opts->lock); |
909 | if (opts->refcnt) { |
910 | ret = -EBUSY; |
911 | goto end; |
912 | } |
913 | |
914 | ret = kstrtou8(s: page, base: 0, res: &num); |
915 | if (ret) |
916 | goto end; |
917 | |
918 | if (num != 0 && num != 1 && num != 2) { |
919 | ret = -EINVAL; |
920 | goto end; |
921 | } |
922 | |
923 | opts->pattern = num; |
924 | ret = len; |
925 | end: |
926 | mutex_unlock(lock: &opts->lock); |
927 | return ret; |
928 | } |
929 | |
930 | CONFIGFS_ATTR(f_ss_opts_, pattern); |
931 | |
932 | static ssize_t f_ss_opts_isoc_interval_show(struct config_item *item, char *page) |
933 | { |
934 | struct f_ss_opts *opts = to_f_ss_opts(item); |
935 | int result; |
936 | |
937 | mutex_lock(&opts->lock); |
938 | result = sprintf(buf: page, fmt: "%u\n" , opts->isoc_interval); |
939 | mutex_unlock(lock: &opts->lock); |
940 | |
941 | return result; |
942 | } |
943 | |
944 | static ssize_t f_ss_opts_isoc_interval_store(struct config_item *item, |
945 | const char *page, size_t len) |
946 | { |
947 | struct f_ss_opts *opts = to_f_ss_opts(item); |
948 | int ret; |
949 | u8 num; |
950 | |
951 | mutex_lock(&opts->lock); |
952 | if (opts->refcnt) { |
953 | ret = -EBUSY; |
954 | goto end; |
955 | } |
956 | |
957 | ret = kstrtou8(s: page, base: 0, res: &num); |
958 | if (ret) |
959 | goto end; |
960 | |
961 | if (num > 16) { |
962 | ret = -EINVAL; |
963 | goto end; |
964 | } |
965 | |
966 | opts->isoc_interval = num; |
967 | ret = len; |
968 | end: |
969 | mutex_unlock(lock: &opts->lock); |
970 | return ret; |
971 | } |
972 | |
973 | CONFIGFS_ATTR(f_ss_opts_, isoc_interval); |
974 | |
975 | static ssize_t f_ss_opts_isoc_maxpacket_show(struct config_item *item, char *page) |
976 | { |
977 | struct f_ss_opts *opts = to_f_ss_opts(item); |
978 | int result; |
979 | |
980 | mutex_lock(&opts->lock); |
981 | result = sprintf(buf: page, fmt: "%u\n" , opts->isoc_maxpacket); |
982 | mutex_unlock(lock: &opts->lock); |
983 | |
984 | return result; |
985 | } |
986 | |
987 | static ssize_t f_ss_opts_isoc_maxpacket_store(struct config_item *item, |
988 | const char *page, size_t len) |
989 | { |
990 | struct f_ss_opts *opts = to_f_ss_opts(item); |
991 | int ret; |
992 | u16 num; |
993 | |
994 | mutex_lock(&opts->lock); |
995 | if (opts->refcnt) { |
996 | ret = -EBUSY; |
997 | goto end; |
998 | } |
999 | |
1000 | ret = kstrtou16(s: page, base: 0, res: &num); |
1001 | if (ret) |
1002 | goto end; |
1003 | |
1004 | if (num > 1024) { |
1005 | ret = -EINVAL; |
1006 | goto end; |
1007 | } |
1008 | |
1009 | opts->isoc_maxpacket = num; |
1010 | ret = len; |
1011 | end: |
1012 | mutex_unlock(lock: &opts->lock); |
1013 | return ret; |
1014 | } |
1015 | |
1016 | CONFIGFS_ATTR(f_ss_opts_, isoc_maxpacket); |
1017 | |
1018 | static ssize_t f_ss_opts_isoc_mult_show(struct config_item *item, char *page) |
1019 | { |
1020 | struct f_ss_opts *opts = to_f_ss_opts(item); |
1021 | int result; |
1022 | |
1023 | mutex_lock(&opts->lock); |
1024 | result = sprintf(buf: page, fmt: "%u\n" , opts->isoc_mult); |
1025 | mutex_unlock(lock: &opts->lock); |
1026 | |
1027 | return result; |
1028 | } |
1029 | |
1030 | static ssize_t f_ss_opts_isoc_mult_store(struct config_item *item, |
1031 | const char *page, size_t len) |
1032 | { |
1033 | struct f_ss_opts *opts = to_f_ss_opts(item); |
1034 | int ret; |
1035 | u8 num; |
1036 | |
1037 | mutex_lock(&opts->lock); |
1038 | if (opts->refcnt) { |
1039 | ret = -EBUSY; |
1040 | goto end; |
1041 | } |
1042 | |
1043 | ret = kstrtou8(s: page, base: 0, res: &num); |
1044 | if (ret) |
1045 | goto end; |
1046 | |
1047 | if (num > 2) { |
1048 | ret = -EINVAL; |
1049 | goto end; |
1050 | } |
1051 | |
1052 | opts->isoc_mult = num; |
1053 | ret = len; |
1054 | end: |
1055 | mutex_unlock(lock: &opts->lock); |
1056 | return ret; |
1057 | } |
1058 | |
1059 | CONFIGFS_ATTR(f_ss_opts_, isoc_mult); |
1060 | |
1061 | static ssize_t f_ss_opts_isoc_maxburst_show(struct config_item *item, char *page) |
1062 | { |
1063 | struct f_ss_opts *opts = to_f_ss_opts(item); |
1064 | int result; |
1065 | |
1066 | mutex_lock(&opts->lock); |
1067 | result = sprintf(buf: page, fmt: "%u\n" , opts->isoc_maxburst); |
1068 | mutex_unlock(lock: &opts->lock); |
1069 | |
1070 | return result; |
1071 | } |
1072 | |
1073 | static ssize_t f_ss_opts_isoc_maxburst_store(struct config_item *item, |
1074 | const char *page, size_t len) |
1075 | { |
1076 | struct f_ss_opts *opts = to_f_ss_opts(item); |
1077 | int ret; |
1078 | u8 num; |
1079 | |
1080 | mutex_lock(&opts->lock); |
1081 | if (opts->refcnt) { |
1082 | ret = -EBUSY; |
1083 | goto end; |
1084 | } |
1085 | |
1086 | ret = kstrtou8(s: page, base: 0, res: &num); |
1087 | if (ret) |
1088 | goto end; |
1089 | |
1090 | if (num > 15) { |
1091 | ret = -EINVAL; |
1092 | goto end; |
1093 | } |
1094 | |
1095 | opts->isoc_maxburst = num; |
1096 | ret = len; |
1097 | end: |
1098 | mutex_unlock(lock: &opts->lock); |
1099 | return ret; |
1100 | } |
1101 | |
1102 | CONFIGFS_ATTR(f_ss_opts_, isoc_maxburst); |
1103 | |
1104 | static ssize_t f_ss_opts_bulk_buflen_show(struct config_item *item, char *page) |
1105 | { |
1106 | struct f_ss_opts *opts = to_f_ss_opts(item); |
1107 | int result; |
1108 | |
1109 | mutex_lock(&opts->lock); |
1110 | result = sprintf(buf: page, fmt: "%u\n" , opts->bulk_buflen); |
1111 | mutex_unlock(lock: &opts->lock); |
1112 | |
1113 | return result; |
1114 | } |
1115 | |
1116 | static ssize_t f_ss_opts_bulk_buflen_store(struct config_item *item, |
1117 | const char *page, size_t len) |
1118 | { |
1119 | struct f_ss_opts *opts = to_f_ss_opts(item); |
1120 | int ret; |
1121 | u32 num; |
1122 | |
1123 | mutex_lock(&opts->lock); |
1124 | if (opts->refcnt) { |
1125 | ret = -EBUSY; |
1126 | goto end; |
1127 | } |
1128 | |
1129 | ret = kstrtou32(s: page, base: 0, res: &num); |
1130 | if (ret) |
1131 | goto end; |
1132 | |
1133 | opts->bulk_buflen = num; |
1134 | ret = len; |
1135 | end: |
1136 | mutex_unlock(lock: &opts->lock); |
1137 | return ret; |
1138 | } |
1139 | |
1140 | CONFIGFS_ATTR(f_ss_opts_, bulk_buflen); |
1141 | |
1142 | static ssize_t f_ss_opts_bulk_qlen_show(struct config_item *item, char *page) |
1143 | { |
1144 | struct f_ss_opts *opts = to_f_ss_opts(item); |
1145 | int result; |
1146 | |
1147 | mutex_lock(&opts->lock); |
1148 | result = sprintf(buf: page, fmt: "%u\n" , opts->bulk_qlen); |
1149 | mutex_unlock(lock: &opts->lock); |
1150 | |
1151 | return result; |
1152 | } |
1153 | |
1154 | static ssize_t f_ss_opts_bulk_qlen_store(struct config_item *item, |
1155 | const char *page, size_t len) |
1156 | { |
1157 | struct f_ss_opts *opts = to_f_ss_opts(item); |
1158 | int ret; |
1159 | u32 num; |
1160 | |
1161 | mutex_lock(&opts->lock); |
1162 | if (opts->refcnt) { |
1163 | ret = -EBUSY; |
1164 | goto end; |
1165 | } |
1166 | |
1167 | ret = kstrtou32(s: page, base: 0, res: &num); |
1168 | if (ret) |
1169 | goto end; |
1170 | |
1171 | opts->bulk_qlen = num; |
1172 | ret = len; |
1173 | end: |
1174 | mutex_unlock(lock: &opts->lock); |
1175 | return ret; |
1176 | } |
1177 | |
1178 | CONFIGFS_ATTR(f_ss_opts_, bulk_qlen); |
1179 | |
1180 | static ssize_t f_ss_opts_iso_qlen_show(struct config_item *item, char *page) |
1181 | { |
1182 | struct f_ss_opts *opts = to_f_ss_opts(item); |
1183 | int result; |
1184 | |
1185 | mutex_lock(&opts->lock); |
1186 | result = sprintf(buf: page, fmt: "%u\n" , opts->iso_qlen); |
1187 | mutex_unlock(lock: &opts->lock); |
1188 | |
1189 | return result; |
1190 | } |
1191 | |
1192 | static ssize_t f_ss_opts_iso_qlen_store(struct config_item *item, |
1193 | const char *page, size_t len) |
1194 | { |
1195 | struct f_ss_opts *opts = to_f_ss_opts(item); |
1196 | int ret; |
1197 | u32 num; |
1198 | |
1199 | mutex_lock(&opts->lock); |
1200 | if (opts->refcnt) { |
1201 | ret = -EBUSY; |
1202 | goto end; |
1203 | } |
1204 | |
1205 | ret = kstrtou32(s: page, base: 0, res: &num); |
1206 | if (ret) |
1207 | goto end; |
1208 | |
1209 | opts->iso_qlen = num; |
1210 | ret = len; |
1211 | end: |
1212 | mutex_unlock(lock: &opts->lock); |
1213 | return ret; |
1214 | } |
1215 | |
1216 | CONFIGFS_ATTR(f_ss_opts_, iso_qlen); |
1217 | |
1218 | static struct configfs_attribute *ss_attrs[] = { |
1219 | &f_ss_opts_attr_pattern, |
1220 | &f_ss_opts_attr_isoc_interval, |
1221 | &f_ss_opts_attr_isoc_maxpacket, |
1222 | &f_ss_opts_attr_isoc_mult, |
1223 | &f_ss_opts_attr_isoc_maxburst, |
1224 | &f_ss_opts_attr_bulk_buflen, |
1225 | &f_ss_opts_attr_bulk_qlen, |
1226 | &f_ss_opts_attr_iso_qlen, |
1227 | NULL, |
1228 | }; |
1229 | |
1230 | static const struct config_item_type ss_func_type = { |
1231 | .ct_item_ops = &ss_item_ops, |
1232 | .ct_attrs = ss_attrs, |
1233 | .ct_owner = THIS_MODULE, |
1234 | }; |
1235 | |
1236 | static void source_sink_free_instance(struct usb_function_instance *fi) |
1237 | { |
1238 | struct f_ss_opts *ss_opts; |
1239 | |
1240 | ss_opts = container_of(fi, struct f_ss_opts, func_inst); |
1241 | kfree(objp: ss_opts); |
1242 | } |
1243 | |
1244 | static struct usb_function_instance *source_sink_alloc_inst(void) |
1245 | { |
1246 | struct f_ss_opts *ss_opts; |
1247 | |
1248 | ss_opts = kzalloc(size: sizeof(*ss_opts), GFP_KERNEL); |
1249 | if (!ss_opts) |
1250 | return ERR_PTR(error: -ENOMEM); |
1251 | mutex_init(&ss_opts->lock); |
1252 | ss_opts->func_inst.free_func_inst = source_sink_free_instance; |
1253 | ss_opts->isoc_interval = GZERO_ISOC_INTERVAL; |
1254 | ss_opts->isoc_maxpacket = GZERO_ISOC_MAXPACKET; |
1255 | ss_opts->bulk_buflen = GZERO_BULK_BUFLEN; |
1256 | ss_opts->bulk_qlen = GZERO_SS_BULK_QLEN; |
1257 | ss_opts->iso_qlen = GZERO_SS_ISO_QLEN; |
1258 | |
1259 | config_group_init_type_name(group: &ss_opts->func_inst.group, name: "" , |
1260 | type: &ss_func_type); |
1261 | |
1262 | return &ss_opts->func_inst; |
1263 | } |
1264 | DECLARE_USB_FUNCTION(SourceSink, source_sink_alloc_inst, |
1265 | source_sink_alloc_func); |
1266 | |
1267 | static int __init sslb_modinit(void) |
1268 | { |
1269 | int ret; |
1270 | |
1271 | ret = usb_function_register(newf: &SourceSinkusb_func); |
1272 | if (ret) |
1273 | return ret; |
1274 | ret = lb_modinit(); |
1275 | if (ret) |
1276 | usb_function_unregister(f: &SourceSinkusb_func); |
1277 | return ret; |
1278 | } |
1279 | static void __exit sslb_modexit(void) |
1280 | { |
1281 | usb_function_unregister(f: &SourceSinkusb_func); |
1282 | lb_modexit(); |
1283 | } |
1284 | module_init(sslb_modinit); |
1285 | module_exit(sslb_modexit); |
1286 | |
1287 | MODULE_LICENSE("GPL" ); |
1288 | |