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