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 * Copyright (C) 2020
10 *    Ruslan Bilovol (ruslan.bilovol@gmail.com)
11 */
12
13#include <linux/usb/audio.h>
14#include <linux/usb/audio-v2.h>
15#include <linux/module.h>
16
17#include "u_audio.h"
18
19#include "u_uac2.h"
20
21/* UAC2 spec: 4.1 Audio Channel Cluster Descriptor */
22#define UAC2_CHANNEL_MASK 0x07FFFFFF
23
24/*
25 * The driver implements a simple UAC_2 topology.
26 * USB-OUT -> IT_1 -> FU -> OT_3 -> ALSA_Capture
27 * ALSA_Playback -> IT_2 -> FU -> OT_4 -> USB-IN
28 * Capture and Playback sampling rates are independently
29 *  controlled by two clock sources :
30 *    CLK_5 := c_srate, and CLK_6 := p_srate
31 */
32#define USB_OUT_CLK_ID	(out_clk_src_desc.bClockID)
33#define USB_IN_CLK_ID	(in_clk_src_desc.bClockID)
34#define USB_OUT_FU_ID	(out_feature_unit_desc->bUnitID)
35#define USB_IN_FU_ID	(in_feature_unit_desc->bUnitID)
36
37#define CONTROL_ABSENT	0
38#define CONTROL_RDONLY	1
39#define CONTROL_RDWR	3
40
41#define CLK_FREQ_CTRL	0
42#define CLK_VLD_CTRL	2
43#define FU_MUTE_CTRL	0
44#define FU_VOL_CTRL	2
45
46#define COPY_CTRL	0
47#define CONN_CTRL	2
48#define OVRLD_CTRL	4
49#define CLSTR_CTRL	6
50#define UNFLW_CTRL	8
51#define OVFLW_CTRL	10
52
53#define EPIN_EN(_opts) ((_opts)->p_chmask != 0)
54#define EPOUT_EN(_opts) ((_opts)->c_chmask != 0)
55#define FUIN_EN(_opts) (EPIN_EN(_opts) \
56				&& ((_opts)->p_mute_present \
57				|| (_opts)->p_volume_present))
58#define FUOUT_EN(_opts) (EPOUT_EN(_opts) \
59				&& ((_opts)->c_mute_present \
60				|| (_opts)->c_volume_present))
61#define EPOUT_FBACK_IN_EN(_opts) ((_opts)->c_sync == USB_ENDPOINT_SYNC_ASYNC)
62
63struct f_uac2 {
64	struct g_audio g_audio;
65	u8 ac_intf, as_in_intf, as_out_intf;
66	u8 ac_alt, as_in_alt, as_out_alt;	/* needed for get_alt() */
67
68	struct usb_ctrlrequest setup_cr;	/* will be used in data stage */
69
70	/* Interrupt IN endpoint of AC interface */
71	struct usb_ep	*int_ep;
72	atomic_t	int_count;
73	/* transient state, only valid during handling of a single control request */
74	int clock_id;
75};
76
77static inline struct f_uac2 *func_to_uac2(struct usb_function *f)
78{
79	return container_of(f, struct f_uac2, g_audio.func);
80}
81
82static inline
83struct f_uac2_opts *g_audio_to_uac2_opts(struct g_audio *agdev)
84{
85	return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
86}
87
88static int afunc_notify(struct g_audio *agdev, int unit_id, int cs);
89
90/* --------- USB Function Interface ------------- */
91
92enum {
93	STR_ASSOC,
94	STR_IF_CTRL,
95	STR_CLKSRC_IN,
96	STR_CLKSRC_OUT,
97	STR_USB_IT,
98	STR_IO_IT,
99	STR_USB_OT,
100	STR_IO_OT,
101	STR_FU_IN,
102	STR_FU_OUT,
103	STR_AS_OUT_ALT0,
104	STR_AS_OUT_ALT1,
105	STR_AS_IN_ALT0,
106	STR_AS_IN_ALT1,
107};
108
109static struct usb_string strings_fn[] = {
110	/* [STR_ASSOC].s = DYNAMIC, */
111	[STR_IF_CTRL].s = "Topology Control",
112	[STR_CLKSRC_IN].s = "Input Clock",
113	[STR_CLKSRC_OUT].s = "Output Clock",
114	[STR_USB_IT].s = "USBH Out",
115	[STR_IO_IT].s = "USBD Out",
116	[STR_USB_OT].s = "USBH In",
117	[STR_IO_OT].s = "USBD In",
118	[STR_FU_IN].s = "Capture Volume",
119	[STR_FU_OUT].s = "Playback Volume",
120	[STR_AS_OUT_ALT0].s = "Playback Inactive",
121	[STR_AS_OUT_ALT1].s = "Playback Active",
122	[STR_AS_IN_ALT0].s = "Capture Inactive",
123	[STR_AS_IN_ALT1].s = "Capture Active",
124	{ },
125};
126
127static const char *const speed_names[] = {
128	[USB_SPEED_UNKNOWN] = "UNKNOWN",
129	[USB_SPEED_LOW] = "LS",
130	[USB_SPEED_FULL] = "FS",
131	[USB_SPEED_HIGH] = "HS",
132	[USB_SPEED_WIRELESS] = "W",
133	[USB_SPEED_SUPER] = "SS",
134	[USB_SPEED_SUPER_PLUS] = "SS+",
135};
136
137static struct usb_gadget_strings str_fn = {
138	.language = 0x0409,	/* en-us */
139	.strings = strings_fn,
140};
141
142static struct usb_gadget_strings *fn_strings[] = {
143	&str_fn,
144	NULL,
145};
146
147static struct usb_interface_assoc_descriptor iad_desc = {
148	.bLength = sizeof iad_desc,
149	.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
150
151	.bFirstInterface = 0,
152	.bInterfaceCount = 3,
153	.bFunctionClass = USB_CLASS_AUDIO,
154	.bFunctionSubClass = UAC2_FUNCTION_SUBCLASS_UNDEFINED,
155	.bFunctionProtocol = UAC_VERSION_2,
156};
157
158/* Audio Control Interface */
159static struct usb_interface_descriptor std_ac_if_desc = {
160	.bLength = sizeof std_ac_if_desc,
161	.bDescriptorType = USB_DT_INTERFACE,
162
163	.bAlternateSetting = 0,
164	/* .bNumEndpoints = DYNAMIC */
165	.bInterfaceClass = USB_CLASS_AUDIO,
166	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
167	.bInterfaceProtocol = UAC_VERSION_2,
168};
169
170/* Clock source for IN traffic */
171static struct uac_clock_source_descriptor in_clk_src_desc = {
172	.bLength = sizeof in_clk_src_desc,
173	.bDescriptorType = USB_DT_CS_INTERFACE,
174
175	.bDescriptorSubtype = UAC2_CLOCK_SOURCE,
176	/* .bClockID = DYNAMIC */
177	.bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
178	.bmControls = (CONTROL_RDWR << CLK_FREQ_CTRL),
179	.bAssocTerminal = 0,
180};
181
182/* Clock source for OUT traffic */
183static struct uac_clock_source_descriptor out_clk_src_desc = {
184	.bLength = sizeof out_clk_src_desc,
185	.bDescriptorType = USB_DT_CS_INTERFACE,
186
187	.bDescriptorSubtype = UAC2_CLOCK_SOURCE,
188	/* .bClockID = DYNAMIC */
189	.bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
190	.bmControls = (CONTROL_RDWR << CLK_FREQ_CTRL),
191	.bAssocTerminal = 0,
192};
193
194/* Input Terminal for USB_OUT */
195static struct uac2_input_terminal_descriptor usb_out_it_desc = {
196	.bLength = sizeof usb_out_it_desc,
197	.bDescriptorType = USB_DT_CS_INTERFACE,
198
199	.bDescriptorSubtype = UAC_INPUT_TERMINAL,
200	/* .bTerminalID = DYNAMIC */
201	.wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
202	.bAssocTerminal = 0,
203	/* .bCSourceID = DYNAMIC */
204	.iChannelNames = 0,
205	.bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
206};
207
208/* Input Terminal for I/O-In */
209static struct uac2_input_terminal_descriptor io_in_it_desc = {
210	.bLength = sizeof io_in_it_desc,
211	.bDescriptorType = USB_DT_CS_INTERFACE,
212
213	.bDescriptorSubtype = UAC_INPUT_TERMINAL,
214	/* .bTerminalID = DYNAMIC */
215	.wTerminalType = cpu_to_le16(UAC_INPUT_TERMINAL_MICROPHONE),
216	.bAssocTerminal = 0,
217	/* .bCSourceID = DYNAMIC */
218	.iChannelNames = 0,
219	.bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
220};
221
222/* Ouput Terminal for USB_IN */
223static struct uac2_output_terminal_descriptor usb_in_ot_desc = {
224	.bLength = sizeof usb_in_ot_desc,
225	.bDescriptorType = USB_DT_CS_INTERFACE,
226
227	.bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
228	/* .bTerminalID = DYNAMIC */
229	.wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
230	.bAssocTerminal = 0,
231	/* .bSourceID = DYNAMIC */
232	/* .bCSourceID = DYNAMIC */
233	.bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
234};
235
236/* Ouput Terminal for I/O-Out */
237static struct uac2_output_terminal_descriptor io_out_ot_desc = {
238	.bLength = sizeof io_out_ot_desc,
239	.bDescriptorType = USB_DT_CS_INTERFACE,
240
241	.bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
242	/* .bTerminalID = DYNAMIC */
243	.wTerminalType = cpu_to_le16(UAC_OUTPUT_TERMINAL_SPEAKER),
244	.bAssocTerminal = 0,
245	/* .bSourceID = DYNAMIC */
246	/* .bCSourceID = DYNAMIC */
247	.bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
248};
249
250static struct uac2_feature_unit_descriptor *in_feature_unit_desc;
251static struct uac2_feature_unit_descriptor *out_feature_unit_desc;
252
253static struct uac2_ac_header_descriptor ac_hdr_desc = {
254	.bLength = sizeof ac_hdr_desc,
255	.bDescriptorType = USB_DT_CS_INTERFACE,
256
257	.bDescriptorSubtype = UAC_MS_HEADER,
258	.bcdADC = cpu_to_le16(0x200),
259	.bCategory = UAC2_FUNCTION_IO_BOX,
260	/* .wTotalLength = DYNAMIC */
261	.bmControls = 0,
262};
263
264/* AC IN Interrupt Endpoint */
265static struct usb_endpoint_descriptor fs_ep_int_desc = {
266	.bLength = USB_DT_ENDPOINT_SIZE,
267	.bDescriptorType = USB_DT_ENDPOINT,
268
269	.bEndpointAddress = USB_DIR_IN,
270	.bmAttributes = USB_ENDPOINT_XFER_INT,
271	.wMaxPacketSize = cpu_to_le16(6),
272	.bInterval = 1,
273};
274
275static struct usb_endpoint_descriptor hs_ep_int_desc = {
276	.bLength = USB_DT_ENDPOINT_SIZE,
277	.bDescriptorType = USB_DT_ENDPOINT,
278
279	.bmAttributes = USB_ENDPOINT_XFER_INT,
280	.wMaxPacketSize = cpu_to_le16(6),
281	.bInterval = 4,
282};
283
284static struct usb_endpoint_descriptor ss_ep_int_desc = {
285	.bLength = USB_DT_ENDPOINT_SIZE,
286	.bDescriptorType = USB_DT_ENDPOINT,
287
288	.bEndpointAddress = USB_DIR_IN,
289	.bmAttributes = USB_ENDPOINT_XFER_INT,
290	.wMaxPacketSize = cpu_to_le16(6),
291	.bInterval = 4,
292};
293
294static struct usb_ss_ep_comp_descriptor ss_ep_int_desc_comp = {
295	.bLength = sizeof(ss_ep_int_desc_comp),
296	.bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
297	.wBytesPerInterval = cpu_to_le16(6),
298};
299
300/* Audio Streaming OUT Interface - Alt0 */
301static struct usb_interface_descriptor std_as_out_if0_desc = {
302	.bLength = sizeof std_as_out_if0_desc,
303	.bDescriptorType = USB_DT_INTERFACE,
304
305	.bAlternateSetting = 0,
306	.bNumEndpoints = 0,
307	.bInterfaceClass = USB_CLASS_AUDIO,
308	.bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
309	.bInterfaceProtocol = UAC_VERSION_2,
310};
311
312/* Audio Streaming OUT Interface - Alt1 */
313static struct usb_interface_descriptor std_as_out_if1_desc = {
314	.bLength = sizeof std_as_out_if1_desc,
315	.bDescriptorType = USB_DT_INTERFACE,
316
317	.bAlternateSetting = 1,
318	.bNumEndpoints = 1,
319	.bInterfaceClass = USB_CLASS_AUDIO,
320	.bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
321	.bInterfaceProtocol = UAC_VERSION_2,
322};
323
324/* Audio Stream OUT Intface Desc */
325static struct uac2_as_header_descriptor as_out_hdr_desc = {
326	.bLength = sizeof as_out_hdr_desc,
327	.bDescriptorType = USB_DT_CS_INTERFACE,
328
329	.bDescriptorSubtype = UAC_AS_GENERAL,
330	/* .bTerminalLink = DYNAMIC */
331	.bmControls = 0,
332	.bFormatType = UAC_FORMAT_TYPE_I,
333	.bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
334	.iChannelNames = 0,
335};
336
337/* Audio USB_OUT Format */
338static struct uac2_format_type_i_descriptor as_out_fmt1_desc = {
339	.bLength = sizeof as_out_fmt1_desc,
340	.bDescriptorType = USB_DT_CS_INTERFACE,
341	.bDescriptorSubtype = UAC_FORMAT_TYPE,
342	.bFormatType = UAC_FORMAT_TYPE_I,
343};
344
345/* STD AS ISO OUT Endpoint */
346static struct usb_endpoint_descriptor fs_epout_desc = {
347	.bLength = USB_DT_ENDPOINT_SIZE,
348	.bDescriptorType = USB_DT_ENDPOINT,
349
350	.bEndpointAddress = USB_DIR_OUT,
351	/* .bmAttributes = DYNAMIC */
352	/* .wMaxPacketSize = DYNAMIC */
353	.bInterval = 1,
354};
355
356static struct usb_endpoint_descriptor hs_epout_desc = {
357	.bLength = USB_DT_ENDPOINT_SIZE,
358	.bDescriptorType = USB_DT_ENDPOINT,
359
360	/* .bmAttributes = DYNAMIC */
361	/* .wMaxPacketSize = DYNAMIC */
362	/* .bInterval = DYNAMIC */
363};
364
365static struct usb_endpoint_descriptor ss_epout_desc = {
366	.bLength = USB_DT_ENDPOINT_SIZE,
367	.bDescriptorType = USB_DT_ENDPOINT,
368
369	.bEndpointAddress = USB_DIR_OUT,
370	/* .bmAttributes = DYNAMIC */
371	/* .wMaxPacketSize = DYNAMIC */
372	/* .bInterval = DYNAMIC */
373};
374
375static struct usb_ss_ep_comp_descriptor ss_epout_desc_comp = {
376	.bLength		= sizeof(ss_epout_desc_comp),
377	.bDescriptorType	= USB_DT_SS_ENDPOINT_COMP,
378	.bMaxBurst		= 0,
379	.bmAttributes		= 0,
380	/* wBytesPerInterval = DYNAMIC */
381};
382
383/* CS AS ISO OUT Endpoint */
384static struct uac2_iso_endpoint_descriptor as_iso_out_desc = {
385	.bLength = sizeof as_iso_out_desc,
386	.bDescriptorType = USB_DT_CS_ENDPOINT,
387
388	.bDescriptorSubtype = UAC_EP_GENERAL,
389	.bmAttributes = 0,
390	.bmControls = 0,
391	.bLockDelayUnits = 0,
392	.wLockDelay = 0,
393};
394
395/* STD AS ISO IN Feedback Endpoint */
396static struct usb_endpoint_descriptor fs_epin_fback_desc = {
397	.bLength = USB_DT_ENDPOINT_SIZE,
398	.bDescriptorType = USB_DT_ENDPOINT,
399
400	.bEndpointAddress = USB_DIR_IN,
401	.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_USAGE_FEEDBACK,
402	.wMaxPacketSize = cpu_to_le16(3),
403	.bInterval = 1,
404};
405
406static struct usb_endpoint_descriptor hs_epin_fback_desc = {
407	.bLength = USB_DT_ENDPOINT_SIZE,
408	.bDescriptorType = USB_DT_ENDPOINT,
409
410	.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_USAGE_FEEDBACK,
411	.wMaxPacketSize = cpu_to_le16(4),
412	.bInterval = 4,
413};
414
415static struct usb_endpoint_descriptor ss_epin_fback_desc = {
416	.bLength = USB_DT_ENDPOINT_SIZE,
417	.bDescriptorType = USB_DT_ENDPOINT,
418
419	.bEndpointAddress = USB_DIR_IN,
420	.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_USAGE_FEEDBACK,
421	.wMaxPacketSize = cpu_to_le16(4),
422	.bInterval = 4,
423};
424
425static struct usb_ss_ep_comp_descriptor ss_epin_fback_desc_comp = {
426	.bLength		= sizeof(ss_epin_fback_desc_comp),
427	.bDescriptorType	= USB_DT_SS_ENDPOINT_COMP,
428	.bMaxBurst		= 0,
429	.bmAttributes		= 0,
430	.wBytesPerInterval	= cpu_to_le16(4),
431};
432
433
434/* Audio Streaming IN Interface - Alt0 */
435static struct usb_interface_descriptor std_as_in_if0_desc = {
436	.bLength = sizeof std_as_in_if0_desc,
437	.bDescriptorType = USB_DT_INTERFACE,
438
439	.bAlternateSetting = 0,
440	.bNumEndpoints = 0,
441	.bInterfaceClass = USB_CLASS_AUDIO,
442	.bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
443	.bInterfaceProtocol = UAC_VERSION_2,
444};
445
446/* Audio Streaming IN Interface - Alt1 */
447static struct usb_interface_descriptor std_as_in_if1_desc = {
448	.bLength = sizeof std_as_in_if1_desc,
449	.bDescriptorType = USB_DT_INTERFACE,
450
451	.bAlternateSetting = 1,
452	.bNumEndpoints = 1,
453	.bInterfaceClass = USB_CLASS_AUDIO,
454	.bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
455	.bInterfaceProtocol = UAC_VERSION_2,
456};
457
458/* Audio Stream IN Intface Desc */
459static struct uac2_as_header_descriptor as_in_hdr_desc = {
460	.bLength = sizeof as_in_hdr_desc,
461	.bDescriptorType = USB_DT_CS_INTERFACE,
462
463	.bDescriptorSubtype = UAC_AS_GENERAL,
464	/* .bTerminalLink = DYNAMIC */
465	.bmControls = 0,
466	.bFormatType = UAC_FORMAT_TYPE_I,
467	.bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
468	.iChannelNames = 0,
469};
470
471/* Audio USB_IN Format */
472static struct uac2_format_type_i_descriptor as_in_fmt1_desc = {
473	.bLength = sizeof as_in_fmt1_desc,
474	.bDescriptorType = USB_DT_CS_INTERFACE,
475	.bDescriptorSubtype = UAC_FORMAT_TYPE,
476	.bFormatType = UAC_FORMAT_TYPE_I,
477};
478
479/* STD AS ISO IN Endpoint */
480static struct usb_endpoint_descriptor fs_epin_desc = {
481	.bLength = USB_DT_ENDPOINT_SIZE,
482	.bDescriptorType = USB_DT_ENDPOINT,
483
484	.bEndpointAddress = USB_DIR_IN,
485	.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
486	/* .wMaxPacketSize = DYNAMIC */
487	.bInterval = 1,
488};
489
490static struct usb_endpoint_descriptor hs_epin_desc = {
491	.bLength = USB_DT_ENDPOINT_SIZE,
492	.bDescriptorType = USB_DT_ENDPOINT,
493
494	.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
495	/* .wMaxPacketSize = DYNAMIC */
496	/* .bInterval = DYNAMIC */
497};
498
499static struct usb_endpoint_descriptor ss_epin_desc = {
500	.bLength = USB_DT_ENDPOINT_SIZE,
501	.bDescriptorType = USB_DT_ENDPOINT,
502
503	.bEndpointAddress = USB_DIR_IN,
504	.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
505	/* .wMaxPacketSize = DYNAMIC */
506	/* .bInterval = DYNAMIC */
507};
508
509static struct usb_ss_ep_comp_descriptor ss_epin_desc_comp = {
510	.bLength		= sizeof(ss_epin_desc_comp),
511	.bDescriptorType	= USB_DT_SS_ENDPOINT_COMP,
512	.bMaxBurst		= 0,
513	.bmAttributes		= 0,
514	/* wBytesPerInterval = DYNAMIC */
515};
516
517/* CS AS ISO IN Endpoint */
518static struct uac2_iso_endpoint_descriptor as_iso_in_desc = {
519	.bLength = sizeof as_iso_in_desc,
520	.bDescriptorType = USB_DT_CS_ENDPOINT,
521
522	.bDescriptorSubtype = UAC_EP_GENERAL,
523	.bmAttributes = 0,
524	.bmControls = 0,
525	.bLockDelayUnits = 0,
526	.wLockDelay = 0,
527};
528
529static struct usb_descriptor_header *fs_audio_desc[] = {
530	(struct usb_descriptor_header *)&iad_desc,
531	(struct usb_descriptor_header *)&std_ac_if_desc,
532
533	(struct usb_descriptor_header *)&ac_hdr_desc,
534	(struct usb_descriptor_header *)&in_clk_src_desc,
535	(struct usb_descriptor_header *)&out_clk_src_desc,
536	(struct usb_descriptor_header *)&usb_out_it_desc,
537	(struct usb_descriptor_header *)&out_feature_unit_desc,
538	(struct usb_descriptor_header *)&io_in_it_desc,
539	(struct usb_descriptor_header *)&usb_in_ot_desc,
540	(struct usb_descriptor_header *)&in_feature_unit_desc,
541	(struct usb_descriptor_header *)&io_out_ot_desc,
542
543	(struct usb_descriptor_header *)&fs_ep_int_desc,
544
545	(struct usb_descriptor_header *)&std_as_out_if0_desc,
546	(struct usb_descriptor_header *)&std_as_out_if1_desc,
547
548	(struct usb_descriptor_header *)&as_out_hdr_desc,
549	(struct usb_descriptor_header *)&as_out_fmt1_desc,
550	(struct usb_descriptor_header *)&fs_epout_desc,
551	(struct usb_descriptor_header *)&as_iso_out_desc,
552	(struct usb_descriptor_header *)&fs_epin_fback_desc,
553
554	(struct usb_descriptor_header *)&std_as_in_if0_desc,
555	(struct usb_descriptor_header *)&std_as_in_if1_desc,
556
557	(struct usb_descriptor_header *)&as_in_hdr_desc,
558	(struct usb_descriptor_header *)&as_in_fmt1_desc,
559	(struct usb_descriptor_header *)&fs_epin_desc,
560	(struct usb_descriptor_header *)&as_iso_in_desc,
561	NULL,
562};
563
564static struct usb_descriptor_header *hs_audio_desc[] = {
565	(struct usb_descriptor_header *)&iad_desc,
566	(struct usb_descriptor_header *)&std_ac_if_desc,
567
568	(struct usb_descriptor_header *)&ac_hdr_desc,
569	(struct usb_descriptor_header *)&in_clk_src_desc,
570	(struct usb_descriptor_header *)&out_clk_src_desc,
571	(struct usb_descriptor_header *)&usb_out_it_desc,
572	(struct usb_descriptor_header *)&out_feature_unit_desc,
573	(struct usb_descriptor_header *)&io_in_it_desc,
574	(struct usb_descriptor_header *)&usb_in_ot_desc,
575	(struct usb_descriptor_header *)&in_feature_unit_desc,
576	(struct usb_descriptor_header *)&io_out_ot_desc,
577
578	(struct usb_descriptor_header *)&hs_ep_int_desc,
579
580	(struct usb_descriptor_header *)&std_as_out_if0_desc,
581	(struct usb_descriptor_header *)&std_as_out_if1_desc,
582
583	(struct usb_descriptor_header *)&as_out_hdr_desc,
584	(struct usb_descriptor_header *)&as_out_fmt1_desc,
585	(struct usb_descriptor_header *)&hs_epout_desc,
586	(struct usb_descriptor_header *)&as_iso_out_desc,
587	(struct usb_descriptor_header *)&hs_epin_fback_desc,
588
589	(struct usb_descriptor_header *)&std_as_in_if0_desc,
590	(struct usb_descriptor_header *)&std_as_in_if1_desc,
591
592	(struct usb_descriptor_header *)&as_in_hdr_desc,
593	(struct usb_descriptor_header *)&as_in_fmt1_desc,
594	(struct usb_descriptor_header *)&hs_epin_desc,
595	(struct usb_descriptor_header *)&as_iso_in_desc,
596	NULL,
597};
598
599static struct usb_descriptor_header *ss_audio_desc[] = {
600	(struct usb_descriptor_header *)&iad_desc,
601	(struct usb_descriptor_header *)&std_ac_if_desc,
602
603	(struct usb_descriptor_header *)&ac_hdr_desc,
604	(struct usb_descriptor_header *)&in_clk_src_desc,
605	(struct usb_descriptor_header *)&out_clk_src_desc,
606	(struct usb_descriptor_header *)&usb_out_it_desc,
607  (struct usb_descriptor_header *)&out_feature_unit_desc,
608	(struct usb_descriptor_header *)&io_in_it_desc,
609	(struct usb_descriptor_header *)&usb_in_ot_desc,
610	(struct usb_descriptor_header *)&in_feature_unit_desc,
611	(struct usb_descriptor_header *)&io_out_ot_desc,
612
613	(struct usb_descriptor_header *)&ss_ep_int_desc,
614	(struct usb_descriptor_header *)&ss_ep_int_desc_comp,
615
616	(struct usb_descriptor_header *)&std_as_out_if0_desc,
617	(struct usb_descriptor_header *)&std_as_out_if1_desc,
618
619	(struct usb_descriptor_header *)&as_out_hdr_desc,
620	(struct usb_descriptor_header *)&as_out_fmt1_desc,
621	(struct usb_descriptor_header *)&ss_epout_desc,
622	(struct usb_descriptor_header *)&ss_epout_desc_comp,
623	(struct usb_descriptor_header *)&as_iso_out_desc,
624	(struct usb_descriptor_header *)&ss_epin_fback_desc,
625	(struct usb_descriptor_header *)&ss_epin_fback_desc_comp,
626
627	(struct usb_descriptor_header *)&std_as_in_if0_desc,
628	(struct usb_descriptor_header *)&std_as_in_if1_desc,
629
630	(struct usb_descriptor_header *)&as_in_hdr_desc,
631	(struct usb_descriptor_header *)&as_in_fmt1_desc,
632	(struct usb_descriptor_header *)&ss_epin_desc,
633	(struct usb_descriptor_header *)&ss_epin_desc_comp,
634	(struct usb_descriptor_header *)&as_iso_in_desc,
635	NULL,
636};
637
638struct cntrl_cur_lay2 {
639	__le16	wCUR;
640};
641
642struct cntrl_range_lay2 {
643	__le16	wNumSubRanges;
644	__le16	wMIN;
645	__le16	wMAX;
646	__le16	wRES;
647} __packed;
648
649struct cntrl_cur_lay3 {
650	__le32	dCUR;
651};
652
653struct cntrl_subrange_lay3 {
654	__le32	dMIN;
655	__le32	dMAX;
656	__le32	dRES;
657} __packed;
658
659#define ranges_lay3_size(c) (sizeof(c.wNumSubRanges)	\
660		+ le16_to_cpu(c.wNumSubRanges)		\
661		* sizeof(struct cntrl_subrange_lay3))
662
663#define DECLARE_UAC2_CNTRL_RANGES_LAY3(k, n)		\
664	struct cntrl_ranges_lay3_##k {			\
665	__le16	wNumSubRanges;				\
666	struct cntrl_subrange_lay3 r[n];		\
667} __packed
668
669DECLARE_UAC2_CNTRL_RANGES_LAY3(srates, UAC_MAX_RATES);
670
671static int get_max_srate(const int *srates)
672{
673	int i, max_srate = 0;
674
675	for (i = 0; i < UAC_MAX_RATES; i++) {
676		if (srates[i] == 0)
677			break;
678		if (srates[i] > max_srate)
679			max_srate = srates[i];
680	}
681	return max_srate;
682}
683
684static int get_max_bw_for_bint(const struct f_uac2_opts *uac2_opts,
685	u8 bint, unsigned int factor, bool is_playback)
686{
687	int chmask, srate, ssize;
688	u16 max_size_bw;
689
690	if (is_playback) {
691		chmask = uac2_opts->p_chmask;
692		srate = get_max_srate(uac2_opts->p_srates);
693		ssize = uac2_opts->p_ssize;
694	} else {
695		chmask = uac2_opts->c_chmask;
696		srate = get_max_srate(uac2_opts->c_srates);
697		ssize = uac2_opts->c_ssize;
698	}
699
700	if (is_playback || (uac2_opts->c_sync == USB_ENDPOINT_SYNC_ASYNC)) {
701		// playback is always async, capture only when configured
702		// Win10 requires max packet size + 1 frame
703		srate = srate * (1000 + uac2_opts->fb_max) / 1000;
704		// updated srate is always bigger, therefore DIV_ROUND_UP always yields +1
705		max_size_bw = num_channels(chmask) * ssize *
706			(DIV_ROUND_UP(srate, factor / (1 << (bint - 1))));
707	} else {
708		// adding 1 frame provision for Win10
709		max_size_bw = num_channels(chmask) * ssize *
710			(DIV_ROUND_UP(srate, factor / (1 << (bint - 1))) + 1);
711	}
712	return max_size_bw;
713}
714
715static int set_ep_max_packet_size_bint(struct device *dev, const struct f_uac2_opts *uac2_opts,
716	struct usb_endpoint_descriptor *ep_desc,
717	enum usb_device_speed speed, bool is_playback)
718{
719	u16 max_size_bw, max_size_ep;
720	u8 bint, opts_bint;
721	char *dir;
722
723	switch (speed) {
724	case USB_SPEED_FULL:
725		max_size_ep = 1023;
726		// fixed
727		bint = ep_desc->bInterval;
728		max_size_bw = get_max_bw_for_bint(uac2_opts, bint, 1000, is_playback);
729		break;
730
731	case USB_SPEED_HIGH:
732	case USB_SPEED_SUPER:
733		max_size_ep = 1024;
734		if (is_playback)
735			opts_bint = uac2_opts->p_hs_bint;
736		else
737			opts_bint = uac2_opts->c_hs_bint;
738
739		if (opts_bint > 0) {
740			/* fixed bint */
741			bint = opts_bint;
742			max_size_bw = get_max_bw_for_bint(uac2_opts, bint, 8000, is_playback);
743		} else {
744			/* checking bInterval from 4 to 1 whether the required bandwidth fits */
745			for (bint = 4; bint > 0; --bint) {
746				max_size_bw = get_max_bw_for_bint(
747					uac2_opts, bint, 8000, is_playback);
748				if (max_size_bw <= max_size_ep)
749					break;
750			}
751		}
752		break;
753
754	default:
755		return -EINVAL;
756	}
757
758	if (is_playback)
759		dir = "Playback";
760	else
761		dir = "Capture";
762
763	if (max_size_bw <= max_size_ep)
764		dev_dbg(dev,
765			"%s %s: Would use wMaxPacketSize %d and bInterval %d\n",
766			speed_names[speed], dir, max_size_bw, bint);
767	else {
768		dev_warn(dev,
769			"%s %s: Req. wMaxPacketSize %d at bInterval %d > max ISOC %d, may drop data!\n",
770			speed_names[speed], dir, max_size_bw, bint, max_size_ep);
771		max_size_bw = max_size_ep;
772	}
773
774	ep_desc->wMaxPacketSize = cpu_to_le16(max_size_bw);
775	ep_desc->bInterval = bint;
776
777	return 0;
778}
779
780static struct uac2_feature_unit_descriptor *build_fu_desc(int chmask)
781{
782	struct uac2_feature_unit_descriptor *fu_desc;
783	int channels = num_channels(chmask);
784	int fu_desc_size = UAC2_DT_FEATURE_UNIT_SIZE(channels);
785
786	fu_desc = kzalloc(fu_desc_size, GFP_KERNEL);
787	if (!fu_desc)
788		return NULL;
789
790	fu_desc->bLength = fu_desc_size;
791	fu_desc->bDescriptorType = USB_DT_CS_INTERFACE;
792
793	fu_desc->bDescriptorSubtype = UAC_FEATURE_UNIT;
794
795	/* bUnitID, bSourceID and bmaControls will be defined later */
796
797	return fu_desc;
798}
799
800/* Use macro to overcome line length limitation */
801#define USBDHDR(p) (struct usb_descriptor_header *)(p)
802
803static void setup_headers(struct f_uac2_opts *opts,
804			  struct usb_descriptor_header **headers,
805			  enum usb_device_speed speed)
806{
807	struct usb_ss_ep_comp_descriptor *epout_desc_comp = NULL;
808	struct usb_ss_ep_comp_descriptor *epin_desc_comp = NULL;
809	struct usb_ss_ep_comp_descriptor *epin_fback_desc_comp = NULL;
810	struct usb_ss_ep_comp_descriptor *ep_int_desc_comp = NULL;
811	struct usb_endpoint_descriptor *epout_desc;
812	struct usb_endpoint_descriptor *epin_desc;
813	struct usb_endpoint_descriptor *epin_fback_desc;
814	struct usb_endpoint_descriptor *ep_int_desc;
815	int i;
816
817	switch (speed) {
818	case USB_SPEED_FULL:
819		epout_desc = &fs_epout_desc;
820		epin_desc = &fs_epin_desc;
821		epin_fback_desc = &fs_epin_fback_desc;
822		ep_int_desc = &fs_ep_int_desc;
823		break;
824	case USB_SPEED_HIGH:
825		epout_desc = &hs_epout_desc;
826		epin_desc = &hs_epin_desc;
827		epin_fback_desc = &hs_epin_fback_desc;
828		ep_int_desc = &hs_ep_int_desc;
829		break;
830	default:
831		epout_desc = &ss_epout_desc;
832		epin_desc = &ss_epin_desc;
833		epout_desc_comp = &ss_epout_desc_comp;
834		epin_desc_comp = &ss_epin_desc_comp;
835		epin_fback_desc = &ss_epin_fback_desc;
836		epin_fback_desc_comp = &ss_epin_fback_desc_comp;
837		ep_int_desc = &ss_ep_int_desc;
838		ep_int_desc_comp = &ss_ep_int_desc_comp;
839	}
840
841	i = 0;
842	headers[i++] = USBDHDR(&iad_desc);
843	headers[i++] = USBDHDR(&std_ac_if_desc);
844	headers[i++] = USBDHDR(&ac_hdr_desc);
845	if (EPIN_EN(opts))
846		headers[i++] = USBDHDR(&in_clk_src_desc);
847	if (EPOUT_EN(opts)) {
848		headers[i++] = USBDHDR(&out_clk_src_desc);
849		headers[i++] = USBDHDR(&usb_out_it_desc);
850
851		if (FUOUT_EN(opts))
852			headers[i++] = USBDHDR(out_feature_unit_desc);
853	}
854
855	if (EPIN_EN(opts)) {
856		headers[i++] = USBDHDR(&io_in_it_desc);
857
858		if (FUIN_EN(opts))
859			headers[i++] = USBDHDR(in_feature_unit_desc);
860
861		headers[i++] = USBDHDR(&usb_in_ot_desc);
862	}
863
864	if (EPOUT_EN(opts))
865		headers[i++] = USBDHDR(&io_out_ot_desc);
866
867	if (FUOUT_EN(opts) || FUIN_EN(opts)) {
868		headers[i++] = USBDHDR(ep_int_desc);
869		if (ep_int_desc_comp)
870			headers[i++] = USBDHDR(ep_int_desc_comp);
871	}
872
873	if (EPOUT_EN(opts)) {
874		headers[i++] = USBDHDR(&std_as_out_if0_desc);
875		headers[i++] = USBDHDR(&std_as_out_if1_desc);
876		headers[i++] = USBDHDR(&as_out_hdr_desc);
877		headers[i++] = USBDHDR(&as_out_fmt1_desc);
878		headers[i++] = USBDHDR(epout_desc);
879		if (epout_desc_comp)
880			headers[i++] = USBDHDR(epout_desc_comp);
881
882		headers[i++] = USBDHDR(&as_iso_out_desc);
883
884		if (EPOUT_FBACK_IN_EN(opts)) {
885			headers[i++] = USBDHDR(epin_fback_desc);
886			if (epin_fback_desc_comp)
887				headers[i++] = USBDHDR(epin_fback_desc_comp);
888		}
889	}
890
891	if (EPIN_EN(opts)) {
892		headers[i++] = USBDHDR(&std_as_in_if0_desc);
893		headers[i++] = USBDHDR(&std_as_in_if1_desc);
894		headers[i++] = USBDHDR(&as_in_hdr_desc);
895		headers[i++] = USBDHDR(&as_in_fmt1_desc);
896		headers[i++] = USBDHDR(epin_desc);
897		if (epin_desc_comp)
898			headers[i++] = USBDHDR(epin_desc_comp);
899
900		headers[i++] = USBDHDR(&as_iso_in_desc);
901	}
902	headers[i] = NULL;
903}
904
905static void setup_descriptor(struct f_uac2_opts *opts)
906{
907	/* patch descriptors */
908	int i = 1; /* ID's start with 1 */
909
910	if (EPOUT_EN(opts))
911		usb_out_it_desc.bTerminalID = i++;
912	if (EPIN_EN(opts))
913		io_in_it_desc.bTerminalID = i++;
914	if (EPOUT_EN(opts))
915		io_out_ot_desc.bTerminalID = i++;
916	if (EPIN_EN(opts))
917		usb_in_ot_desc.bTerminalID = i++;
918	if (FUOUT_EN(opts))
919		out_feature_unit_desc->bUnitID = i++;
920	if (FUIN_EN(opts))
921		in_feature_unit_desc->bUnitID = i++;
922	if (EPOUT_EN(opts))
923		out_clk_src_desc.bClockID = i++;
924	if (EPIN_EN(opts))
925		in_clk_src_desc.bClockID = i++;
926
927	usb_out_it_desc.bCSourceID = out_clk_src_desc.bClockID;
928
929	if (FUIN_EN(opts)) {
930		usb_in_ot_desc.bSourceID = in_feature_unit_desc->bUnitID;
931		in_feature_unit_desc->bSourceID = io_in_it_desc.bTerminalID;
932	} else {
933		usb_in_ot_desc.bSourceID = io_in_it_desc.bTerminalID;
934	}
935
936	usb_in_ot_desc.bCSourceID = in_clk_src_desc.bClockID;
937	io_in_it_desc.bCSourceID = in_clk_src_desc.bClockID;
938	io_out_ot_desc.bCSourceID = out_clk_src_desc.bClockID;
939
940	if (FUOUT_EN(opts)) {
941		io_out_ot_desc.bSourceID = out_feature_unit_desc->bUnitID;
942		out_feature_unit_desc->bSourceID = usb_out_it_desc.bTerminalID;
943	} else {
944		io_out_ot_desc.bSourceID = usb_out_it_desc.bTerminalID;
945	}
946
947	as_out_hdr_desc.bTerminalLink = usb_out_it_desc.bTerminalID;
948	as_in_hdr_desc.bTerminalLink = usb_in_ot_desc.bTerminalID;
949
950	iad_desc.bInterfaceCount = 1;
951	ac_hdr_desc.wTotalLength = cpu_to_le16(sizeof(ac_hdr_desc));
952
953	if (EPIN_EN(opts)) {
954		u16 len = le16_to_cpu(ac_hdr_desc.wTotalLength);
955
956		len += sizeof(in_clk_src_desc);
957		len += sizeof(usb_in_ot_desc);
958
959		if (FUIN_EN(opts))
960			len += in_feature_unit_desc->bLength;
961
962		len += sizeof(io_in_it_desc);
963		ac_hdr_desc.wTotalLength = cpu_to_le16(len);
964		iad_desc.bInterfaceCount++;
965	}
966	if (EPOUT_EN(opts)) {
967		u16 len = le16_to_cpu(ac_hdr_desc.wTotalLength);
968
969		len += sizeof(out_clk_src_desc);
970		len += sizeof(usb_out_it_desc);
971
972		if (FUOUT_EN(opts))
973			len += out_feature_unit_desc->bLength;
974
975		len += sizeof(io_out_ot_desc);
976		ac_hdr_desc.wTotalLength = cpu_to_le16(len);
977		iad_desc.bInterfaceCount++;
978	}
979
980	setup_headers(opts, fs_audio_desc, USB_SPEED_FULL);
981	setup_headers(opts, hs_audio_desc, USB_SPEED_HIGH);
982	setup_headers(opts, ss_audio_desc, USB_SPEED_SUPER);
983}
984
985static int afunc_validate_opts(struct g_audio *agdev, struct device *dev)
986{
987	struct f_uac2_opts *opts = g_audio_to_uac2_opts(agdev);
988	const char *msg = NULL;
989
990	if (!opts->p_chmask && !opts->c_chmask)
991		msg = "no playback and capture channels";
992	else if (opts->p_chmask & ~UAC2_CHANNEL_MASK)
993		msg = "unsupported playback channels mask";
994	else if (opts->c_chmask & ~UAC2_CHANNEL_MASK)
995		msg = "unsupported capture channels mask";
996	else if ((opts->p_ssize < 1) || (opts->p_ssize > 4))
997		msg = "incorrect playback sample size";
998	else if ((opts->c_ssize < 1) || (opts->c_ssize > 4))
999		msg = "incorrect capture sample size";
1000	else if (!opts->p_srates[0])
1001		msg = "incorrect playback sampling rate";
1002	else if (!opts->c_srates[0])
1003		msg = "incorrect capture sampling rate";
1004
1005	else if (opts->p_volume_max <= opts->p_volume_min)
1006		msg = "incorrect playback volume max/min";
1007	else if (opts->c_volume_max <= opts->c_volume_min)
1008		msg = "incorrect capture volume max/min";
1009	else if (opts->p_volume_res <= 0)
1010		msg = "negative/zero playback volume resolution";
1011	else if (opts->c_volume_res <= 0)
1012		msg = "negative/zero capture volume resolution";
1013
1014	else if ((opts->p_volume_max - opts->p_volume_min) % opts->p_volume_res)
1015		msg = "incorrect playback volume resolution";
1016	else if ((opts->c_volume_max - opts->c_volume_min) % opts->c_volume_res)
1017		msg = "incorrect capture volume resolution";
1018
1019	else if ((opts->p_hs_bint < 0) || (opts->p_hs_bint > 4))
1020		msg = "incorrect playback HS/SS bInterval (1-4: fixed, 0: auto)";
1021	else if ((opts->c_hs_bint < 0) || (opts->c_hs_bint > 4))
1022		msg = "incorrect capture HS/SS bInterval (1-4: fixed, 0: auto)";
1023
1024	if (msg) {
1025		dev_err(dev, "Error: %s\n", msg);
1026		return -EINVAL;
1027	}
1028
1029	return 0;
1030}
1031
1032static int
1033afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
1034{
1035	struct f_uac2 *uac2 = func_to_uac2(fn);
1036	struct g_audio *agdev = func_to_g_audio(fn);
1037	struct usb_composite_dev *cdev = cfg->cdev;
1038	struct usb_gadget *gadget = cdev->gadget;
1039	struct device *dev = &gadget->dev;
1040	struct f_uac2_opts *uac2_opts = g_audio_to_uac2_opts(agdev);
1041	struct usb_string *us;
1042	int ret;
1043
1044	ret = afunc_validate_opts(agdev, dev);
1045	if (ret)
1046		return ret;
1047
1048	strings_fn[STR_ASSOC].s = uac2_opts->function_name;
1049
1050	us = usb_gstrings_attach(cdev, fn_strings, ARRAY_SIZE(strings_fn));
1051	if (IS_ERR(us))
1052		return PTR_ERR(us);
1053
1054	if (FUOUT_EN(uac2_opts)) {
1055		out_feature_unit_desc = build_fu_desc(uac2_opts->c_chmask);
1056		if (!out_feature_unit_desc)
1057			return -ENOMEM;
1058	}
1059	if (FUIN_EN(uac2_opts)) {
1060		in_feature_unit_desc = build_fu_desc(uac2_opts->p_chmask);
1061		if (!in_feature_unit_desc) {
1062			ret = -ENOMEM;
1063			goto err_free_fu;
1064		}
1065	}
1066
1067	iad_desc.iFunction = us[STR_ASSOC].id;
1068	std_ac_if_desc.iInterface = us[STR_IF_CTRL].id;
1069	in_clk_src_desc.iClockSource = us[STR_CLKSRC_IN].id;
1070	out_clk_src_desc.iClockSource = us[STR_CLKSRC_OUT].id;
1071	usb_out_it_desc.iTerminal = us[STR_USB_IT].id;
1072	io_in_it_desc.iTerminal = us[STR_IO_IT].id;
1073	usb_in_ot_desc.iTerminal = us[STR_USB_OT].id;
1074	io_out_ot_desc.iTerminal = us[STR_IO_OT].id;
1075	std_as_out_if0_desc.iInterface = us[STR_AS_OUT_ALT0].id;
1076	std_as_out_if1_desc.iInterface = us[STR_AS_OUT_ALT1].id;
1077	std_as_in_if0_desc.iInterface = us[STR_AS_IN_ALT0].id;
1078	std_as_in_if1_desc.iInterface = us[STR_AS_IN_ALT1].id;
1079
1080	if (FUOUT_EN(uac2_opts)) {
1081		u8 *i_feature = (u8 *)out_feature_unit_desc +
1082				out_feature_unit_desc->bLength - 1;
1083		*i_feature = us[STR_FU_OUT].id;
1084	}
1085	if (FUIN_EN(uac2_opts)) {
1086		u8 *i_feature = (u8 *)in_feature_unit_desc +
1087				in_feature_unit_desc->bLength - 1;
1088		*i_feature = us[STR_FU_IN].id;
1089	}
1090
1091
1092	/* Initialize the configurable parameters */
1093	usb_out_it_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
1094	usb_out_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
1095	io_in_it_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
1096	io_in_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
1097	as_out_hdr_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
1098	as_out_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
1099	as_in_hdr_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
1100	as_in_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
1101	as_out_fmt1_desc.bSubslotSize = uac2_opts->c_ssize;
1102	as_out_fmt1_desc.bBitResolution = uac2_opts->c_ssize * 8;
1103	as_in_fmt1_desc.bSubslotSize = uac2_opts->p_ssize;
1104	as_in_fmt1_desc.bBitResolution = uac2_opts->p_ssize * 8;
1105	if (FUOUT_EN(uac2_opts)) {
1106		__le32 *bma = (__le32 *)&out_feature_unit_desc->bmaControls[0];
1107		u32 control = 0;
1108
1109		if (uac2_opts->c_mute_present)
1110			control |= CONTROL_RDWR << FU_MUTE_CTRL;
1111		if (uac2_opts->c_volume_present)
1112			control |= CONTROL_RDWR << FU_VOL_CTRL;
1113		*bma = cpu_to_le32(control);
1114	}
1115	if (FUIN_EN(uac2_opts)) {
1116		__le32 *bma = (__le32 *)&in_feature_unit_desc->bmaControls[0];
1117		u32 control = 0;
1118
1119		if (uac2_opts->p_mute_present)
1120			control |= CONTROL_RDWR << FU_MUTE_CTRL;
1121		if (uac2_opts->p_volume_present)
1122			control |= CONTROL_RDWR << FU_VOL_CTRL;
1123		*bma = cpu_to_le32(control);
1124	}
1125
1126	ret = usb_interface_id(cfg, fn);
1127	if (ret < 0) {
1128		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1129		goto err_free_fu;
1130	}
1131	iad_desc.bFirstInterface = ret;
1132
1133	std_ac_if_desc.bInterfaceNumber = ret;
1134	uac2->ac_intf = ret;
1135	uac2->ac_alt = 0;
1136
1137	if (EPOUT_EN(uac2_opts)) {
1138		ret = usb_interface_id(cfg, fn);
1139		if (ret < 0) {
1140			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1141			goto err_free_fu;
1142		}
1143		std_as_out_if0_desc.bInterfaceNumber = ret;
1144		std_as_out_if1_desc.bInterfaceNumber = ret;
1145		std_as_out_if1_desc.bNumEndpoints = 1;
1146		uac2->as_out_intf = ret;
1147		uac2->as_out_alt = 0;
1148
1149		if (EPOUT_FBACK_IN_EN(uac2_opts)) {
1150			fs_epout_desc.bmAttributes =
1151			  USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC;
1152			hs_epout_desc.bmAttributes =
1153			  USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC;
1154			ss_epout_desc.bmAttributes =
1155			  USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC;
1156			std_as_out_if1_desc.bNumEndpoints++;
1157		} else {
1158			fs_epout_desc.bmAttributes =
1159			  USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ADAPTIVE;
1160			hs_epout_desc.bmAttributes =
1161			  USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ADAPTIVE;
1162			ss_epout_desc.bmAttributes =
1163			  USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ADAPTIVE;
1164		}
1165	}
1166
1167	if (EPIN_EN(uac2_opts)) {
1168		ret = usb_interface_id(cfg, fn);
1169		if (ret < 0) {
1170			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1171			goto err_free_fu;
1172		}
1173		std_as_in_if0_desc.bInterfaceNumber = ret;
1174		std_as_in_if1_desc.bInterfaceNumber = ret;
1175		uac2->as_in_intf = ret;
1176		uac2->as_in_alt = 0;
1177	}
1178
1179	if (FUOUT_EN(uac2_opts) || FUIN_EN(uac2_opts)) {
1180		uac2->int_ep = usb_ep_autoconfig(gadget, &fs_ep_int_desc);
1181		if (!uac2->int_ep) {
1182			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1183			ret = -ENODEV;
1184			goto err_free_fu;
1185		}
1186
1187		std_ac_if_desc.bNumEndpoints = 1;
1188	}
1189
1190	hs_epin_desc.bInterval = uac2_opts->p_hs_bint;
1191	ss_epin_desc.bInterval = uac2_opts->p_hs_bint;
1192	hs_epout_desc.bInterval = uac2_opts->c_hs_bint;
1193	ss_epout_desc.bInterval = uac2_opts->c_hs_bint;
1194
1195	/* Calculate wMaxPacketSize according to audio bandwidth */
1196	ret = set_ep_max_packet_size_bint(dev, uac2_opts, &fs_epin_desc,
1197					USB_SPEED_FULL, true);
1198	if (ret < 0) {
1199		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1200		return ret;
1201	}
1202
1203	ret = set_ep_max_packet_size_bint(dev, uac2_opts, &fs_epout_desc,
1204					USB_SPEED_FULL, false);
1205	if (ret < 0) {
1206		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1207		return ret;
1208	}
1209
1210	ret = set_ep_max_packet_size_bint(dev, uac2_opts, &hs_epin_desc,
1211					USB_SPEED_HIGH, true);
1212	if (ret < 0) {
1213		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1214		return ret;
1215	}
1216
1217	ret = set_ep_max_packet_size_bint(dev, uac2_opts, &hs_epout_desc,
1218					USB_SPEED_HIGH, false);
1219	if (ret < 0) {
1220		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1221		return ret;
1222	}
1223
1224	ret = set_ep_max_packet_size_bint(dev, uac2_opts, &ss_epin_desc,
1225					USB_SPEED_SUPER, true);
1226	if (ret < 0) {
1227		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1228		return ret;
1229	}
1230
1231	ret = set_ep_max_packet_size_bint(dev, uac2_opts, &ss_epout_desc,
1232					USB_SPEED_SUPER, false);
1233	if (ret < 0) {
1234		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1235		return ret;
1236	}
1237
1238	if (EPOUT_EN(uac2_opts)) {
1239		agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
1240		if (!agdev->out_ep) {
1241			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1242			ret = -ENODEV;
1243			goto err_free_fu;
1244		}
1245		if (EPOUT_FBACK_IN_EN(uac2_opts)) {
1246			agdev->in_ep_fback = usb_ep_autoconfig(gadget,
1247						       &fs_epin_fback_desc);
1248			if (!agdev->in_ep_fback) {
1249				dev_err(dev, "%s:%d Error!\n",
1250					__func__, __LINE__);
1251				ret = -ENODEV;
1252				goto err_free_fu;
1253			}
1254		}
1255	}
1256
1257	if (EPIN_EN(uac2_opts)) {
1258		agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
1259		if (!agdev->in_ep) {
1260			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1261			ret = -ENODEV;
1262			goto err_free_fu;
1263		}
1264	}
1265
1266	agdev->in_ep_maxpsize = max_t(u16,
1267				le16_to_cpu(fs_epin_desc.wMaxPacketSize),
1268				le16_to_cpu(hs_epin_desc.wMaxPacketSize));
1269	agdev->out_ep_maxpsize = max_t(u16,
1270				le16_to_cpu(fs_epout_desc.wMaxPacketSize),
1271				le16_to_cpu(hs_epout_desc.wMaxPacketSize));
1272
1273	agdev->in_ep_maxpsize = max_t(u16, agdev->in_ep_maxpsize,
1274				le16_to_cpu(ss_epin_desc.wMaxPacketSize));
1275	agdev->out_ep_maxpsize = max_t(u16, agdev->out_ep_maxpsize,
1276				le16_to_cpu(ss_epout_desc.wMaxPacketSize));
1277
1278	ss_epin_desc_comp.wBytesPerInterval = ss_epin_desc.wMaxPacketSize;
1279	ss_epout_desc_comp.wBytesPerInterval = ss_epout_desc.wMaxPacketSize;
1280
1281	// HS and SS endpoint addresses are copied from autoconfigured FS descriptors
1282	hs_ep_int_desc.bEndpointAddress = fs_ep_int_desc.bEndpointAddress;
1283	hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
1284	hs_epin_fback_desc.bEndpointAddress = fs_epin_fback_desc.bEndpointAddress;
1285	hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
1286	ss_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
1287	ss_epin_fback_desc.bEndpointAddress = fs_epin_fback_desc.bEndpointAddress;
1288	ss_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
1289	ss_ep_int_desc.bEndpointAddress = fs_ep_int_desc.bEndpointAddress;
1290
1291	setup_descriptor(uac2_opts);
1292
1293	ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, ss_audio_desc,
1294				     ss_audio_desc);
1295	if (ret)
1296		goto err_free_fu;
1297
1298	agdev->gadget = gadget;
1299
1300	agdev->params.p_chmask = uac2_opts->p_chmask;
1301	memcpy(agdev->params.p_srates, uac2_opts->p_srates,
1302			sizeof(agdev->params.p_srates));
1303	agdev->params.p_ssize = uac2_opts->p_ssize;
1304	if (FUIN_EN(uac2_opts)) {
1305		agdev->params.p_fu.id = USB_IN_FU_ID;
1306		agdev->params.p_fu.mute_present = uac2_opts->p_mute_present;
1307		agdev->params.p_fu.volume_present = uac2_opts->p_volume_present;
1308		agdev->params.p_fu.volume_min = uac2_opts->p_volume_min;
1309		agdev->params.p_fu.volume_max = uac2_opts->p_volume_max;
1310		agdev->params.p_fu.volume_res = uac2_opts->p_volume_res;
1311	}
1312	agdev->params.c_chmask = uac2_opts->c_chmask;
1313	memcpy(agdev->params.c_srates, uac2_opts->c_srates,
1314			sizeof(agdev->params.c_srates));
1315	agdev->params.c_ssize = uac2_opts->c_ssize;
1316	if (FUOUT_EN(uac2_opts)) {
1317		agdev->params.c_fu.id = USB_OUT_FU_ID;
1318		agdev->params.c_fu.mute_present = uac2_opts->c_mute_present;
1319		agdev->params.c_fu.volume_present = uac2_opts->c_volume_present;
1320		agdev->params.c_fu.volume_min = uac2_opts->c_volume_min;
1321		agdev->params.c_fu.volume_max = uac2_opts->c_volume_max;
1322		agdev->params.c_fu.volume_res = uac2_opts->c_volume_res;
1323	}
1324	agdev->params.req_number = uac2_opts->req_number;
1325	agdev->params.fb_max = uac2_opts->fb_max;
1326
1327	if (FUOUT_EN(uac2_opts) || FUIN_EN(uac2_opts))
1328    agdev->notify = afunc_notify;
1329
1330	ret = g_audio_setup(agdev, "UAC2 PCM", "UAC2_Gadget");
1331	if (ret)
1332		goto err_free_descs;
1333
1334	return 0;
1335
1336err_free_descs:
1337	usb_free_all_descriptors(fn);
1338	agdev->gadget = NULL;
1339err_free_fu:
1340	kfree(out_feature_unit_desc);
1341	out_feature_unit_desc = NULL;
1342	kfree(in_feature_unit_desc);
1343	in_feature_unit_desc = NULL;
1344	return ret;
1345}
1346
1347static void
1348afunc_notify_complete(struct usb_ep *_ep, struct usb_request *req)
1349{
1350	struct g_audio *agdev = req->context;
1351	struct f_uac2 *uac2 = func_to_uac2(&agdev->func);
1352
1353	atomic_dec(&uac2->int_count);
1354	kfree(req->buf);
1355	usb_ep_free_request(_ep, req);
1356}
1357
1358static int
1359afunc_notify(struct g_audio *agdev, int unit_id, int cs)
1360{
1361	struct f_uac2 *uac2 = func_to_uac2(&agdev->func);
1362	struct usb_request *req;
1363	struct uac2_interrupt_data_msg *msg;
1364	u16 w_index, w_value;
1365	int ret;
1366
1367	if (!uac2->int_ep->enabled)
1368		return 0;
1369
1370	if (atomic_inc_return(&uac2->int_count) > UAC2_DEF_INT_REQ_NUM) {
1371		atomic_dec(&uac2->int_count);
1372		return 0;
1373	}
1374
1375	req = usb_ep_alloc_request(uac2->int_ep, GFP_ATOMIC);
1376	if (req == NULL) {
1377		ret = -ENOMEM;
1378		goto err_dec_int_count;
1379	}
1380
1381	msg = kzalloc(sizeof(*msg), GFP_ATOMIC);
1382	if (msg == NULL) {
1383		ret = -ENOMEM;
1384		goto err_free_request;
1385	}
1386
1387	w_index = unit_id << 8 | uac2->ac_intf;
1388	w_value = cs << 8;
1389
1390	msg->bInfo = 0; /* Non-vendor, interface interrupt */
1391	msg->bAttribute = UAC2_CS_CUR;
1392	msg->wIndex = cpu_to_le16(w_index);
1393	msg->wValue = cpu_to_le16(w_value);
1394
1395	req->length = sizeof(*msg);
1396	req->buf = msg;
1397	req->context = agdev;
1398	req->complete = afunc_notify_complete;
1399
1400	ret = usb_ep_queue(uac2->int_ep, req, GFP_ATOMIC);
1401
1402	if (ret)
1403		goto err_free_msg;
1404
1405	return 0;
1406
1407err_free_msg:
1408	kfree(msg);
1409err_free_request:
1410	usb_ep_free_request(uac2->int_ep, req);
1411err_dec_int_count:
1412	atomic_dec(&uac2->int_count);
1413
1414	return ret;
1415}
1416
1417static int
1418afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
1419{
1420	struct usb_composite_dev *cdev = fn->config->cdev;
1421	struct f_uac2 *uac2 = func_to_uac2(fn);
1422	struct g_audio *agdev = func_to_g_audio(fn);
1423	struct usb_gadget *gadget = cdev->gadget;
1424	struct device *dev = &gadget->dev;
1425	int ret = 0;
1426
1427	/* No i/f has more than 2 alt settings */
1428	if (alt > 1) {
1429		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1430		return -EINVAL;
1431	}
1432
1433	if (intf == uac2->ac_intf) {
1434		/* Control I/f has only 1 AltSetting - 0 */
1435		if (alt) {
1436			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1437			return -EINVAL;
1438		}
1439
1440		/* restart interrupt endpoint */
1441		if (uac2->int_ep) {
1442			usb_ep_disable(uac2->int_ep);
1443			config_ep_by_speed(gadget, &agdev->func, uac2->int_ep);
1444			usb_ep_enable(uac2->int_ep);
1445		}
1446
1447		return 0;
1448	}
1449
1450	if (intf == uac2->as_out_intf) {
1451		uac2->as_out_alt = alt;
1452
1453		if (alt)
1454			ret = u_audio_start_capture(&uac2->g_audio);
1455		else
1456			u_audio_stop_capture(&uac2->g_audio);
1457	} else if (intf == uac2->as_in_intf) {
1458		uac2->as_in_alt = alt;
1459
1460		if (alt)
1461			ret = u_audio_start_playback(&uac2->g_audio);
1462		else
1463			u_audio_stop_playback(&uac2->g_audio);
1464	} else {
1465		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1466		return -EINVAL;
1467	}
1468
1469	return ret;
1470}
1471
1472static int
1473afunc_get_alt(struct usb_function *fn, unsigned intf)
1474{
1475	struct f_uac2 *uac2 = func_to_uac2(fn);
1476	struct g_audio *agdev = func_to_g_audio(fn);
1477
1478	if (intf == uac2->ac_intf)
1479		return uac2->ac_alt;
1480	else if (intf == uac2->as_out_intf)
1481		return uac2->as_out_alt;
1482	else if (intf == uac2->as_in_intf)
1483		return uac2->as_in_alt;
1484	else
1485		dev_err(&agdev->gadget->dev,
1486			"%s:%d Invalid Interface %d!\n",
1487			__func__, __LINE__, intf);
1488
1489	return -EINVAL;
1490}
1491
1492static void
1493afunc_disable(struct usb_function *fn)
1494{
1495	struct f_uac2 *uac2 = func_to_uac2(fn);
1496
1497	uac2->as_in_alt = 0;
1498	uac2->as_out_alt = 0;
1499	u_audio_stop_capture(&uac2->g_audio);
1500	u_audio_stop_playback(&uac2->g_audio);
1501	if (uac2->int_ep)
1502		usb_ep_disable(uac2->int_ep);
1503}
1504
1505static void
1506afunc_suspend(struct usb_function *fn)
1507{
1508	struct f_uac2 *uac2 = func_to_uac2(fn);
1509
1510	u_audio_suspend(&uac2->g_audio);
1511}
1512
1513static int
1514in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1515{
1516	struct usb_request *req = fn->config->cdev->req;
1517	struct g_audio *agdev = func_to_g_audio(fn);
1518	struct f_uac2_opts *opts = g_audio_to_uac2_opts(agdev);
1519	u16 w_length = le16_to_cpu(cr->wLength);
1520	u16 w_index = le16_to_cpu(cr->wIndex);
1521	u16 w_value = le16_to_cpu(cr->wValue);
1522	u8 entity_id = (w_index >> 8) & 0xff;
1523	u8 control_selector = w_value >> 8;
1524	int value = -EOPNOTSUPP;
1525	u32 p_srate, c_srate;
1526
1527	u_audio_get_playback_srate(agdev, &p_srate);
1528	u_audio_get_capture_srate(agdev, &c_srate);
1529
1530	if ((entity_id == USB_IN_CLK_ID) || (entity_id == USB_OUT_CLK_ID)) {
1531		if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1532			struct cntrl_cur_lay3 c;
1533
1534			memset(&c, 0, sizeof(struct cntrl_cur_lay3));
1535
1536			if (entity_id == USB_IN_CLK_ID)
1537				c.dCUR = cpu_to_le32(p_srate);
1538			else if (entity_id == USB_OUT_CLK_ID)
1539				c.dCUR = cpu_to_le32(c_srate);
1540
1541			value = min_t(unsigned int, w_length, sizeof(c));
1542			memcpy(req->buf, &c, value);
1543		} else if (control_selector == UAC2_CS_CONTROL_CLOCK_VALID) {
1544			*(u8 *)req->buf = 1;
1545			value = min_t(unsigned int, w_length, 1);
1546		} else {
1547			dev_err(&agdev->gadget->dev,
1548				"%s:%d control_selector=%d TODO!\n",
1549				__func__, __LINE__, control_selector);
1550		}
1551	} else if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
1552			(FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
1553		unsigned int is_playback = 0;
1554
1555		if (FUIN_EN(opts) && (entity_id == USB_IN_FU_ID))
1556			is_playback = 1;
1557
1558		if (control_selector == UAC_FU_MUTE) {
1559			unsigned int mute;
1560
1561			u_audio_get_mute(agdev, is_playback, &mute);
1562
1563			*(u8 *)req->buf = mute;
1564			value = min_t(unsigned int, w_length, 1);
1565		} else if (control_selector == UAC_FU_VOLUME) {
1566			struct cntrl_cur_lay2 c;
1567			s16 volume;
1568
1569			memset(&c, 0, sizeof(struct cntrl_cur_lay2));
1570
1571			u_audio_get_volume(agdev, is_playback, &volume);
1572			c.wCUR = cpu_to_le16(volume);
1573
1574			value = min_t(unsigned int, w_length, sizeof(c));
1575			memcpy(req->buf, &c, value);
1576		} else {
1577			dev_err(&agdev->gadget->dev,
1578				"%s:%d control_selector=%d TODO!\n",
1579				__func__, __LINE__, control_selector);
1580		}
1581	} else {
1582		dev_err(&agdev->gadget->dev,
1583			"%s:%d entity_id=%d control_selector=%d TODO!\n",
1584			__func__, __LINE__, entity_id, control_selector);
1585	}
1586
1587	return value;
1588}
1589
1590static int
1591in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1592{
1593	struct usb_request *req = fn->config->cdev->req;
1594	struct g_audio *agdev = func_to_g_audio(fn);
1595	struct f_uac2_opts *opts = g_audio_to_uac2_opts(agdev);
1596	u16 w_length = le16_to_cpu(cr->wLength);
1597	u16 w_index = le16_to_cpu(cr->wIndex);
1598	u16 w_value = le16_to_cpu(cr->wValue);
1599	u8 entity_id = (w_index >> 8) & 0xff;
1600	u8 control_selector = w_value >> 8;
1601	int value = -EOPNOTSUPP;
1602
1603	if ((entity_id == USB_IN_CLK_ID) || (entity_id == USB_OUT_CLK_ID)) {
1604		if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1605			struct cntrl_ranges_lay3_srates rs;
1606			int i;
1607			int wNumSubRanges = 0;
1608			int srate;
1609			int *srates;
1610
1611			if (entity_id == USB_IN_CLK_ID)
1612				srates = opts->p_srates;
1613			else if (entity_id == USB_OUT_CLK_ID)
1614				srates = opts->c_srates;
1615			else
1616				return -EOPNOTSUPP;
1617			for (i = 0; i < UAC_MAX_RATES; i++) {
1618				srate = srates[i];
1619				if (srate == 0)
1620					break;
1621
1622				rs.r[wNumSubRanges].dMIN = cpu_to_le32(srate);
1623				rs.r[wNumSubRanges].dMAX = cpu_to_le32(srate);
1624				rs.r[wNumSubRanges].dRES = 0;
1625				wNumSubRanges++;
1626				dev_dbg(&agdev->gadget->dev,
1627					"%s(): clk %d: rate ID %d: %d\n",
1628					__func__, entity_id, wNumSubRanges, srate);
1629			}
1630			rs.wNumSubRanges = cpu_to_le16(wNumSubRanges);
1631			value = min_t(unsigned int, w_length, ranges_lay3_size(rs));
1632			dev_dbg(&agdev->gadget->dev, "%s(): sending %d rates, size %d\n",
1633				__func__, rs.wNumSubRanges, value);
1634			memcpy(req->buf, &rs, value);
1635		} else {
1636			dev_err(&agdev->gadget->dev,
1637				"%s:%d control_selector=%d TODO!\n",
1638				__func__, __LINE__, control_selector);
1639		}
1640	} else if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
1641			(FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
1642		unsigned int is_playback = 0;
1643
1644		if (FUIN_EN(opts) && (entity_id == USB_IN_FU_ID))
1645			is_playback = 1;
1646
1647		if (control_selector == UAC_FU_VOLUME) {
1648			struct cntrl_range_lay2 r;
1649			s16 max_db, min_db, res_db;
1650
1651			if (is_playback) {
1652				max_db = opts->p_volume_max;
1653				min_db = opts->p_volume_min;
1654				res_db = opts->p_volume_res;
1655			} else {
1656				max_db = opts->c_volume_max;
1657				min_db = opts->c_volume_min;
1658				res_db = opts->c_volume_res;
1659			}
1660
1661			r.wMAX = cpu_to_le16(max_db);
1662			r.wMIN = cpu_to_le16(min_db);
1663			r.wRES = cpu_to_le16(res_db);
1664			r.wNumSubRanges = cpu_to_le16(1);
1665
1666			value = min_t(unsigned int, w_length, sizeof(r));
1667			memcpy(req->buf, &r, value);
1668		} else {
1669			dev_err(&agdev->gadget->dev,
1670				"%s:%d control_selector=%d TODO!\n",
1671				__func__, __LINE__, control_selector);
1672		}
1673	} else {
1674		dev_err(&agdev->gadget->dev,
1675			"%s:%d entity_id=%d control_selector=%d TODO!\n",
1676			__func__, __LINE__, entity_id, control_selector);
1677	}
1678
1679	return value;
1680}
1681
1682static int
1683ac_rq_in(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1684{
1685	if (cr->bRequest == UAC2_CS_CUR)
1686		return in_rq_cur(fn, cr);
1687	else if (cr->bRequest == UAC2_CS_RANGE)
1688		return in_rq_range(fn, cr);
1689	else
1690		return -EOPNOTSUPP;
1691}
1692
1693static void uac2_cs_control_sam_freq(struct usb_ep *ep, struct usb_request *req)
1694{
1695	struct usb_function *fn = ep->driver_data;
1696	struct g_audio *agdev = func_to_g_audio(fn);
1697	struct f_uac2 *uac2 = func_to_uac2(fn);
1698	u32 val;
1699
1700	if (req->actual != 4)
1701		return;
1702
1703	val = le32_to_cpu(*((__le32 *)req->buf));
1704	dev_dbg(&agdev->gadget->dev, "%s val: %d.\n", __func__, val);
1705	if (uac2->clock_id == USB_IN_CLK_ID) {
1706		u_audio_set_playback_srate(agdev, val);
1707	} else if (uac2->clock_id == USB_OUT_CLK_ID) {
1708		u_audio_set_capture_srate(agdev, val);
1709	}
1710}
1711
1712static void
1713out_rq_cur_complete(struct usb_ep *ep, struct usb_request *req)
1714{
1715	struct g_audio *agdev = req->context;
1716	struct usb_composite_dev *cdev = agdev->func.config->cdev;
1717	struct f_uac2_opts *opts = g_audio_to_uac2_opts(agdev);
1718	struct f_uac2 *uac2 = func_to_uac2(&agdev->func);
1719	struct usb_ctrlrequest *cr = &uac2->setup_cr;
1720	u16 w_index = le16_to_cpu(cr->wIndex);
1721	u16 w_value = le16_to_cpu(cr->wValue);
1722	u8 entity_id = (w_index >> 8) & 0xff;
1723	u8 control_selector = w_value >> 8;
1724
1725	if (req->status != 0) {
1726		dev_dbg(&cdev->gadget->dev, "completion err %d\n", req->status);
1727		return;
1728	}
1729
1730	if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
1731		(FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
1732		unsigned int is_playback = 0;
1733
1734		if (FUIN_EN(opts) && (entity_id == USB_IN_FU_ID))
1735			is_playback = 1;
1736
1737		if (control_selector == UAC_FU_MUTE) {
1738			u8 mute = *(u8 *)req->buf;
1739
1740			u_audio_set_mute(agdev, is_playback, mute);
1741
1742			return;
1743		} else if (control_selector == UAC_FU_VOLUME) {
1744			struct cntrl_cur_lay2 *c = req->buf;
1745			s16 volume;
1746
1747			volume = le16_to_cpu(c->wCUR);
1748			u_audio_set_volume(agdev, is_playback, volume);
1749
1750			return;
1751		} else {
1752			dev_err(&agdev->gadget->dev,
1753				"%s:%d control_selector=%d TODO!\n",
1754				__func__, __LINE__, control_selector);
1755			usb_ep_set_halt(ep);
1756		}
1757	}
1758}
1759
1760static int
1761out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1762{
1763	struct usb_composite_dev *cdev = fn->config->cdev;
1764	struct usb_request *req = fn->config->cdev->req;
1765	struct g_audio *agdev = func_to_g_audio(fn);
1766	struct f_uac2_opts *opts = g_audio_to_uac2_opts(agdev);
1767	struct f_uac2 *uac2 = func_to_uac2(fn);
1768	u16 w_length = le16_to_cpu(cr->wLength);
1769	u16 w_index = le16_to_cpu(cr->wIndex);
1770	u16 w_value = le16_to_cpu(cr->wValue);
1771	u8 entity_id = (w_index >> 8) & 0xff;
1772	u8 control_selector = w_value >> 8;
1773	u8 clock_id = w_index >> 8;
1774
1775	if ((entity_id == USB_IN_CLK_ID) || (entity_id == USB_OUT_CLK_ID)) {
1776		if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1777			dev_dbg(&agdev->gadget->dev,
1778				"control_selector UAC2_CS_CONTROL_SAM_FREQ, clock: %d\n", clock_id);
1779			cdev->gadget->ep0->driver_data = fn;
1780			uac2->clock_id = clock_id;
1781			req->complete = uac2_cs_control_sam_freq;
1782			return w_length;
1783		}
1784	} else if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
1785			(FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
1786		memcpy(&uac2->setup_cr, cr, sizeof(*cr));
1787		req->context = agdev;
1788		req->complete = out_rq_cur_complete;
1789
1790		return w_length;
1791	} else {
1792		dev_err(&agdev->gadget->dev,
1793			"%s:%d entity_id=%d control_selector=%d TODO!\n",
1794			__func__, __LINE__, entity_id, control_selector);
1795	}
1796	return -EOPNOTSUPP;
1797}
1798
1799static int
1800setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1801{
1802	struct f_uac2 *uac2 = func_to_uac2(fn);
1803	struct g_audio *agdev = func_to_g_audio(fn);
1804	u16 w_index = le16_to_cpu(cr->wIndex);
1805	u8 intf = w_index & 0xff;
1806
1807	if (intf != uac2->ac_intf) {
1808		dev_err(&agdev->gadget->dev,
1809			"%s:%d Error!\n", __func__, __LINE__);
1810		return -EOPNOTSUPP;
1811	}
1812
1813	if (cr->bRequestType & USB_DIR_IN)
1814		return ac_rq_in(fn, cr);
1815	else if (cr->bRequest == UAC2_CS_CUR)
1816		return out_rq_cur(fn, cr);
1817
1818	return -EOPNOTSUPP;
1819}
1820
1821static int
1822afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1823{
1824	struct usb_composite_dev *cdev = fn->config->cdev;
1825	struct g_audio *agdev = func_to_g_audio(fn);
1826	struct usb_request *req = cdev->req;
1827	u16 w_length = le16_to_cpu(cr->wLength);
1828	int value = -EOPNOTSUPP;
1829
1830	/* Only Class specific requests are supposed to reach here */
1831	if ((cr->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
1832		return -EOPNOTSUPP;
1833
1834	if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
1835		value = setup_rq_inf(fn, cr);
1836	else
1837		dev_err(&agdev->gadget->dev, "%s:%d Error!\n",
1838				__func__, __LINE__);
1839
1840	if (value >= 0) {
1841		req->length = value;
1842		req->zero = value < w_length;
1843		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
1844		if (value < 0) {
1845			dev_err(&agdev->gadget->dev,
1846				"%s:%d Error!\n", __func__, __LINE__);
1847			req->status = 0;
1848		}
1849	}
1850
1851	return value;
1852}
1853
1854static inline struct f_uac2_opts *to_f_uac2_opts(struct config_item *item)
1855{
1856	return container_of(to_config_group(item), struct f_uac2_opts,
1857			    func_inst.group);
1858}
1859
1860static void f_uac2_attr_release(struct config_item *item)
1861{
1862	struct f_uac2_opts *opts = to_f_uac2_opts(item);
1863
1864	usb_put_function_instance(&opts->func_inst);
1865}
1866
1867static struct configfs_item_operations f_uac2_item_ops = {
1868	.release	= f_uac2_attr_release,
1869};
1870
1871#define uac2_kstrtou8 kstrtou8
1872#define uac2_kstrtou32 kstrtou32
1873#define uac2_kstrtos16 kstrtos16
1874#define uac2_kstrtobool(s, base, res) kstrtobool((s), (res))
1875
1876static const char *u8_fmt = "%u\n";
1877static const char *u32_fmt = "%u\n";
1878static const char *s16_fmt = "%hd\n";
1879static const char *bool_fmt = "%u\n";
1880
1881#define UAC2_ATTRIBUTE(type, name)					\
1882static ssize_t f_uac2_opts_##name##_show(struct config_item *item,	\
1883					 char *page)			\
1884{									\
1885	struct f_uac2_opts *opts = to_f_uac2_opts(item);		\
1886	int result;							\
1887									\
1888	mutex_lock(&opts->lock);					\
1889	result = sprintf(page, type##_fmt, opts->name);			\
1890	mutex_unlock(&opts->lock);					\
1891									\
1892	return result;							\
1893}									\
1894									\
1895static ssize_t f_uac2_opts_##name##_store(struct config_item *item,	\
1896					  const char *page, size_t len)	\
1897{									\
1898	struct f_uac2_opts *opts = to_f_uac2_opts(item);		\
1899	int ret;							\
1900	type num;							\
1901									\
1902	mutex_lock(&opts->lock);					\
1903	if (opts->refcnt) {						\
1904		ret = -EBUSY;						\
1905		goto end;						\
1906	}								\
1907									\
1908	ret = uac2_kstrto##type(page, 0, &num);				\
1909	if (ret)							\
1910		goto end;						\
1911									\
1912	opts->name = num;						\
1913	ret = len;							\
1914									\
1915end:									\
1916	mutex_unlock(&opts->lock);					\
1917	return ret;							\
1918}									\
1919									\
1920CONFIGFS_ATTR(f_uac2_opts_, name)
1921
1922#define UAC2_ATTRIBUTE_SYNC(name)					\
1923static ssize_t f_uac2_opts_##name##_show(struct config_item *item,	\
1924					 char *page)			\
1925{									\
1926	struct f_uac2_opts *opts = to_f_uac2_opts(item);		\
1927	int result;							\
1928	char *str;							\
1929									\
1930	mutex_lock(&opts->lock);					\
1931	switch (opts->name) {						\
1932	case USB_ENDPOINT_SYNC_ASYNC:					\
1933		str = "async";						\
1934		break;							\
1935	case USB_ENDPOINT_SYNC_ADAPTIVE:				\
1936		str = "adaptive";					\
1937		break;							\
1938	default:							\
1939		str = "unknown";					\
1940		break;							\
1941	}								\
1942	result = sprintf(page, "%s\n", str);				\
1943	mutex_unlock(&opts->lock);					\
1944									\
1945	return result;							\
1946}									\
1947									\
1948static ssize_t f_uac2_opts_##name##_store(struct config_item *item,	\
1949					  const char *page, size_t len)	\
1950{									\
1951	struct f_uac2_opts *opts = to_f_uac2_opts(item);		\
1952	int ret = 0;							\
1953									\
1954	mutex_lock(&opts->lock);					\
1955	if (opts->refcnt) {						\
1956		ret = -EBUSY;						\
1957		goto end;						\
1958	}								\
1959									\
1960	if (!strncmp(page, "async", 5))					\
1961		opts->name = USB_ENDPOINT_SYNC_ASYNC;			\
1962	else if (!strncmp(page, "adaptive", 8))				\
1963		opts->name = USB_ENDPOINT_SYNC_ADAPTIVE;		\
1964	else {								\
1965		ret = -EINVAL;						\
1966		goto end;						\
1967	}								\
1968									\
1969	ret = len;							\
1970									\
1971end:									\
1972	mutex_unlock(&opts->lock);					\
1973	return ret;							\
1974}									\
1975									\
1976CONFIGFS_ATTR(f_uac2_opts_, name)
1977
1978#define UAC2_RATE_ATTRIBUTE(name)					\
1979static ssize_t f_uac2_opts_##name##_show(struct config_item *item,	\
1980					 char *page)			\
1981{									\
1982	struct f_uac2_opts *opts = to_f_uac2_opts(item);		\
1983	int result = 0;							\
1984	int i;								\
1985									\
1986	mutex_lock(&opts->lock);					\
1987	page[0] = '\0';							\
1988	for (i = 0; i < UAC_MAX_RATES; i++) {				\
1989		if (opts->name##s[i] == 0)				\
1990			break;						\
1991		result += sprintf(page + strlen(page), "%u,",		\
1992				opts->name##s[i]);			\
1993	}								\
1994	if (strlen(page) > 0)						\
1995		page[strlen(page) - 1] = '\n';				\
1996	mutex_unlock(&opts->lock);					\
1997									\
1998	return result;							\
1999}									\
2000									\
2001static ssize_t f_uac2_opts_##name##_store(struct config_item *item,	\
2002					  const char *page, size_t len)	\
2003{									\
2004	struct f_uac2_opts *opts = to_f_uac2_opts(item);		\
2005	char *split_page = NULL;					\
2006	int ret = -EINVAL;						\
2007	char *token;							\
2008	u32 num;							\
2009	int i;								\
2010									\
2011	mutex_lock(&opts->lock);					\
2012	if (opts->refcnt) {						\
2013		ret = -EBUSY;						\
2014		goto end;						\
2015	}								\
2016									\
2017	i = 0;								\
2018	memset(opts->name##s, 0x00, sizeof(opts->name##s));		\
2019	split_page = kstrdup(page, GFP_KERNEL);				\
2020	while ((token = strsep(&split_page, ",")) != NULL) {		\
2021		ret = kstrtou32(token, 0, &num);			\
2022		if (ret)						\
2023			goto end;					\
2024									\
2025		opts->name##s[i++] = num;				\
2026		ret = len;						\
2027	};								\
2028									\
2029end:									\
2030	kfree(split_page);						\
2031	mutex_unlock(&opts->lock);					\
2032	return ret;							\
2033}									\
2034									\
2035CONFIGFS_ATTR(f_uac2_opts_, name)
2036
2037#define UAC2_ATTRIBUTE_STRING(name)					\
2038static ssize_t f_uac2_opts_##name##_show(struct config_item *item,	\
2039					 char *page)			\
2040{									\
2041	struct f_uac2_opts *opts = to_f_uac2_opts(item);		\
2042	int result;							\
2043									\
2044	mutex_lock(&opts->lock);					\
2045	result = snprintf(page, sizeof(opts->name), "%s", opts->name);	\
2046	mutex_unlock(&opts->lock);					\
2047									\
2048	return result;							\
2049}									\
2050									\
2051static ssize_t f_uac2_opts_##name##_store(struct config_item *item,	\
2052					  const char *page, size_t len)	\
2053{									\
2054	struct f_uac2_opts *opts = to_f_uac2_opts(item);		\
2055	int ret = 0;							\
2056									\
2057	mutex_lock(&opts->lock);					\
2058	if (opts->refcnt) {						\
2059		ret = -EBUSY;						\
2060		goto end;						\
2061	}								\
2062									\
2063	ret = snprintf(opts->name, min(sizeof(opts->name), len),	\
2064			"%s", page);					\
2065									\
2066end:									\
2067	mutex_unlock(&opts->lock);					\
2068	return ret;							\
2069}									\
2070									\
2071CONFIGFS_ATTR(f_uac2_opts_, name)
2072
2073UAC2_ATTRIBUTE(u32, p_chmask);
2074UAC2_RATE_ATTRIBUTE(p_srate);
2075UAC2_ATTRIBUTE(u32, p_ssize);
2076UAC2_ATTRIBUTE(u8, p_hs_bint);
2077UAC2_ATTRIBUTE(u32, c_chmask);
2078UAC2_RATE_ATTRIBUTE(c_srate);
2079UAC2_ATTRIBUTE_SYNC(c_sync);
2080UAC2_ATTRIBUTE(u32, c_ssize);
2081UAC2_ATTRIBUTE(u8, c_hs_bint);
2082UAC2_ATTRIBUTE(u32, req_number);
2083
2084UAC2_ATTRIBUTE(bool, p_mute_present);
2085UAC2_ATTRIBUTE(bool, p_volume_present);
2086UAC2_ATTRIBUTE(s16, p_volume_min);
2087UAC2_ATTRIBUTE(s16, p_volume_max);
2088UAC2_ATTRIBUTE(s16, p_volume_res);
2089
2090UAC2_ATTRIBUTE(bool, c_mute_present);
2091UAC2_ATTRIBUTE(bool, c_volume_present);
2092UAC2_ATTRIBUTE(s16, c_volume_min);
2093UAC2_ATTRIBUTE(s16, c_volume_max);
2094UAC2_ATTRIBUTE(s16, c_volume_res);
2095UAC2_ATTRIBUTE(u32, fb_max);
2096UAC2_ATTRIBUTE_STRING(function_name);
2097
2098static struct configfs_attribute *f_uac2_attrs[] = {
2099	&f_uac2_opts_attr_p_chmask,
2100	&f_uac2_opts_attr_p_srate,
2101	&f_uac2_opts_attr_p_ssize,
2102	&f_uac2_opts_attr_p_hs_bint,
2103	&f_uac2_opts_attr_c_chmask,
2104	&f_uac2_opts_attr_c_srate,
2105	&f_uac2_opts_attr_c_ssize,
2106	&f_uac2_opts_attr_c_hs_bint,
2107	&f_uac2_opts_attr_c_sync,
2108	&f_uac2_opts_attr_req_number,
2109	&f_uac2_opts_attr_fb_max,
2110
2111	&f_uac2_opts_attr_p_mute_present,
2112	&f_uac2_opts_attr_p_volume_present,
2113	&f_uac2_opts_attr_p_volume_min,
2114	&f_uac2_opts_attr_p_volume_max,
2115	&f_uac2_opts_attr_p_volume_res,
2116
2117	&f_uac2_opts_attr_c_mute_present,
2118	&f_uac2_opts_attr_c_volume_present,
2119	&f_uac2_opts_attr_c_volume_min,
2120	&f_uac2_opts_attr_c_volume_max,
2121	&f_uac2_opts_attr_c_volume_res,
2122
2123	&f_uac2_opts_attr_function_name,
2124
2125	NULL,
2126};
2127
2128static const struct config_item_type f_uac2_func_type = {
2129	.ct_item_ops	= &f_uac2_item_ops,
2130	.ct_attrs	= f_uac2_attrs,
2131	.ct_owner	= THIS_MODULE,
2132};
2133
2134static void afunc_free_inst(struct usb_function_instance *f)
2135{
2136	struct f_uac2_opts *opts;
2137
2138	opts = container_of(f, struct f_uac2_opts, func_inst);
2139	kfree(opts);
2140}
2141
2142static struct usb_function_instance *afunc_alloc_inst(void)
2143{
2144	struct f_uac2_opts *opts;
2145
2146	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
2147	if (!opts)
2148		return ERR_PTR(-ENOMEM);
2149
2150	mutex_init(&opts->lock);
2151	opts->func_inst.free_func_inst = afunc_free_inst;
2152
2153	config_group_init_type_name(&opts->func_inst.group, "",
2154				    &f_uac2_func_type);
2155
2156	opts->p_chmask = UAC2_DEF_PCHMASK;
2157	opts->p_srates[0] = UAC2_DEF_PSRATE;
2158	opts->p_ssize = UAC2_DEF_PSSIZE;
2159	opts->p_hs_bint = UAC2_DEF_PHSBINT;
2160	opts->c_chmask = UAC2_DEF_CCHMASK;
2161	opts->c_srates[0] = UAC2_DEF_CSRATE;
2162	opts->c_ssize = UAC2_DEF_CSSIZE;
2163	opts->c_hs_bint = UAC2_DEF_CHSBINT;
2164	opts->c_sync = UAC2_DEF_CSYNC;
2165
2166	opts->p_mute_present = UAC2_DEF_MUTE_PRESENT;
2167	opts->p_volume_present = UAC2_DEF_VOLUME_PRESENT;
2168	opts->p_volume_min = UAC2_DEF_MIN_DB;
2169	opts->p_volume_max = UAC2_DEF_MAX_DB;
2170	opts->p_volume_res = UAC2_DEF_RES_DB;
2171
2172	opts->c_mute_present = UAC2_DEF_MUTE_PRESENT;
2173	opts->c_volume_present = UAC2_DEF_VOLUME_PRESENT;
2174	opts->c_volume_min = UAC2_DEF_MIN_DB;
2175	opts->c_volume_max = UAC2_DEF_MAX_DB;
2176	opts->c_volume_res = UAC2_DEF_RES_DB;
2177
2178	opts->req_number = UAC2_DEF_REQ_NUM;
2179	opts->fb_max = FBACK_FAST_MAX;
2180
2181	snprintf(opts->function_name, sizeof(opts->function_name), "Source/Sink");
2182
2183	return &opts->func_inst;
2184}
2185
2186static void afunc_free(struct usb_function *f)
2187{
2188	struct g_audio *agdev;
2189	struct f_uac2_opts *opts;
2190
2191	agdev = func_to_g_audio(f);
2192	opts = container_of(f->fi, struct f_uac2_opts, func_inst);
2193	kfree(agdev);
2194	mutex_lock(&opts->lock);
2195	--opts->refcnt;
2196	mutex_unlock(&opts->lock);
2197}
2198
2199static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
2200{
2201	struct g_audio *agdev = func_to_g_audio(f);
2202
2203	g_audio_cleanup(agdev);
2204	usb_free_all_descriptors(f);
2205
2206	agdev->gadget = NULL;
2207
2208	kfree(out_feature_unit_desc);
2209	out_feature_unit_desc = NULL;
2210	kfree(in_feature_unit_desc);
2211	in_feature_unit_desc = NULL;
2212}
2213
2214static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
2215{
2216	struct f_uac2	*uac2;
2217	struct f_uac2_opts *opts;
2218
2219	uac2 = kzalloc(sizeof(*uac2), GFP_KERNEL);
2220	if (uac2 == NULL)
2221		return ERR_PTR(-ENOMEM);
2222
2223	opts = container_of(fi, struct f_uac2_opts, func_inst);
2224	mutex_lock(&opts->lock);
2225	++opts->refcnt;
2226	mutex_unlock(&opts->lock);
2227
2228	uac2->g_audio.func.name = "uac2_func";
2229	uac2->g_audio.func.bind = afunc_bind;
2230	uac2->g_audio.func.unbind = afunc_unbind;
2231	uac2->g_audio.func.set_alt = afunc_set_alt;
2232	uac2->g_audio.func.get_alt = afunc_get_alt;
2233	uac2->g_audio.func.disable = afunc_disable;
2234	uac2->g_audio.func.suspend = afunc_suspend;
2235	uac2->g_audio.func.setup = afunc_setup;
2236	uac2->g_audio.func.free_func = afunc_free;
2237
2238	return &uac2->g_audio.func;
2239}
2240
2241DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
2242MODULE_LICENSE("GPL");
2243MODULE_AUTHOR("Yadwinder Singh");
2244MODULE_AUTHOR("Jaswinder Singh");
2245MODULE_AUTHOR("Ruslan Bilovol");
2246