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 		((srate / (factor / (1 << (ep_desc->bInterval - 1)))) + 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");
1179