?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / usb / gadget / function / f_uac2.c
blob5d960b6603b6f0f67e2590bb50aa0809edcd4481
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * f_uac2.c -- USB Audio Class 2.0 Function
4 *
5 * Copyright (C) 2011
6 * Yadwinder Singh (yadi.brar01@gmail.com)
7 * Jaswinder Singh (jaswinder.singh@linaro.org)
8 */
9
10 #include <linux/usb/audio.h>
11 #include <linux/usb/audio-v2.h>
12 #include <linux/module.h>
13
14 #include "u_audio.h"
15 #include "u_uac2.h"
16
17 /*
18 * The driver implements a simple UAC_2 topology.
19 * USB-OUT -> IT_1 -> OT_3 -> ALSA_Capture
20 * ALSA_Playback -> IT_2 -> OT_4 -> USB-IN
21 * Capture and Playback sampling rates are independently
22 * controlled by two clock sources :
23 * CLK_5 := c_srate, and CLK_6 := p_srate
24 */
25 #define USB_OUT_CLK_ID (out_clk_src_desc.bClockID)
26 #define USB_IN_CLK_ID (in_clk_src_desc.bClockID)
27
28 #define CONTROL_ABSENT 0
29 #define CONTROL_RDONLY 1
30 #define CONTROL_RDWR 3
31
32 #define CLK_FREQ_CTRL 0
33 #define CLK_VLD_CTRL 2
34
35 #define COPY_CTRL 0
36 #define CONN_CTRL 2
37 #define OVRLD_CTRL 4
38 #define CLSTR_CTRL 6
39 #define UNFLW_CTRL 8
40 #define OVFLW_CTRL 10
41
42 #define EPIN_EN(_opts) ((_opts)->p_chmask != 0)
43 #define EPOUT_EN(_opts) ((_opts)->c_chmask != 0)
44
45 struct f_uac2 {
46 struct g_audio g_audio;
47 u8 ac_intf, as_in_intf, as_out_intf;
48 u8 ac_alt, as_in_alt, as_out_alt; /* needed for get_alt() */
49 };
50
51 static inline struct f_uac2 *func_to_uac2(struct usb_function *f)
52 {
53 return container_of(f, struct f_uac2, g_audio.func);
54 }
55
56 static inline
57 struct f_uac2_opts *g_audio_to_uac2_opts(struct g_audio *agdev)
58 {
59 return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
60 }
61
62 /* --------- USB Function Interface ------------- */
63
64 enum {
65 STR_ASSOC,
66 STR_IF_CTRL,
67 STR_CLKSRC_IN,
68 STR_CLKSRC_OUT,
69 STR_USB_IT,
70 STR_IO_IT,
71 STR_USB_OT,
72 STR_IO_OT,
73 STR_AS_OUT_ALT0,
74 STR_AS_OUT_ALT1,
75 STR_AS_IN_ALT0,
76 STR_AS_IN_ALT1,
77 };
78
79 static char clksrc_in[8];
80 static char clksrc_out[8];
81
82 static struct usb_string strings_fn[] = {
83 [STR_ASSOC].s = "Source/Sink",
84 [STR_IF_CTRL].s = "Topology Control",
85 [STR_CLKSRC_IN].s = clksrc_in,
86 [STR_CLKSRC_OUT].s = clksrc_out,
87 [STR_USB_IT].s = "USBH Out",
88 [STR_IO_IT].s = "USBD Out",
89 [STR_USB_OT].s = "USBH In",
90 [STR_IO_OT].s = "USBD In",
91 [STR_AS_OUT_ALT0].s = "Playback Inactive",
92 [STR_AS_OUT_ALT1].s = "Playback Active",
93 [STR_AS_IN_ALT0].s = "Capture Inactive",
94 [STR_AS_IN_ALT1].s = "Capture Active",
95 { },
96 };
97
98 static struct usb_gadget_strings str_fn = {
99 .language = 0x0409, /* en-us */
100 .strings = strings_fn,
101 };
102
103 static struct usb_gadget_strings *fn_strings[] = {
104 &str_fn,
105 NULL,
106 };
107
108 static struct usb_interface_assoc_descriptor iad_desc = {
109 .bLength = sizeof iad_desc,
110 .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
111
112 .bFirstInterface = 0,
113 .bInterfaceCount = 3,
114 .bFunctionClass = USB_CLASS_AUDIO,
115 .bFunctionSubClass = UAC2_FUNCTION_SUBCLASS_UNDEFINED,
116 .bFunctionProtocol = UAC_VERSION_2,
117 };
118
119 /* Audio Control Interface */
120 static struct usb_interface_descriptor std_ac_if_desc = {
121 .bLength = sizeof std_ac_if_desc,
122 .bDescriptorType = USB_DT_INTERFACE,
123
124 .bAlternateSetting = 0,
125 .bNumEndpoints = 0,
126 .bInterfaceClass = USB_CLASS_AUDIO,
127 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
128 .bInterfaceProtocol = UAC_VERSION_2,
129 };
130
131 /* Clock source for IN traffic */
132 static struct uac_clock_source_descriptor in_clk_src_desc = {
133 .bLength = sizeof in_clk_src_desc,
134 .bDescriptorType = USB_DT_CS_INTERFACE,
135
136 .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
137 /* .bClockID = DYNAMIC */
138 .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
139 .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
140 .bAssocTerminal = 0,
141 };
142
143 /* Clock source for OUT traffic */
144 static struct uac_clock_source_descriptor out_clk_src_desc = {
145 .bLength = sizeof out_clk_src_desc,
146 .bDescriptorType = USB_DT_CS_INTERFACE,
147
148 .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
149 /* .bClockID = DYNAMIC */
150 .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
151 .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
152 .bAssocTerminal = 0,
153 };
154
155 /* Input Terminal for USB_OUT */
156 static struct uac2_input_terminal_descriptor usb_out_it_desc = {
157 .bLength = sizeof usb_out_it_desc,
158 .bDescriptorType = USB_DT_CS_INTERFACE,
159
160 .bDescriptorSubtype = UAC_INPUT_TERMINAL,
161 /* .bTerminalID = DYNAMIC */
162 .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
163 .bAssocTerminal = 0,
164 /* .bCSourceID = DYNAMIC */
165 .iChannelNames = 0,
166 .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
167 };
168
169 /* Input Terminal for I/O-In */
170 static struct uac2_input_terminal_descriptor io_in_it_desc = {
171 .bLength = sizeof io_in_it_desc,
172 .bDescriptorType = USB_DT_CS_INTERFACE,
173
174 .bDescriptorSubtype = UAC_INPUT_TERMINAL,
175 /* .bTerminalID = DYNAMIC */
176 .wTerminalType = cpu_to_le16(UAC_INPUT_TERMINAL_UNDEFINED),
177 .bAssocTerminal = 0,
178 /* .bCSourceID = DYNAMIC */
179 .iChannelNames = 0,
180 .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
181 };
182
183 /* Ouput Terminal for USB_IN */
184 static struct uac2_output_terminal_descriptor usb_in_ot_desc = {
185 .bLength = sizeof usb_in_ot_desc,
186 .bDescriptorType = USB_DT_CS_INTERFACE,
187
188 .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
189 /* .bTerminalID = DYNAMIC */
190 .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
191 .bAssocTerminal = 0,
192 /* .bSourceID = DYNAMIC */
193 /* .bCSourceID = DYNAMIC */
194 .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
195 };
196
197 /* Ouput Terminal for I/O-Out */
198 static struct uac2_output_terminal_descriptor io_out_ot_desc = {
199 .bLength = sizeof io_out_ot_desc,
200 .bDescriptorType = USB_DT_CS_INTERFACE,
201
202 .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
203 /* .bTerminalID = DYNAMIC */
204 .wTerminalType = cpu_to_le16(UAC_OUTPUT_TERMINAL_UNDEFINED),
205 .bAssocTerminal = 0,
206 /* .bSourceID = DYNAMIC */
207 /* .bCSourceID = DYNAMIC */
208 .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
209 };
210
211 static struct uac2_ac_header_descriptor ac_hdr_desc = {
212 .bLength = sizeof ac_hdr_desc,
213 .bDescriptorType = USB_DT_CS_INTERFACE,
214
215 .bDescriptorSubtype = UAC_MS_HEADER,
216 .bcdADC = cpu_to_le16(0x200),
217 .bCategory = UAC2_FUNCTION_IO_BOX,
218 /* .wTotalLength = DYNAMIC */
219 .bmControls = 0,
220 };
221
222 /* Audio Streaming OUT Interface - Alt0 */
223 static struct usb_interface_descriptor std_as_out_if0_desc = {
224 .bLength = sizeof std_as_out_if0_desc,
225 .bDescriptorType = USB_DT_INTERFACE,
226
227 .bAlternateSetting = 0,
228 .bNumEndpoints = 0,
229 .bInterfaceClass = USB_CLASS_AUDIO,
230 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
231 .bInterfaceProtocol = UAC_VERSION_2,
232 };
233
234 /* Audio Streaming OUT Interface - Alt1 */
235 static struct usb_interface_descriptor std_as_out_if1_desc = {
236 .bLength = sizeof std_as_out_if1_desc,
237 .bDescriptorType = USB_DT_INTERFACE,
238
239 .bAlternateSetting = 1,
240 .bNumEndpoints = 1,
241 .bInterfaceClass = USB_CLASS_AUDIO,
242 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
243 .bInterfaceProtocol = UAC_VERSION_2,
244 };
245
246 /* Audio Stream OUT Intface Desc */
247 static struct uac2_as_header_descriptor as_out_hdr_desc = {
248 .bLength = sizeof as_out_hdr_desc,
249 .bDescriptorType = USB_DT_CS_INTERFACE,
250
251 .bDescriptorSubtype = UAC_AS_GENERAL,
252 /* .bTerminalLink = DYNAMIC */
253 .bmControls = 0,
254 .bFormatType = UAC_FORMAT_TYPE_I,
255 .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
256 .iChannelNames = 0,
257 };
258
259 /* Audio USB_OUT Format */
260 static struct uac2_format_type_i_descriptor as_out_fmt1_desc = {
261 .bLength = sizeof as_out_fmt1_desc,
262 .bDescriptorType = USB_DT_CS_INTERFACE,
263 .bDescriptorSubtype = UAC_FORMAT_TYPE,
264 .bFormatType = UAC_FORMAT_TYPE_I,
265 };
266
267 /* STD AS ISO OUT Endpoint */
268 static struct usb_endpoint_descriptor fs_epout_desc = {
269 .bLength = USB_DT_ENDPOINT_SIZE,
270 .bDescriptorType = USB_DT_ENDPOINT,
271
272 .bEndpointAddress = USB_DIR_OUT,
273 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
274 /* .wMaxPacketSize = DYNAMIC */
275 .bInterval = 1,
276 };
277
278 static struct usb_endpoint_descriptor hs_epout_desc = {
279 .bLength = USB_DT_ENDPOINT_SIZE,
280 .bDescriptorType = USB_DT_ENDPOINT,
281
282 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
283 /* .wMaxPacketSize = DYNAMIC */
284 .bInterval = 4,
285 };
286
287 /* CS AS ISO OUT Endpoint */
288 static struct uac2_iso_endpoint_descriptor as_iso_out_desc = {
289 .bLength = sizeof as_iso_out_desc,
290 .bDescriptorType = USB_DT_CS_ENDPOINT,
291
292 .bDescriptorSubtype = UAC_EP_GENERAL,
293 .bmAttributes = 0,
294 .bmControls = 0,
295 .bLockDelayUnits = 0,
296 .wLockDelay = 0,
297 };
298
299 /* Audio Streaming IN Interface - Alt0 */
300 static struct usb_interface_descriptor std_as_in_if0_desc = {
301 .bLength = sizeof std_as_in_if0_desc,
302 .bDescriptorType = USB_DT_INTERFACE,
303
304 .bAlternateSetting = 0,
305 .bNumEndpoints = 0,
306 .bInterfaceClass = USB_CLASS_AUDIO,
307 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
308 .bInterfaceProtocol = UAC_VERSION_2,
309 };
310
311 /* Audio Streaming IN Interface - Alt1 */
312 static struct usb_interface_descriptor std_as_in_if1_desc = {
313 .bLength = sizeof std_as_in_if1_desc,
314 .bDescriptorType = USB_DT_INTERFACE,
315
316 .bAlternateSetting = 1,
317 .bNumEndpoints = 1,
318 .bInterfaceClass = USB_CLASS_AUDIO,
319 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
320 .bInterfaceProtocol = UAC_VERSION_2,
321 };
322
323 /* Audio Stream IN Intface Desc */
324 static struct uac2_as_header_descriptor as_in_hdr_desc = {
325 .bLength = sizeof as_in_hdr_desc,
326 .bDescriptorType = USB_DT_CS_INTERFACE,
327
328 .bDescriptorSubtype = UAC_AS_GENERAL,
329 /* .bTerminalLink = DYNAMIC */
330 .bmControls = 0,
331 .bFormatType = UAC_FORMAT_TYPE_I,
332 .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
333 .iChannelNames = 0,
334 };
335
336 /* Audio USB_IN Format */
337 static struct uac2_format_type_i_descriptor as_in_fmt1_desc = {
338 .bLength = sizeof as_in_fmt1_desc,
339 .bDescriptorType = USB_DT_CS_INTERFACE,
340 .bDescriptorSubtype = UAC_FORMAT_TYPE,
341 .bFormatType = UAC_FORMAT_TYPE_I,
342 };
343
344 /* STD AS ISO IN Endpoint */
345 static struct usb_endpoint_descriptor fs_epin_desc = {
346 .bLength = USB_DT_ENDPOINT_SIZE,
347 .bDescriptorType = USB_DT_ENDPOINT,
348
349 .bEndpointAddress = USB_DIR_IN,
350 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
351 /* .wMaxPacketSize = DYNAMIC */
352 .bInterval = 1,
353 };
354
355 static struct usb_endpoint_descriptor hs_epin_desc = {
356 .bLength = USB_DT_ENDPOINT_SIZE,
357 .bDescriptorType = USB_DT_ENDPOINT,
358
359 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
360 /* .wMaxPacketSize = DYNAMIC */
361 .bInterval = 4,
362 };
363
364 /* CS AS ISO IN Endpoint */
365 static struct uac2_iso_endpoint_descriptor as_iso_in_desc = {
366 .bLength = sizeof as_iso_in_desc,
367 .bDescriptorType = USB_DT_CS_ENDPOINT,
368
369 .bDescriptorSubtype = UAC_EP_GENERAL,
370 .bmAttributes = 0,
371 .bmControls = 0,
372 .bLockDelayUnits = 0,
373 .wLockDelay = 0,
374 };
375
376 static struct usb_descriptor_header *fs_audio_desc[] = {
377 (struct usb_descriptor_header *)&iad_desc,
378 (struct usb_descriptor_header *)&std_ac_if_desc,
379
380 (struct usb_descriptor_header *)&ac_hdr_desc,
381 (struct usb_descriptor_header *)&in_clk_src_desc,
382 (struct usb_descriptor_header *)&out_clk_src_desc,
383 (struct usb_descriptor_header *)&usb_out_it_desc,
384 (struct usb_descriptor_header *)&io_in_it_desc,
385 (struct usb_descriptor_header *)&usb_in_ot_desc,
386 (struct usb_descriptor_header *)&io_out_ot_desc,
387
388 (struct usb_descriptor_header *)&std_as_out_if0_desc,
389 (struct usb_descriptor_header *)&std_as_out_if1_desc,
390
391 (struct usb_descriptor_header *)&as_out_hdr_desc,
392 (struct usb_descriptor_header *)&as_out_fmt1_desc,
393 (struct usb_descriptor_header *)&fs_epout_desc,
394 (struct usb_descriptor_header *)&as_iso_out_desc,
395
396 (struct usb_descriptor_header *)&std_as_in_if0_desc,
397 (struct usb_descriptor_header *)&std_as_in_if1_desc,
398
399 (struct usb_descriptor_header *)&as_in_hdr_desc,
400 (struct usb_descriptor_header *)&as_in_fmt1_desc,
401 (struct usb_descriptor_header *)&fs_epin_desc,
402 (struct usb_descriptor_header *)&as_iso_in_desc,
403 NULL,
404 };
405
406 static struct usb_descriptor_header *hs_audio_desc[] = {
407 (struct usb_descriptor_header *)&iad_desc,
408 (struct usb_descriptor_header *)&std_ac_if_desc,
409
410 (struct usb_descriptor_header *)&ac_hdr_desc,
411 (struct usb_descriptor_header *)&in_clk_src_desc,
412 (struct usb_descriptor_header *)&out_clk_src_desc,
413 (struct usb_descriptor_header *)&usb_out_it_desc,
414 (struct usb_descriptor_header *)&io_in_it_desc,
415 (struct usb_descriptor_header *)&usb_in_ot_desc,
416 (struct usb_descriptor_header *)&io_out_ot_desc,
417
418 (struct usb_descriptor_header *)&std_as_out_if0_desc,
419 (struct usb_descriptor_header *)&std_as_out_if1_desc,
420
421 (struct usb_descriptor_header *)&as_out_hdr_desc,
422 (struct usb_descriptor_header *)&as_out_fmt1_desc,
423 (struct usb_descriptor_header *)&hs_epout_desc,
424 (struct usb_descriptor_header *)&as_iso_out_desc,
425
426 (struct usb_descriptor_header *)&std_as_in_if0_desc,
427 (struct usb_descriptor_header *)&std_as_in_if1_desc,
428
429 (struct usb_descriptor_header *)&as_in_hdr_desc,
430 (struct usb_descriptor_header *)&as_in_fmt1_desc,
431 (struct usb_descriptor_header *)&hs_epin_desc,
432 (struct usb_descriptor_header *)&as_iso_in_desc,
433 NULL,
434 };
435
436 struct cntrl_cur_lay3 {
437 __le32 dCUR;
438 };
439
440 struct cntrl_range_lay3 {
441 __le16 wNumSubRanges;
442 __le32 dMIN;
443 __le32 dMAX;
444 __le32 dRES;
445 } __packed;
446
447 static int set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
448 struct usb_endpoint_descriptor *ep_desc,
449 enum usb_device_speed speed, bool is_playback)
450 {
451 int chmask, srate, ssize;
452 u16 max_size_bw, max_size_ep;
453 unsigned int factor;
454
455 switch (speed) {
456 case USB_SPEED_FULL:
457 max_size_ep = 1023;
458 factor = 1000;
459 break;
460
461 case USB_SPEED_HIGH:
462 max_size_ep = 1024;
463 factor = 8000;
464 break;
465
466 default:
467 return -EINVAL;
468 }
469
470 if (is_playback) {
471 chmask = uac2_opts->p_chmask;
472 srate = uac2_opts->p_srate;
473 ssize = uac2_opts->p_ssize;
474 } else {
475 chmask = uac2_opts->c_chmask;
476 srate = uac2_opts->c_srate;
477 ssize = uac2_opts->c_ssize;
478 }
479
480 max_size_bw = num_channels(chmask) * ssize *
481 DIV_ROUND_UP(srate, factor / (1 << (ep_desc->bInterval - 1)));
482 ep_desc->wMaxPacketSize = cpu_to_le16(min_t(u16, max_size_bw,
483 max_size_ep));
484
485 return 0;
486 }
487
488 /* Use macro to overcome line length limitation */
489 #define USBDHDR(p) (struct usb_descriptor_header *)(p)
490
491 static void setup_descriptor(struct f_uac2_opts *opts)
492 {
493 /* patch descriptors */
494 int i = 1; /* ID's start with 1 */
495
496 if (EPOUT_EN(opts))
497 usb_out_it_desc.bTerminalID = i++;
498 if (EPIN_EN(opts))
499 io_in_it_desc.bTerminalID = i++;
500 if (EPOUT_EN(opts))
501 io_out_ot_desc.bTerminalID = i++;
502 if (EPIN_EN(opts))
503 usb_in_ot_desc.bTerminalID = i++;
504 if (EPOUT_EN(opts))
505 out_clk_src_desc.bClockID = i++;
506 if (EPIN_EN(opts))
507 in_clk_src_desc.bClockID = i++;
508
509 usb_out_it_desc.bCSourceID = out_clk_src_desc.bClockID;
510 usb_in_ot_desc.bSourceID = io_in_it_desc.bTerminalID;
511 usb_in_ot_desc.bCSourceID = in_clk_src_desc.bClockID;
512 io_in_it_desc.bCSourceID = in_clk_src_desc.bClockID;
513 io_out_ot_desc.bCSourceID = out_clk_src_desc.bClockID;
514 io_out_ot_desc.bSourceID = usb_out_it_desc.bTerminalID;
515 as_out_hdr_desc.bTerminalLink = usb_out_it_desc.bTerminalID;
516 as_in_hdr_desc.bTerminalLink = usb_in_ot_desc.bTerminalID;
517
518 iad_desc.bInterfaceCount = 1;
519 ac_hdr_desc.wTotalLength = cpu_to_le16(sizeof(ac_hdr_desc));
520
521 if (EPIN_EN(opts)) {
522 u16 len = le16_to_cpu(ac_hdr_desc.wTotalLength);
523
524 len += sizeof(in_clk_src_desc);
525 len += sizeof(usb_in_ot_desc);
526 len += sizeof(io_in_it_desc);
527 ac_hdr_desc.wTotalLength = cpu_to_le16(len);
528 iad_desc.bInterfaceCount++;
529 }
530 if (EPOUT_EN(opts)) {
531 u16 len = le16_to_cpu(ac_hdr_desc.wTotalLength);
532
533 len += sizeof(out_clk_src_desc);
534 len += sizeof(usb_out_it_desc);
535 len += sizeof(io_out_ot_desc);
536 ac_hdr_desc.wTotalLength = cpu_to_le16(len);
537 iad_desc.bInterfaceCount++;
538 }
539
540 i = 0;
541 fs_audio_desc[i++] = USBDHDR(&iad_desc);
542 fs_audio_desc[i++] = USBDHDR(&std_ac_if_desc);
543 fs_audio_desc[i++] = USBDHDR(&ac_hdr_desc);
544 if (EPIN_EN(opts))
545 fs_audio_desc[i++] = USBDHDR(&in_clk_src_desc);
546 if (EPOUT_EN(opts)) {
547 fs_audio_desc[i++] = USBDHDR(&out_clk_src_desc);
548 fs_audio_desc[i++] = USBDHDR(&usb_out_it_desc);
549 }
550 if (EPIN_EN(opts)) {
551 fs_audio_desc[i++] = USBDHDR(&io_in_it_desc);
552 fs_audio_desc[i++] = USBDHDR(&usb_in_ot_desc);
553 }
554 if (EPOUT_EN(opts)) {
555 fs_audio_desc[i++] = USBDHDR(&io_out_ot_desc);
556 fs_audio_desc[i++] = USBDHDR(&std_as_out_if0_desc);
557 fs_audio_desc[i++] = USBDHDR(&std_as_out_if1_desc);
558 fs_audio_desc[i++] = USBDHDR(&as_out_hdr_desc);
559 fs_audio_desc[i++] = USBDHDR(&as_out_fmt1_desc);
560 fs_audio_desc[i++] = USBDHDR(&fs_epout_desc);
561 fs_audio_desc[i++] = USBDHDR(&as_iso_out_desc);
562 }
563 if (EPIN_EN(opts)) {
564 fs_audio_desc[i++] = USBDHDR(&std_as_in_if0_desc);
565 fs_audio_desc[i++] = USBDHDR(&std_as_in_if1_desc);
566 fs_audio_desc[i++] = USBDHDR(&as_in_hdr_desc);
567 fs_audio_desc[i++] = USBDHDR(&as_in_fmt1_desc);
568 fs_audio_desc[i++] = USBDHDR(&fs_epin_desc);
569 fs_audio_desc[i++] = USBDHDR(&as_iso_in_desc);
570 }
571 fs_audio_desc[i] = NULL;
572
573 i = 0;
574 hs_audio_desc[i++] = USBDHDR(&iad_desc);
575 hs_audio_desc[i++] = USBDHDR(&std_ac_if_desc);
576 hs_audio_desc[i++] = USBDHDR(&ac_hdr_desc);
577 if (EPIN_EN(opts))
578 hs_audio_desc[i++] = USBDHDR(&in_clk_src_desc);
579 if (EPOUT_EN(opts)) {
580 hs_audio_desc[i++] = USBDHDR(&out_clk_src_desc);
581 hs_audio_desc[i++] = USBDHDR(&usb_out_it_desc);
582 }
583 if (EPIN_EN(opts)) {
584 hs_audio_desc[i++] = USBDHDR(&io_in_it_desc);
585 hs_audio_desc[i++] = USBDHDR(&usb_in_ot_desc);
586 }
587 if (EPOUT_EN(opts)) {
588 hs_audio_desc[i++] = USBDHDR(&io_out_ot_desc);
589 hs_audio_desc[i++] = USBDHDR(&std_as_out_if0_desc);
590 hs_audio_desc[i++] = USBDHDR(&std_as_out_if1_desc);
591 hs_audio_desc[i++] = USBDHDR(&as_out_hdr_desc);
592 hs_audio_desc[i++] = USBDHDR(&as_out_fmt1_desc);
593 hs_audio_desc[i++] = USBDHDR(&hs_epout_desc);
594 hs_audio_desc[i++] = USBDHDR(&as_iso_out_desc);
595 }
596 if (EPIN_EN(opts)) {
597 hs_audio_desc[i++] = USBDHDR(&std_as_in_if0_desc);
598 hs_audio_desc[i++] = USBDHDR(&std_as_in_if1_desc);
599 hs_audio_desc[i++] = USBDHDR(&as_in_hdr_desc);
600 hs_audio_desc[i++] = USBDHDR(&as_in_fmt1_desc);
601 hs_audio_desc[i++] = USBDHDR(&hs_epin_desc);
602 hs_audio_desc[i++] = USBDHDR(&as_iso_in_desc);
603 }
604 hs_audio_desc[i] = NULL;
605 }
606
607 static int
608 afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
609 {
610 struct f_uac2 *uac2 = func_to_uac2(fn);
611 struct g_audio *agdev = func_to_g_audio(fn);
612 struct usb_composite_dev *cdev = cfg->cdev;
613 struct usb_gadget *gadget = cdev->gadget;
614 struct device *dev = &gadget->dev;
615 struct f_uac2_opts *uac2_opts;
616 struct usb_string *us;
617 int ret;
618
619 uac2_opts = container_of(fn->fi, struct f_uac2_opts, func_inst);
620
621 us = usb_gstrings_attach(cdev, fn_strings, ARRAY_SIZE(strings_fn));
622 if (IS_ERR(us))
623 return PTR_ERR(us);
624 iad_desc.iFunction = us[STR_ASSOC].id;
625 std_ac_if_desc.iInterface = us[STR_IF_CTRL].id;
626 in_clk_src_desc.iClockSource = us[STR_CLKSRC_IN].id;
627 out_clk_src_desc.iClockSource = us[STR_CLKSRC_OUT].id;
628 usb_out_it_desc.iTerminal = us[STR_USB_IT].id;
629 io_in_it_desc.iTerminal = us[STR_IO_IT].id;
630 usb_in_ot_desc.iTerminal = us[STR_USB_OT].id;
631 io_out_ot_desc.iTerminal = us[STR_IO_OT].id;
632 std_as_out_if0_desc.iInterface = us[STR_AS_OUT_ALT0].id;
633 std_as_out_if1_desc.iInterface = us[STR_AS_OUT_ALT1].id;
634 std_as_in_if0_desc.iInterface = us[STR_AS_IN_ALT0].id;
635 std_as_in_if1_desc.iInterface = us[STR_AS_IN_ALT1].id;
636
637
638 /* Initialize the configurable parameters */
639 usb_out_it_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
640 usb_out_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
641 io_in_it_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
642 io_in_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
643 as_out_hdr_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
644 as_out_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
645 as_in_hdr_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
646 as_in_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
647 as_out_fmt1_desc.bSubslotSize = uac2_opts->c_ssize;
648 as_out_fmt1_desc.bBitResolution = uac2_opts->c_ssize * 8;
649 as_in_fmt1_desc.bSubslotSize = uac2_opts->p_ssize;
650 as_in_fmt1_desc.bBitResolution = uac2_opts->p_ssize * 8;
651
652 snprintf(clksrc_in, sizeof(clksrc_in), "%uHz", uac2_opts->p_srate);
653 snprintf(clksrc_out, sizeof(clksrc_out), "%uHz", uac2_opts->c_srate);
654
655 ret = usb_interface_id(cfg, fn);
656 if (ret < 0) {
657 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
658 return ret;
659 }
660 iad_desc.bFirstInterface = ret;
661
662 std_ac_if_desc.bInterfaceNumber = ret;
663 uac2->ac_intf = ret;
664 uac2->ac_alt = 0;
665
666 if (EPOUT_EN(uac2_opts)) {
667 ret = usb_interface_id(cfg, fn);
668 if (ret < 0) {
669 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
670 return ret;
671 }
672 std_as_out_if0_desc.bInterfaceNumber = ret;
673 std_as_out_if1_desc.bInterfaceNumber = ret;
674 uac2->as_out_intf = ret;
675 uac2->as_out_alt = 0;
676 }
677
678 if (EPIN_EN(uac2_opts)) {
679 ret = usb_interface_id(cfg, fn);
680 if (ret < 0) {
681 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
682 return ret;
683 }
684 std_as_in_if0_desc.bInterfaceNumber = ret;
685 std_as_in_if1_desc.bInterfaceNumber = ret;
686 uac2->as_in_intf = ret;
687 uac2->as_in_alt = 0;
688 }
689
690 /* Calculate wMaxPacketSize according to audio bandwidth */
691 ret = set_ep_max_packet_size(uac2_opts, &fs_epin_desc, USB_SPEED_FULL,
692 true);
693 if (ret < 0) {
694 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
695 return ret;
696 }
697
698 ret = set_ep_max_packet_size(uac2_opts, &fs_epout_desc, USB_SPEED_FULL,
699 false);
700 if (ret < 0) {
701 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
702 return ret;
703 }
704
705 ret = set_ep_max_packet_size(uac2_opts, &hs_epin_desc, USB_SPEED_HIGH,
706 true);
707 if (ret < 0) {
708 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
709 return ret;
710 }
711
712 ret = set_ep_max_packet_size(uac2_opts, &hs_epout_desc, USB_SPEED_HIGH,
713 false);
714 if (ret < 0) {
715 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
716 return ret;
717 }
718
719 if (EPOUT_EN(uac2_opts)) {
720 agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
721 if (!agdev->out_ep) {
722 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
723 return -ENODEV;
724 }
725 }
726
727 if (EPIN_EN(uac2_opts)) {
728 agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
729 if (!agdev->in_ep) {
730 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
731 return -ENODEV;
732 }
733 }
734
735 agdev->in_ep_maxpsize = max_t(u16,
736 le16_to_cpu(fs_epin_desc.wMaxPacketSize),
737 le16_to_cpu(hs_epin_desc.wMaxPacketSize));
738 agdev->out_ep_maxpsize = max_t(u16,
739 le16_to_cpu(fs_epout_desc.wMaxPacketSize),
740 le16_to_cpu(hs_epout_desc.wMaxPacketSize));
741
742 hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
743 hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
744
745 setup_descriptor(uac2_opts);
746
747 ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, NULL,
748 NULL);
749 if (ret)
750 return ret;
751
752 agdev->gadget = gadget;
753
754 agdev->params.p_chmask = uac2_opts->p_chmask;
755 agdev->params.p_srate = uac2_opts->p_srate;
756 agdev->params.p_ssize = uac2_opts->p_ssize;
757 agdev->params.c_chmask = uac2_opts->c_chmask;
758 agdev->params.c_srate = uac2_opts->c_srate;
759 agdev->params.c_ssize = uac2_opts->c_ssize;
760 agdev->params.req_number = uac2_opts->req_number;
761 ret = g_audio_setup(agdev, "UAC2 PCM", "UAC2_Gadget");
762 if (ret)
763 goto err_free_descs;
764 return 0;
765
766 err_free_descs:
767 usb_free_all_descriptors(fn);
768 agdev->gadget = NULL;
769 return ret;
770 }
771
772 static int
773 afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
774 {
775 struct usb_composite_dev *cdev = fn->config->cdev;
776 struct f_uac2 *uac2 = func_to_uac2(fn);
777 struct usb_gadget *gadget = cdev->gadget;
778 struct device *dev = &gadget->dev;
779 int ret = 0;
780
781 /* No i/f has more than 2 alt settings */
782 if (alt > 1) {
783 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
784 return -EINVAL;
785 }
786
787 if (intf == uac2->ac_intf) {
788 /* Control I/f has only 1 AltSetting - 0 */
789 if (alt) {
790 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
791 return -EINVAL;
792 }
793 return 0;
794 }
795
796 if (intf == uac2->as_out_intf) {
797 uac2->as_out_alt = alt;
798
799 if (alt)
800 ret = u_audio_start_capture(&uac2->g_audio);
801 else
802 u_audio_stop_capture(&uac2->g_audio);
803 } else if (intf == uac2->as_in_intf) {
804 uac2->as_in_alt = alt;
805
806 if (alt)
807 ret = u_audio_start_playback(&uac2->g_audio);
808 else
809 u_audio_stop_playback(&uac2->g_audio);
810 } else {
811 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
812 return -EINVAL;
813 }
814
815 return ret;
816 }
817
818 static int
819 afunc_get_alt(struct usb_function *fn, unsigned intf)
820 {
821 struct f_uac2 *uac2 = func_to_uac2(fn);
822 struct g_audio *agdev = func_to_g_audio(fn);
823
824 if (intf == uac2->ac_intf)
825 return uac2->ac_alt;
826 else if (intf == uac2->as_out_intf)
827 return uac2->as_out_alt;
828 else if (intf == uac2->as_in_intf)
829 return uac2->as_in_alt;
830 else
831 dev_err(&agdev->gadget->dev,
832 "%s:%d Invalid Interface %d!\n",
833 __func__, __LINE__, intf);
834
835 return -EINVAL;
836 }
837
838 static void
839 afunc_disable(struct usb_function *fn)
840 {
841 struct f_uac2 *uac2 = func_to_uac2(fn);
842
843 uac2->as_in_alt = 0;
844 uac2->as_out_alt = 0;
845 u_audio_stop_capture(&uac2->g_audio);
846 u_audio_stop_playback(&uac2->g_audio);
847 }
848
849 static int
850 in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
851 {
852 struct usb_request *req = fn->config->cdev->req;
853 struct g_audio *agdev = func_to_g_audio(fn);
854 struct f_uac2_opts *opts;
855 u16 w_length = le16_to_cpu(cr->wLength);
856 u16 w_index = le16_to_cpu(cr->wIndex);
857 u16 w_value = le16_to_cpu(cr->wValue);
858 u8 entity_id = (w_index >> 8) & 0xff;
859 u8 control_selector = w_value >> 8;
860 int value = -EOPNOTSUPP;
861 int p_srate, c_srate;
862
863 opts = g_audio_to_uac2_opts(agdev);
864 p_srate = opts->p_srate;
865 c_srate = opts->c_srate;
866
867 if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
868 struct cntrl_cur_lay3 c;
869 memset(&c, 0, sizeof(struct cntrl_cur_lay3));
870
871 if (entity_id == USB_IN_CLK_ID)
872 c.dCUR = cpu_to_le32(p_srate);
873 else if (entity_id == USB_OUT_CLK_ID)
874 c.dCUR = cpu_to_le32(c_srate);
875
876 value = min_t(unsigned, w_length, sizeof c);
877 memcpy(req->buf, &c, value);
878 } else if (control_selector == UAC2_CS_CONTROL_CLOCK_VALID) {
879 *(u8 *)req->buf = 1;
880 value = min_t(unsigned, w_length, 1);
881 } else {
882 dev_err(&agdev->gadget->dev,
883 "%s:%d control_selector=%d TODO!\n",
884 __func__, __LINE__, control_selector);
885 }
886
887 return value;
888 }
889
890 static int
891 in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
892 {
893 struct usb_request *req = fn->config->cdev->req;
894 struct g_audio *agdev = func_to_g_audio(fn);
895 struct f_uac2_opts *opts;
896 u16 w_length = le16_to_cpu(cr->wLength);
897 u16 w_index = le16_to_cpu(cr->wIndex);
898 u16 w_value = le16_to_cpu(cr->wValue);
899 u8 entity_id = (w_index >> 8) & 0xff;
900 u8 control_selector = w_value >> 8;
901 struct cntrl_range_lay3 r;
902 int value = -EOPNOTSUPP;
903 int p_srate, c_srate;
904
905 opts = g_audio_to_uac2_opts(agdev);
906 p_srate = opts->p_srate;
907 c_srate = opts->c_srate;
908
909 if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
910 if (entity_id == USB_IN_CLK_ID)
911 r.dMIN = cpu_to_le32(p_srate);
912 else if (entity_id == USB_OUT_CLK_ID)
913 r.dMIN = cpu_to_le32(c_srate);
914 else
915 return -EOPNOTSUPP;
916
917 r.dMAX = r.dMIN;
918 r.dRES = 0;
919 r.wNumSubRanges = cpu_to_le16(1);
920
921 value = min_t(unsigned, w_length, sizeof r);
922 memcpy(req->buf, &r, value);
923 } else {
924 dev_err(&agdev->gadget->dev,
925 "%s:%d control_selector=%d TODO!\n",
926 __func__, __LINE__, control_selector);
927 }
928
929 return value;
930 }
931
932 static int
933 ac_rq_in(struct usb_function *fn, const struct usb_ctrlrequest *cr)
934 {
935 if (cr->bRequest == UAC2_CS_CUR)
936 return in_rq_cur(fn, cr);
937 else if (cr->bRequest == UAC2_CS_RANGE)
938 return in_rq_range(fn, cr);
939 else
940 return -EOPNOTSUPP;
941 }
942
943 static int
944 out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
945 {
946 u16 w_length = le16_to_cpu(cr->wLength);
947 u16 w_value = le16_to_cpu(cr->wValue);
948 u8 control_selector = w_value >> 8;
949
950 if (control_selector == UAC2_CS_CONTROL_SAM_FREQ)
951 return w_length;
952
953 return -EOPNOTSUPP;
954 }
955
956 static int
957 setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
958 {
959 struct f_uac2 *uac2 = func_to_uac2(fn);
960 struct g_audio *agdev = func_to_g_audio(fn);
961 u16 w_index = le16_to_cpu(cr->wIndex);
962 u8 intf = w_index & 0xff;
963
964 if (intf != uac2->ac_intf) {
965 dev_err(&agdev->gadget->dev,
966 "%s:%d Error!\n", __func__, __LINE__);
967 return -EOPNOTSUPP;
968 }
969
970 if (cr->bRequestType & USB_DIR_IN)
971 return ac_rq_in(fn, cr);
972 else if (cr->bRequest == UAC2_CS_CUR)
973 return out_rq_cur(fn, cr);
974
975 return -EOPNOTSUPP;
976 }
977
978 static int
979 afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
980 {
981 struct usb_composite_dev *cdev = fn->config->cdev;
982 struct g_audio *agdev = func_to_g_audio(fn);
983 struct usb_request *req = cdev->req;
984 u16 w_length = le16_to_cpu(cr->wLength);
985 int value = -EOPNOTSUPP;
986
987 /* Only Class specific requests are supposed to reach here */
988 if ((cr->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
989 return -EOPNOTSUPP;
990
991 if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
992 value = setup_rq_inf(fn, cr);
993 else
994 dev_err(&agdev->gadget->dev, "%s:%d Error!\n",
995 __func__, __LINE__);
996
997 if (value >= 0) {
998 req->length = value;
999 req->zero = value < w_length;
1000 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
1001 if (value < 0) {
1002 dev_err(&agdev->gadget->dev,
1003 "%s:%d Error!\n", __func__, __LINE__);
1004 req->status = 0;
1005 }
1006 }
1007
1008 return value;
1009 }
1010
1011 static inline struct f_uac2_opts *to_f_uac2_opts(struct config_item *item)
1012 {
1013 return container_of(to_config_group(item), struct f_uac2_opts,
1014 func_inst.group);
1015 }
1016
1017 static void f_uac2_attr_release(struct config_item *item)
1018 {
1019 struct f_uac2_opts *opts = to_f_uac2_opts(item);
1020
1021 usb_put_function_instance(&opts->func_inst);
1022 }
1023
1024 static struct configfs_item_operations f_uac2_item_ops = {
1025 .release = f_uac2_attr_release,
1026 };
1027
1028 #define UAC2_ATTRIBUTE(name) \
1029 static ssize_t f_uac2_opts_##name##_show(struct config_item *item, \
1030 char *page) \
1031 { \
1032 struct f_uac2_opts *opts = to_f_uac2_opts(item); \
1033 int result; \
1034 \
1035 mutex_lock(&opts->lock); \
1036 result = sprintf(page, "%u\n", opts->name); \
1037 mutex_unlock(&opts->lock); \
1038 \
1039 return result; \
1040 } \
1041 \
1042 static ssize_t f_uac2_opts_##name##_store(struct config_item *item, \
1043 const char *page, size_t len) \
1044 { \
1045 struct f_uac2_opts *opts = to_f_uac2_opts(item); \
1046 int ret; \
1047 u32 num; \
1048 \
1049 mutex_lock(&opts->lock); \
1050 if (opts->refcnt) { \
1051 ret = -EBUSY; \
1052 goto end; \
1053 } \
1054 \
1055 ret = kstrtou32(page, 0, &num); \
1056 if (ret) \
1057 goto end; \
1058 \
1059 opts->name = num; \
1060 ret = len; \
1061 \
1062 end: \
1063 mutex_unlock(&opts->lock); \
1064 return ret; \
1065 } \
1066 \
1067 CONFIGFS_ATTR(f_uac2_opts_, name)
1068
1069 UAC2_ATTRIBUTE(p_chmask);
1070 UAC2_ATTRIBUTE(p_srate);
1071 UAC2_ATTRIBUTE(p_ssize);
1072 UAC2_ATTRIBUTE(c_chmask);
1073 UAC2_ATTRIBUTE(c_srate);
1074 UAC2_ATTRIBUTE(c_ssize);
1075 UAC2_ATTRIBUTE(req_number);
1076
1077 static struct configfs_attribute *f_uac2_attrs[] = {
1078 &f_uac2_opts_attr_p_chmask,
1079 &f_uac2_opts_attr_p_srate,
1080 &f_uac2_opts_attr_p_ssize,
1081 &f_uac2_opts_attr_c_chmask,
1082 &f_uac2_opts_attr_c_srate,
1083 &f_uac2_opts_attr_c_ssize,
1084 &f_uac2_opts_attr_req_number,
1085 NULL,
1086 };
1087
1088 static const struct config_item_type f_uac2_func_type = {
1089 .ct_item_ops = &f_uac2_item_ops,
1090 .ct_attrs = f_uac2_attrs,
1091 .ct_owner = THIS_MODULE,
1092 };
1093
1094 static void afunc_free_inst(struct usb_function_instance *f)
1095 {
1096 struct f_uac2_opts *opts;
1097
1098 opts = container_of(f, struct f_uac2_opts, func_inst);
1099 kfree(opts);
1100 }
1101
1102 static struct usb_function_instance *afunc_alloc_inst(void)
1103 {
1104 struct f_uac2_opts *opts;
1105
1106 opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1107 if (!opts)
1108 return ERR_PTR(-ENOMEM);
1109
1110 mutex_init(&opts->lock);
1111 opts->func_inst.free_func_inst = afunc_free_inst;
1112
1113 config_group_init_type_name(&opts->func_inst.group, "",
1114 &f_uac2_func_type);
1115
1116 opts->p_chmask = UAC2_DEF_PCHMASK;
1117 opts->p_srate = UAC2_DEF_PSRATE;
1118 opts->p_ssize = UAC2_DEF_PSSIZE;
1119 opts->c_chmask = UAC2_DEF_CCHMASK;
1120 opts->c_srate = UAC2_DEF_CSRATE;
1121 opts->c_ssize = UAC2_DEF_CSSIZE;
1122 opts->req_number = UAC2_DEF_REQ_NUM;
1123 return &opts->func_inst;
1124 }
1125
1126 static void afunc_free(struct usb_function *f)
1127 {
1128 struct g_audio *agdev;
1129 struct f_uac2_opts *opts;
1130
1131 agdev = func_to_g_audio(f);
1132 opts = container_of(f->fi, struct f_uac2_opts, func_inst);
1133 kfree(agdev);
1134 mutex_lock(&opts->lock);
1135 --opts->refcnt;
1136 mutex_unlock(&opts->lock);
1137 }
1138
1139 static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
1140 {
1141 struct g_audio *agdev = func_to_g_audio(f);
1142
1143 g_audio_cleanup(agdev);
1144 usb_free_all_descriptors(f);
1145
1146 agdev->gadget = NULL;
1147 }
1148
1149 static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
1150 {
1151 struct f_uac2 *uac2;
1152 struct f_uac2_opts *opts;
1153
1154 uac2 = kzalloc(sizeof(*uac2), GFP_KERNEL);
1155 if (uac2 == NULL)
1156 return ERR_PTR(-ENOMEM);
1157
1158 opts = container_of(fi, struct f_uac2_opts, func_inst);
1159 mutex_lock(&opts->lock);
1160 ++opts->refcnt;
1161 mutex_unlock(&opts->lock);
1162
1163 uac2->g_audio.func.name = "uac2_func";
1164 uac2->g_audio.func.bind = afunc_bind;
1165 uac2->g_audio.func.unbind = afunc_unbind;
1166 uac2->g_audio.func.set_alt = afunc_set_alt;
1167 uac2->g_audio.func.get_alt = afunc_get_alt;
1168 uac2->g_audio.func.disable = afunc_disable;
1169 uac2->g_audio.func.setup = afunc_setup;
1170 uac2->g_audio.func.free_func = afunc_free;
1171
1172 return &uac2->g_audio.func;
1173 }
1174
1175 DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
1176 MODULE_LICENSE("GPL");
1177 MODULE_AUTHOR("Yadwinder Singh");
1178 MODULE_AUTHOR("Jaswinder Singh");
Linux with added FPC-III support