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/platform_device.h>
17 #include <linux/module.h>
18 
19 #include <sound/core.h>
20 #include <sound/pcm.h>
21 #include <sound/pcm_params.h>
22 
23 #include "u_uac2.h"
24 
25 /* Keep everyone on toes */
26 #define USB_XFERS	2
27 
28 /*
29  * The driver implements a simple UAC_2 topology.
30  * USB-OUT -> IT_1 -> OT_3 -> ALSA_Capture
31  * ALSA_Playback -> IT_2 -> OT_4 -> USB-IN
32  * Capture and Playback sampling rates are independently
33  *  controlled by two clock sources :
34  *    CLK_5 := c_srate, and CLK_6 := p_srate
35  */
36 #define USB_OUT_IT_ID	1
37 #define IO_IN_IT_ID	2
38 #define IO_OUT_OT_ID	3
39 #define USB_IN_OT_ID	4
40 #define USB_OUT_CLK_ID	5
41 #define USB_IN_CLK_ID	6
42 
43 #define CONTROL_ABSENT	0
44 #define CONTROL_RDONLY	1
45 #define CONTROL_RDWR	3
46 
47 #define CLK_FREQ_CTRL	0
48 #define CLK_VLD_CTRL	2
49 
50 #define COPY_CTRL	0
51 #define CONN_CTRL	2
52 #define OVRLD_CTRL	4
53 #define CLSTR_CTRL	6
54 #define UNFLW_CTRL	8
55 #define OVFLW_CTRL	10
56 
57 const char *uac2_name = "snd_uac2";
58 
59 struct uac2_req {
60 	struct uac2_rtd_params *pp; /* parent param */
61 	struct usb_request *req;
62 };
63 
64 struct uac2_rtd_params {
65 	struct snd_uac2_chip *uac2; /* parent chip */
66 	bool ep_enabled; /* if the ep is enabled */
67 	/* Size of the ring buffer */
68 	size_t dma_bytes;
69 	unsigned char *dma_area;
70 
71 	struct snd_pcm_substream *ss;
72 
73 	/* Ring buffer */
74 	ssize_t hw_ptr;
75 
76 	void *rbuf;
77 
78 	size_t period_size;
79 
80 	unsigned max_psize;
81 	struct uac2_req ureq[USB_XFERS];
82 
83 	spinlock_t lock;
84 };
85 
86 struct snd_uac2_chip {
87 	struct platform_device pdev;
88 	struct platform_driver pdrv;
89 
90 	struct uac2_rtd_params p_prm;
91 	struct uac2_rtd_params c_prm;
92 
93 	struct snd_card *card;
94 	struct snd_pcm *pcm;
95 
96 	/* timekeeping for the playback endpoint */
97 	unsigned int p_interval;
98 	unsigned int p_residue;
99 
100 	/* pre-calculated values for playback iso completion */
101 	unsigned int p_pktsize;
102 	unsigned int p_pktsize_residue;
103 	unsigned int p_framesize;
104 };
105 
106 #define BUFF_SIZE_MAX	(PAGE_SIZE * 16)
107 #define PRD_SIZE_MAX	PAGE_SIZE
108 #define MIN_PERIODS	4
109 
110 static struct snd_pcm_hardware uac2_pcm_hardware = {
111 	.info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
112 		 | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
113 		 | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
114 	.rates = SNDRV_PCM_RATE_CONTINUOUS,
115 	.periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
116 	.buffer_bytes_max = BUFF_SIZE_MAX,
117 	.period_bytes_max = PRD_SIZE_MAX,
118 	.periods_min = MIN_PERIODS,
119 };
120 
121 struct audio_dev {
122 	u8 ac_intf, ac_alt;
123 	u8 as_out_intf, as_out_alt;
124 	u8 as_in_intf, as_in_alt;
125 
126 	struct usb_ep *in_ep, *out_ep;
127 	struct usb_function func;
128 
129 	/* The ALSA Sound Card it represents on the USB-Client side */
130 	struct snd_uac2_chip uac2;
131 };
132 
133 static inline
134 struct audio_dev *func_to_agdev(struct usb_function *f)
135 {
136 	return container_of(f, struct audio_dev, func);
137 }
138 
139 static inline
140 struct audio_dev *uac2_to_agdev(struct snd_uac2_chip *u)
141 {
142 	return container_of(u, struct audio_dev, uac2);
143 }
144 
145 static inline
146 struct snd_uac2_chip *pdev_to_uac2(struct platform_device *p)
147 {
148 	return container_of(p, struct snd_uac2_chip, pdev);
149 }
150 
151 static inline
152 struct f_uac2_opts *agdev_to_uac2_opts(struct audio_dev *agdev)
153 {
154 	return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
155 }
156 
157 static inline
158 uint num_channels(uint chanmask)
159 {
160 	uint num = 0;
161 
162 	while (chanmask) {
163 		num += (chanmask & 1);
164 		chanmask >>= 1;
165 	}
166 
167 	return num;
168 }
169 
170 static void
171 agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
172 {
173 	unsigned pending;
174 	unsigned long flags;
175 	unsigned int hw_ptr;
176 	bool update_alsa = false;
177 	int status = req->status;
178 	struct uac2_req *ur = req->context;
179 	struct snd_pcm_substream *substream;
180 	struct uac2_rtd_params *prm = ur->pp;
181 	struct snd_uac2_chip *uac2 = prm->uac2;
182 
183 	/* i/f shutting down */
184 	if (!prm->ep_enabled || req->status == -ESHUTDOWN)
185 		return;
186 
187 	/*
188 	 * We can't really do much about bad xfers.
189 	 * Afterall, the ISOCH xfers could fail legitimately.
190 	 */
191 	if (status)
192 		pr_debug("%s: iso_complete status(%d) %d/%d\n",
193 			__func__, status, req->actual, req->length);
194 
195 	substream = prm->ss;
196 
197 	/* Do nothing if ALSA isn't active */
198 	if (!substream)
199 		goto exit;
200 
201 	spin_lock_irqsave(&prm->lock, flags);
202 
203 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
204 		/*
205 		 * For each IN packet, take the quotient of the current data
206 		 * rate and the endpoint's interval as the base packet size.
207 		 * If there is a residue from this division, add it to the
208 		 * residue accumulator.
209 		 */
210 		req->length = uac2->p_pktsize;
211 		uac2->p_residue += uac2->p_pktsize_residue;
212 
213 		/*
214 		 * Whenever there are more bytes in the accumulator than we
215 		 * need to add one more sample frame, increase this packet's
216 		 * size and decrease the accumulator.
217 		 */
218 		if (uac2->p_residue / uac2->p_interval >= uac2->p_framesize) {
219 			req->length += uac2->p_framesize;
220 			uac2->p_residue -= uac2->p_framesize *
221 					   uac2->p_interval;
222 		}
223 
224 		req->actual = req->length;
225 	}
226 
227 	pending = prm->hw_ptr % prm->period_size;
228 	pending += req->actual;
229 	if (pending >= prm->period_size)
230 		update_alsa = true;
231 
232 	hw_ptr = prm->hw_ptr;
233 	prm->hw_ptr = (prm->hw_ptr + req->actual) % prm->dma_bytes;
234 
235 	spin_unlock_irqrestore(&prm->lock, flags);
236 
237 	/* Pack USB load in ALSA ring buffer */
238 	pending = prm->dma_bytes - hw_ptr;
239 
240 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
241 		if (unlikely(pending < req->actual)) {
242 			memcpy(req->buf, prm->dma_area + hw_ptr, pending);
243 			memcpy(req->buf + pending, prm->dma_area,
244 			       req->actual - pending);
245 		} else {
246 			memcpy(req->buf, prm->dma_area + hw_ptr, req->actual);
247 		}
248 	} else {
249 		if (unlikely(pending < req->actual)) {
250 			memcpy(prm->dma_area + hw_ptr, req->buf, pending);
251 			memcpy(prm->dma_area, req->buf + pending,
252 			       req->actual - pending);
253 		} else {
254 			memcpy(prm->dma_area + hw_ptr, req->buf, req->actual);
255 		}
256 	}
257 
258 exit:
259 	if (usb_ep_queue(ep, req, GFP_ATOMIC))
260 		dev_err(&uac2->pdev.dev, "%d Error!\n", __LINE__);
261 
262 	if (update_alsa)
263 		snd_pcm_period_elapsed(substream);
264 
265 	return;
266 }
267 
268 static int
269 uac2_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
270 {
271 	struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
272 	struct uac2_rtd_params *prm;
273 	unsigned long flags;
274 	int err = 0;
275 
276 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
277 		prm = &uac2->p_prm;
278 	else
279 		prm = &uac2->c_prm;
280 
281 	spin_lock_irqsave(&prm->lock, flags);
282 
283 	/* Reset */
284 	prm->hw_ptr = 0;
285 
286 	switch (cmd) {
287 	case SNDRV_PCM_TRIGGER_START:
288 	case SNDRV_PCM_TRIGGER_RESUME:
289 		prm->ss = substream;
290 		break;
291 	case SNDRV_PCM_TRIGGER_STOP:
292 	case SNDRV_PCM_TRIGGER_SUSPEND:
293 		prm->ss = NULL;
294 		break;
295 	default:
296 		err = -EINVAL;
297 	}
298 
299 	spin_unlock_irqrestore(&prm->lock, flags);
300 
301 	/* Clear buffer after Play stops */
302 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
303 		memset(prm->rbuf, 0, prm->max_psize * USB_XFERS);
304 
305 	return err;
306 }
307 
308 static snd_pcm_uframes_t uac2_pcm_pointer(struct snd_pcm_substream *substream)
309 {
310 	struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
311 	struct uac2_rtd_params *prm;
312 
313 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
314 		prm = &uac2->p_prm;
315 	else
316 		prm = &uac2->c_prm;
317 
318 	return bytes_to_frames(substream->runtime, prm->hw_ptr);
319 }
320 
321 static int uac2_pcm_hw_params(struct snd_pcm_substream *substream,
322 			       struct snd_pcm_hw_params *hw_params)
323 {
324 	struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
325 	struct uac2_rtd_params *prm;
326 	int err;
327 
328 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
329 		prm = &uac2->p_prm;
330 	else
331 		prm = &uac2->c_prm;
332 
333 	err = snd_pcm_lib_malloc_pages(substream,
334 					params_buffer_bytes(hw_params));
335 	if (err >= 0) {
336 		prm->dma_bytes = substream->runtime->dma_bytes;
337 		prm->dma_area = substream->runtime->dma_area;
338 		prm->period_size = params_period_bytes(hw_params);
339 	}
340 
341 	return err;
342 }
343 
344 static int uac2_pcm_hw_free(struct snd_pcm_substream *substream)
345 {
346 	struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
347 	struct uac2_rtd_params *prm;
348 
349 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
350 		prm = &uac2->p_prm;
351 	else
352 		prm = &uac2->c_prm;
353 
354 	prm->dma_area = NULL;
355 	prm->dma_bytes = 0;
356 	prm->period_size = 0;
357 
358 	return snd_pcm_lib_free_pages(substream);
359 }
360 
361 static int uac2_pcm_open(struct snd_pcm_substream *substream)
362 {
363 	struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
364 	struct snd_pcm_runtime *runtime = substream->runtime;
365 	struct audio_dev *audio_dev;
366 	struct f_uac2_opts *opts;
367 	int p_ssize, c_ssize;
368 	int p_srate, c_srate;
369 	int p_chmask, c_chmask;
370 
371 	audio_dev = uac2_to_agdev(uac2);
372 	opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
373 	p_ssize = opts->p_ssize;
374 	c_ssize = opts->c_ssize;
375 	p_srate = opts->p_srate;
376 	c_srate = opts->c_srate;
377 	p_chmask = opts->p_chmask;
378 	c_chmask = opts->c_chmask;
379 	uac2->p_residue = 0;
380 
381 	runtime->hw = uac2_pcm_hardware;
382 
383 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
384 		spin_lock_init(&uac2->p_prm.lock);
385 		runtime->hw.rate_min = p_srate;
386 		switch (p_ssize) {
387 		case 3:
388 			runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
389 			break;
390 		case 4:
391 			runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
392 			break;
393 		default:
394 			runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
395 			break;
396 		}
397 		runtime->hw.channels_min = num_channels(p_chmask);
398 		runtime->hw.period_bytes_min = 2 * uac2->p_prm.max_psize
399 						/ runtime->hw.periods_min;
400 	} else {
401 		spin_lock_init(&uac2->c_prm.lock);
402 		runtime->hw.rate_min = c_srate;
403 		switch (c_ssize) {
404 		case 3:
405 			runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
406 			break;
407 		case 4:
408 			runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
409 			break;
410 		default:
411 			runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
412 			break;
413 		}
414 		runtime->hw.channels_min = num_channels(c_chmask);
415 		runtime->hw.period_bytes_min = 2 * uac2->c_prm.max_psize
416 						/ runtime->hw.periods_min;
417 	}
418 
419 	runtime->hw.rate_max = runtime->hw.rate_min;
420 	runtime->hw.channels_max = runtime->hw.channels_min;
421 
422 	snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
423 
424 	return 0;
425 }
426 
427 /* ALSA cries without these function pointers */
428 static int uac2_pcm_null(struct snd_pcm_substream *substream)
429 {
430 	return 0;
431 }
432 
433 static struct snd_pcm_ops uac2_pcm_ops = {
434 	.open = uac2_pcm_open,
435 	.close = uac2_pcm_null,
436 	.ioctl = snd_pcm_lib_ioctl,
437 	.hw_params = uac2_pcm_hw_params,
438 	.hw_free = uac2_pcm_hw_free,
439 	.trigger = uac2_pcm_trigger,
440 	.pointer = uac2_pcm_pointer,
441 	.prepare = uac2_pcm_null,
442 };
443 
444 static int snd_uac2_probe(struct platform_device *pdev)
445 {
446 	struct snd_uac2_chip *uac2 = pdev_to_uac2(pdev);
447 	struct snd_card *card;
448 	struct snd_pcm *pcm;
449 	struct audio_dev *audio_dev;
450 	struct f_uac2_opts *opts;
451 	int err;
452 	int p_chmask, c_chmask;
453 
454 	audio_dev = uac2_to_agdev(uac2);
455 	opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
456 	p_chmask = opts->p_chmask;
457 	c_chmask = opts->c_chmask;
458 
459 	/* Choose any slot, with no id */
460 	err = snd_card_new(&pdev->dev, -1, NULL, THIS_MODULE, 0, &card);
461 	if (err < 0)
462 		return err;
463 
464 	uac2->card = card;
465 
466 	/*
467 	 * Create first PCM device
468 	 * Create a substream only for non-zero channel streams
469 	 */
470 	err = snd_pcm_new(uac2->card, "UAC2 PCM", 0,
471 			       p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
472 	if (err < 0)
473 		goto snd_fail;
474 
475 	strcpy(pcm->name, "UAC2 PCM");
476 	pcm->private_data = uac2;
477 
478 	uac2->pcm = pcm;
479 
480 	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac2_pcm_ops);
481 	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac2_pcm_ops);
482 
483 	strcpy(card->driver, "UAC2_Gadget");
484 	strcpy(card->shortname, "UAC2_Gadget");
485 	sprintf(card->longname, "UAC2_Gadget %i", pdev->id);
486 
487 	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
488 		snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX);
489 
490 	err = snd_card_register(card);
491 	if (!err) {
492 		platform_set_drvdata(pdev, card);
493 		return 0;
494 	}
495 
496 snd_fail:
497 	snd_card_free(card);
498 
499 	uac2->pcm = NULL;
500 	uac2->card = NULL;
501 
502 	return err;
503 }
504 
505 static int snd_uac2_remove(struct platform_device *pdev)
506 {
507 	struct snd_card *card = platform_get_drvdata(pdev);
508 
509 	if (card)
510 		return snd_card_free(card);
511 
512 	return 0;
513 }
514 
515 static int alsa_uac2_init(struct audio_dev *agdev)
516 {
517 	struct snd_uac2_chip *uac2 = &agdev->uac2;
518 	int err;
519 
520 	uac2->pdrv.probe = snd_uac2_probe;
521 	uac2->pdrv.remove = snd_uac2_remove;
522 	uac2->pdrv.driver.name = uac2_name;
523 
524 	uac2->pdev.id = 0;
525 	uac2->pdev.name = uac2_name;
526 
527 	/* Register snd_uac2 driver */
528 	err = platform_driver_register(&uac2->pdrv);
529 	if (err)
530 		return err;
531 
532 	/* Register snd_uac2 device */
533 	err = platform_device_register(&uac2->pdev);
534 	if (err)
535 		platform_driver_unregister(&uac2->pdrv);
536 
537 	return err;
538 }
539 
540 static void alsa_uac2_exit(struct audio_dev *agdev)
541 {
542 	struct snd_uac2_chip *uac2 = &agdev->uac2;
543 
544 	platform_driver_unregister(&uac2->pdrv);
545 	platform_device_unregister(&uac2->pdev);
546 }
547 
548 
549 /* --------- USB Function Interface ------------- */
550 
551 enum {
552 	STR_ASSOC,
553 	STR_IF_CTRL,
554 	STR_CLKSRC_IN,
555 	STR_CLKSRC_OUT,
556 	STR_USB_IT,
557 	STR_IO_IT,
558 	STR_USB_OT,
559 	STR_IO_OT,
560 	STR_AS_OUT_ALT0,
561 	STR_AS_OUT_ALT1,
562 	STR_AS_IN_ALT0,
563 	STR_AS_IN_ALT1,
564 };
565 
566 static char clksrc_in[8];
567 static char clksrc_out[8];
568 
569 static struct usb_string strings_fn[] = {
570 	[STR_ASSOC].s = "Source/Sink",
571 	[STR_IF_CTRL].s = "Topology Control",
572 	[STR_CLKSRC_IN].s = clksrc_in,
573 	[STR_CLKSRC_OUT].s = clksrc_out,
574 	[STR_USB_IT].s = "USBH Out",
575 	[STR_IO_IT].s = "USBD Out",
576 	[STR_USB_OT].s = "USBH In",
577 	[STR_IO_OT].s = "USBD In",
578 	[STR_AS_OUT_ALT0].s = "Playback Inactive",
579 	[STR_AS_OUT_ALT1].s = "Playback Active",
580 	[STR_AS_IN_ALT0].s = "Capture Inactive",
581 	[STR_AS_IN_ALT1].s = "Capture Active",
582 	{ },
583 };
584 
585 static struct usb_gadget_strings str_fn = {
586 	.language = 0x0409,	/* en-us */
587 	.strings = strings_fn,
588 };
589 
590 static struct usb_gadget_strings *fn_strings[] = {
591 	&str_fn,
592 	NULL,
593 };
594 
595 static struct usb_qualifier_descriptor devqual_desc = {
596 	.bLength = sizeof devqual_desc,
597 	.bDescriptorType = USB_DT_DEVICE_QUALIFIER,
598 
599 	.bcdUSB = cpu_to_le16(0x200),
600 	.bDeviceClass = USB_CLASS_MISC,
601 	.bDeviceSubClass = 0x02,
602 	.bDeviceProtocol = 0x01,
603 	.bNumConfigurations = 1,
604 	.bRESERVED = 0,
605 };
606 
607 static struct usb_interface_assoc_descriptor iad_desc = {
608 	.bLength = sizeof iad_desc,
609 	.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
610 
611 	.bFirstInterface = 0,
612 	.bInterfaceCount = 3,
613 	.bFunctionClass = USB_CLASS_AUDIO,
614 	.bFunctionSubClass = UAC2_FUNCTION_SUBCLASS_UNDEFINED,
615 	.bFunctionProtocol = UAC_VERSION_2,
616 };
617 
618 /* Audio Control Interface */
619 static struct usb_interface_descriptor std_ac_if_desc = {
620 	.bLength = sizeof std_ac_if_desc,
621 	.bDescriptorType = USB_DT_INTERFACE,
622 
623 	.bAlternateSetting = 0,
624 	.bNumEndpoints = 0,
625 	.bInterfaceClass = USB_CLASS_AUDIO,
626 	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
627 	.bInterfaceProtocol = UAC_VERSION_2,
628 };
629 
630 /* Clock source for IN traffic */
631 struct uac_clock_source_descriptor in_clk_src_desc = {
632 	.bLength = sizeof in_clk_src_desc,
633 	.bDescriptorType = USB_DT_CS_INTERFACE,
634 
635 	.bDescriptorSubtype = UAC2_CLOCK_SOURCE,
636 	.bClockID = USB_IN_CLK_ID,
637 	.bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
638 	.bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
639 	.bAssocTerminal = 0,
640 };
641 
642 /* Clock source for OUT traffic */
643 struct uac_clock_source_descriptor out_clk_src_desc = {
644 	.bLength = sizeof out_clk_src_desc,
645 	.bDescriptorType = USB_DT_CS_INTERFACE,
646 
647 	.bDescriptorSubtype = UAC2_CLOCK_SOURCE,
648 	.bClockID = USB_OUT_CLK_ID,
649 	.bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
650 	.bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
651 	.bAssocTerminal = 0,
652 };
653 
654 /* Input Terminal for USB_OUT */
655 struct uac2_input_terminal_descriptor usb_out_it_desc = {
656 	.bLength = sizeof usb_out_it_desc,
657 	.bDescriptorType = USB_DT_CS_INTERFACE,
658 
659 	.bDescriptorSubtype = UAC_INPUT_TERMINAL,
660 	.bTerminalID = USB_OUT_IT_ID,
661 	.wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
662 	.bAssocTerminal = 0,
663 	.bCSourceID = USB_OUT_CLK_ID,
664 	.iChannelNames = 0,
665 	.bmControls = (CONTROL_RDWR << COPY_CTRL),
666 };
667 
668 /* Input Terminal for I/O-In */
669 struct uac2_input_terminal_descriptor io_in_it_desc = {
670 	.bLength = sizeof io_in_it_desc,
671 	.bDescriptorType = USB_DT_CS_INTERFACE,
672 
673 	.bDescriptorSubtype = UAC_INPUT_TERMINAL,
674 	.bTerminalID = IO_IN_IT_ID,
675 	.wTerminalType = cpu_to_le16(UAC_INPUT_TERMINAL_UNDEFINED),
676 	.bAssocTerminal = 0,
677 	.bCSourceID = USB_IN_CLK_ID,
678 	.iChannelNames = 0,
679 	.bmControls = (CONTROL_RDWR << COPY_CTRL),
680 };
681 
682 /* Ouput Terminal for USB_IN */
683 struct uac2_output_terminal_descriptor usb_in_ot_desc = {
684 	.bLength = sizeof usb_in_ot_desc,
685 	.bDescriptorType = USB_DT_CS_INTERFACE,
686 
687 	.bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
688 	.bTerminalID = USB_IN_OT_ID,
689 	.wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
690 	.bAssocTerminal = 0,
691 	.bSourceID = IO_IN_IT_ID,
692 	.bCSourceID = USB_IN_CLK_ID,
693 	.bmControls = (CONTROL_RDWR << COPY_CTRL),
694 };
695 
696 /* Ouput Terminal for I/O-Out */
697 struct uac2_output_terminal_descriptor io_out_ot_desc = {
698 	.bLength = sizeof io_out_ot_desc,
699 	.bDescriptorType = USB_DT_CS_INTERFACE,
700 
701 	.bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
702 	.bTerminalID = IO_OUT_OT_ID,
703 	.wTerminalType = cpu_to_le16(UAC_OUTPUT_TERMINAL_UNDEFINED),
704 	.bAssocTerminal = 0,
705 	.bSourceID = USB_OUT_IT_ID,
706 	.bCSourceID = USB_OUT_CLK_ID,
707 	.bmControls = (CONTROL_RDWR << COPY_CTRL),
708 };
709 
710 struct uac2_ac_header_descriptor ac_hdr_desc = {
711 	.bLength = sizeof ac_hdr_desc,
712 	.bDescriptorType = USB_DT_CS_INTERFACE,
713 
714 	.bDescriptorSubtype = UAC_MS_HEADER,
715 	.bcdADC = cpu_to_le16(0x200),
716 	.bCategory = UAC2_FUNCTION_IO_BOX,
717 	.wTotalLength = sizeof in_clk_src_desc + sizeof out_clk_src_desc
718 			 + sizeof usb_out_it_desc + sizeof io_in_it_desc
719 			+ sizeof usb_in_ot_desc + sizeof io_out_ot_desc,
720 	.bmControls = 0,
721 };
722 
723 /* Audio Streaming OUT Interface - Alt0 */
724 static struct usb_interface_descriptor std_as_out_if0_desc = {
725 	.bLength = sizeof std_as_out_if0_desc,
726 	.bDescriptorType = USB_DT_INTERFACE,
727 
728 	.bAlternateSetting = 0,
729 	.bNumEndpoints = 0,
730 	.bInterfaceClass = USB_CLASS_AUDIO,
731 	.bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
732 	.bInterfaceProtocol = UAC_VERSION_2,
733 };
734 
735 /* Audio Streaming OUT Interface - Alt1 */
736 static struct usb_interface_descriptor std_as_out_if1_desc = {
737 	.bLength = sizeof std_as_out_if1_desc,
738 	.bDescriptorType = USB_DT_INTERFACE,
739 
740 	.bAlternateSetting = 1,
741 	.bNumEndpoints = 1,
742 	.bInterfaceClass = USB_CLASS_AUDIO,
743 	.bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
744 	.bInterfaceProtocol = UAC_VERSION_2,
745 };
746 
747 /* Audio Stream OUT Intface Desc */
748 struct uac2_as_header_descriptor as_out_hdr_desc = {
749 	.bLength = sizeof as_out_hdr_desc,
750 	.bDescriptorType = USB_DT_CS_INTERFACE,
751 
752 	.bDescriptorSubtype = UAC_AS_GENERAL,
753 	.bTerminalLink = USB_OUT_IT_ID,
754 	.bmControls = 0,
755 	.bFormatType = UAC_FORMAT_TYPE_I,
756 	.bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
757 	.iChannelNames = 0,
758 };
759 
760 /* Audio USB_OUT Format */
761 struct uac2_format_type_i_descriptor as_out_fmt1_desc = {
762 	.bLength = sizeof as_out_fmt1_desc,
763 	.bDescriptorType = USB_DT_CS_INTERFACE,
764 	.bDescriptorSubtype = UAC_FORMAT_TYPE,
765 	.bFormatType = UAC_FORMAT_TYPE_I,
766 };
767 
768 /* STD AS ISO OUT Endpoint */
769 struct usb_endpoint_descriptor fs_epout_desc = {
770 	.bLength = USB_DT_ENDPOINT_SIZE,
771 	.bDescriptorType = USB_DT_ENDPOINT,
772 
773 	.bEndpointAddress = USB_DIR_OUT,
774 	.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
775 	.bInterval = 1,
776 };
777 
778 struct usb_endpoint_descriptor hs_epout_desc = {
779 	.bLength = USB_DT_ENDPOINT_SIZE,
780 	.bDescriptorType = USB_DT_ENDPOINT,
781 
782 	.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
783 	.bInterval = 4,
784 };
785 
786 /* CS AS ISO OUT Endpoint */
787 static struct uac2_iso_endpoint_descriptor as_iso_out_desc = {
788 	.bLength = sizeof as_iso_out_desc,
789 	.bDescriptorType = USB_DT_CS_ENDPOINT,
790 
791 	.bDescriptorSubtype = UAC_EP_GENERAL,
792 	.bmAttributes = 0,
793 	.bmControls = 0,
794 	.bLockDelayUnits = 0,
795 	.wLockDelay = 0,
796 };
797 
798 /* Audio Streaming IN Interface - Alt0 */
799 static struct usb_interface_descriptor std_as_in_if0_desc = {
800 	.bLength = sizeof std_as_in_if0_desc,
801 	.bDescriptorType = USB_DT_INTERFACE,
802 
803 	.bAlternateSetting = 0,
804 	.bNumEndpoints = 0,
805 	.bInterfaceClass = USB_CLASS_AUDIO,
806 	.bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
807 	.bInterfaceProtocol = UAC_VERSION_2,
808 };
809 
810 /* Audio Streaming IN Interface - Alt1 */
811 static struct usb_interface_descriptor std_as_in_if1_desc = {
812 	.bLength = sizeof std_as_in_if1_desc,
813 	.bDescriptorType = USB_DT_INTERFACE,
814 
815 	.bAlternateSetting = 1,
816 	.bNumEndpoints = 1,
817 	.bInterfaceClass = USB_CLASS_AUDIO,
818 	.bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
819 	.bInterfaceProtocol = UAC_VERSION_2,
820 };
821 
822 /* Audio Stream IN Intface Desc */
823 struct uac2_as_header_descriptor as_in_hdr_desc = {
824 	.bLength = sizeof as_in_hdr_desc,
825 	.bDescriptorType = USB_DT_CS_INTERFACE,
826 
827 	.bDescriptorSubtype = UAC_AS_GENERAL,
828 	.bTerminalLink = USB_IN_OT_ID,
829 	.bmControls = 0,
830 	.bFormatType = UAC_FORMAT_TYPE_I,
831 	.bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
832 	.iChannelNames = 0,
833 };
834 
835 /* Audio USB_IN Format */
836 struct uac2_format_type_i_descriptor as_in_fmt1_desc = {
837 	.bLength = sizeof as_in_fmt1_desc,
838 	.bDescriptorType = USB_DT_CS_INTERFACE,
839 	.bDescriptorSubtype = UAC_FORMAT_TYPE,
840 	.bFormatType = UAC_FORMAT_TYPE_I,
841 };
842 
843 /* STD AS ISO IN Endpoint */
844 struct usb_endpoint_descriptor fs_epin_desc = {
845 	.bLength = USB_DT_ENDPOINT_SIZE,
846 	.bDescriptorType = USB_DT_ENDPOINT,
847 
848 	.bEndpointAddress = USB_DIR_IN,
849 	.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
850 	.bInterval = 1,
851 };
852 
853 struct usb_endpoint_descriptor hs_epin_desc = {
854 	.bLength = USB_DT_ENDPOINT_SIZE,
855 	.bDescriptorType = USB_DT_ENDPOINT,
856 
857 	.bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
858 	.bInterval = 4,
859 };
860 
861 /* CS AS ISO IN Endpoint */
862 static struct uac2_iso_endpoint_descriptor as_iso_in_desc = {
863 	.bLength = sizeof as_iso_in_desc,
864 	.bDescriptorType = USB_DT_CS_ENDPOINT,
865 
866 	.bDescriptorSubtype = UAC_EP_GENERAL,
867 	.bmAttributes = 0,
868 	.bmControls = 0,
869 	.bLockDelayUnits = 0,
870 	.wLockDelay = 0,
871 };
872 
873 static struct usb_descriptor_header *fs_audio_desc[] = {
874 	(struct usb_descriptor_header *)&iad_desc,
875 	(struct usb_descriptor_header *)&std_ac_if_desc,
876 
877 	(struct usb_descriptor_header *)&ac_hdr_desc,
878 	(struct usb_descriptor_header *)&in_clk_src_desc,
879 	(struct usb_descriptor_header *)&out_clk_src_desc,
880 	(struct usb_descriptor_header *)&usb_out_it_desc,
881 	(struct usb_descriptor_header *)&io_in_it_desc,
882 	(struct usb_descriptor_header *)&usb_in_ot_desc,
883 	(struct usb_descriptor_header *)&io_out_ot_desc,
884 
885 	(struct usb_descriptor_header *)&std_as_out_if0_desc,
886 	(struct usb_descriptor_header *)&std_as_out_if1_desc,
887 
888 	(struct usb_descriptor_header *)&as_out_hdr_desc,
889 	(struct usb_descriptor_header *)&as_out_fmt1_desc,
890 	(struct usb_descriptor_header *)&fs_epout_desc,
891 	(struct usb_descriptor_header *)&as_iso_out_desc,
892 
893 	(struct usb_descriptor_header *)&std_as_in_if0_desc,
894 	(struct usb_descriptor_header *)&std_as_in_if1_desc,
895 
896 	(struct usb_descriptor_header *)&as_in_hdr_desc,
897 	(struct usb_descriptor_header *)&as_in_fmt1_desc,
898 	(struct usb_descriptor_header *)&fs_epin_desc,
899 	(struct usb_descriptor_header *)&as_iso_in_desc,
900 	NULL,
901 };
902 
903 static struct usb_descriptor_header *hs_audio_desc[] = {
904 	(struct usb_descriptor_header *)&iad_desc,
905 	(struct usb_descriptor_header *)&std_ac_if_desc,
906 
907 	(struct usb_descriptor_header *)&ac_hdr_desc,
908 	(struct usb_descriptor_header *)&in_clk_src_desc,
909 	(struct usb_descriptor_header *)&out_clk_src_desc,
910 	(struct usb_descriptor_header *)&usb_out_it_desc,
911 	(struct usb_descriptor_header *)&io_in_it_desc,
912 	(struct usb_descriptor_header *)&usb_in_ot_desc,
913 	(struct usb_descriptor_header *)&io_out_ot_desc,
914 
915 	(struct usb_descriptor_header *)&std_as_out_if0_desc,
916 	(struct usb_descriptor_header *)&std_as_out_if1_desc,
917 
918 	(struct usb_descriptor_header *)&as_out_hdr_desc,
919 	(struct usb_descriptor_header *)&as_out_fmt1_desc,
920 	(struct usb_descriptor_header *)&hs_epout_desc,
921 	(struct usb_descriptor_header *)&as_iso_out_desc,
922 
923 	(struct usb_descriptor_header *)&std_as_in_if0_desc,
924 	(struct usb_descriptor_header *)&std_as_in_if1_desc,
925 
926 	(struct usb_descriptor_header *)&as_in_hdr_desc,
927 	(struct usb_descriptor_header *)&as_in_fmt1_desc,
928 	(struct usb_descriptor_header *)&hs_epin_desc,
929 	(struct usb_descriptor_header *)&as_iso_in_desc,
930 	NULL,
931 };
932 
933 struct cntrl_cur_lay3 {
934 	__u32	dCUR;
935 };
936 
937 struct cntrl_range_lay3 {
938 	__u16	wNumSubRanges;
939 	__u32	dMIN;
940 	__u32	dMAX;
941 	__u32	dRES;
942 } __packed;
943 
944 static inline void
945 free_ep(struct uac2_rtd_params *prm, struct usb_ep *ep)
946 {
947 	struct snd_uac2_chip *uac2 = prm->uac2;
948 	int i;
949 
950 	prm->ep_enabled = false;
951 
952 	for (i = 0; i < USB_XFERS; i++) {
953 		if (prm->ureq[i].req) {
954 			usb_ep_dequeue(ep, prm->ureq[i].req);
955 			usb_ep_free_request(ep, prm->ureq[i].req);
956 			prm->ureq[i].req = NULL;
957 		}
958 	}
959 
960 	if (usb_ep_disable(ep))
961 		dev_err(&uac2->pdev.dev,
962 			"%s:%d Error!\n", __func__, __LINE__);
963 }
964 
965 static int
966 afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
967 {
968 	struct audio_dev *agdev = func_to_agdev(fn);
969 	struct snd_uac2_chip *uac2 = &agdev->uac2;
970 	struct usb_composite_dev *cdev = cfg->cdev;
971 	struct usb_gadget *gadget = cdev->gadget;
972 	struct device *dev = &uac2->pdev.dev;
973 	struct uac2_rtd_params *prm;
974 	struct f_uac2_opts *uac2_opts;
975 	struct usb_string *us;
976 	int ret;
977 
978 	uac2_opts = container_of(fn->fi, struct f_uac2_opts, func_inst);
979 
980 	us = usb_gstrings_attach(cdev, fn_strings, ARRAY_SIZE(strings_fn));
981 	if (IS_ERR(us))
982 		return PTR_ERR(us);
983 	iad_desc.iFunction = us[STR_ASSOC].id;
984 	std_ac_if_desc.iInterface = us[STR_IF_CTRL].id;
985 	in_clk_src_desc.iClockSource = us[STR_CLKSRC_IN].id;
986 	out_clk_src_desc.iClockSource = us[STR_CLKSRC_OUT].id;
987 	usb_out_it_desc.iTerminal = us[STR_USB_IT].id;
988 	io_in_it_desc.iTerminal = us[STR_IO_IT].id;
989 	usb_in_ot_desc.iTerminal = us[STR_USB_OT].id;
990 	io_out_ot_desc.iTerminal = us[STR_IO_OT].id;
991 	std_as_out_if0_desc.iInterface = us[STR_AS_OUT_ALT0].id;
992 	std_as_out_if1_desc.iInterface = us[STR_AS_OUT_ALT1].id;
993 	std_as_in_if0_desc.iInterface = us[STR_AS_IN_ALT0].id;
994 	std_as_in_if1_desc.iInterface = us[STR_AS_IN_ALT1].id;
995 
996 
997 	/* Initialize the configurable parameters */
998 	usb_out_it_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
999 	usb_out_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
1000 	io_in_it_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
1001 	io_in_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
1002 	as_out_hdr_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
1003 	as_out_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
1004 	as_in_hdr_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
1005 	as_in_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
1006 	as_out_fmt1_desc.bSubslotSize = uac2_opts->c_ssize;
1007 	as_out_fmt1_desc.bBitResolution = uac2_opts->c_ssize * 8;
1008 	as_in_fmt1_desc.bSubslotSize = uac2_opts->p_ssize;
1009 	as_in_fmt1_desc.bBitResolution = uac2_opts->p_ssize * 8;
1010 
1011 	snprintf(clksrc_in, sizeof(clksrc_in), "%uHz", uac2_opts->p_srate);
1012 	snprintf(clksrc_out, sizeof(clksrc_out), "%uHz", uac2_opts->c_srate);
1013 
1014 	ret = usb_interface_id(cfg, fn);
1015 	if (ret < 0) {
1016 		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1017 		return ret;
1018 	}
1019 	std_ac_if_desc.bInterfaceNumber = ret;
1020 	agdev->ac_intf = ret;
1021 	agdev->ac_alt = 0;
1022 
1023 	ret = usb_interface_id(cfg, fn);
1024 	if (ret < 0) {
1025 		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1026 		return ret;
1027 	}
1028 	std_as_out_if0_desc.bInterfaceNumber = ret;
1029 	std_as_out_if1_desc.bInterfaceNumber = ret;
1030 	agdev->as_out_intf = ret;
1031 	agdev->as_out_alt = 0;
1032 
1033 	ret = usb_interface_id(cfg, fn);
1034 	if (ret < 0) {
1035 		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1036 		return ret;
1037 	}
1038 	std_as_in_if0_desc.bInterfaceNumber = ret;
1039 	std_as_in_if1_desc.bInterfaceNumber = ret;
1040 	agdev->as_in_intf = ret;
1041 	agdev->as_in_alt = 0;
1042 
1043 	agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
1044 	if (!agdev->out_ep) {
1045 		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1046 		goto err;
1047 	}
1048 	agdev->out_ep->driver_data = agdev;
1049 
1050 	agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
1051 	if (!agdev->in_ep) {
1052 		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1053 		goto err;
1054 	}
1055 	agdev->in_ep->driver_data = agdev;
1056 
1057 	uac2->p_prm.uac2 = uac2;
1058 	uac2->c_prm.uac2 = uac2;
1059 
1060 	hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
1061 	hs_epout_desc.wMaxPacketSize = fs_epout_desc.wMaxPacketSize;
1062 	hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
1063 	hs_epin_desc.wMaxPacketSize = fs_epin_desc.wMaxPacketSize;
1064 
1065 	ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, NULL);
1066 	if (ret)
1067 		goto err;
1068 
1069 	prm = &agdev->uac2.c_prm;
1070 	prm->max_psize = hs_epout_desc.wMaxPacketSize;
1071 	prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
1072 	if (!prm->rbuf) {
1073 		prm->max_psize = 0;
1074 		goto err;
1075 	}
1076 
1077 	prm = &agdev->uac2.p_prm;
1078 	prm->max_psize = hs_epin_desc.wMaxPacketSize;
1079 	prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
1080 	if (!prm->rbuf) {
1081 		prm->max_psize = 0;
1082 		goto err;
1083 	}
1084 
1085 	ret = alsa_uac2_init(agdev);
1086 	if (ret)
1087 		goto err;
1088 	return 0;
1089 err:
1090 	kfree(agdev->uac2.p_prm.rbuf);
1091 	kfree(agdev->uac2.c_prm.rbuf);
1092 	usb_free_all_descriptors(fn);
1093 	if (agdev->in_ep)
1094 		agdev->in_ep->driver_data = NULL;
1095 	if (agdev->out_ep)
1096 		agdev->out_ep->driver_data = NULL;
1097 	return -EINVAL;
1098 }
1099 
1100 static int
1101 afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
1102 {
1103 	struct usb_composite_dev *cdev = fn->config->cdev;
1104 	struct audio_dev *agdev = func_to_agdev(fn);
1105 	struct snd_uac2_chip *uac2 = &agdev->uac2;
1106 	struct usb_gadget *gadget = cdev->gadget;
1107 	struct device *dev = &uac2->pdev.dev;
1108 	struct usb_request *req;
1109 	struct usb_ep *ep;
1110 	struct uac2_rtd_params *prm;
1111 	int req_len, i;
1112 
1113 	/* No i/f has more than 2 alt settings */
1114 	if (alt > 1) {
1115 		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1116 		return -EINVAL;
1117 	}
1118 
1119 	if (intf == agdev->ac_intf) {
1120 		/* Control I/f has only 1 AltSetting - 0 */
1121 		if (alt) {
1122 			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1123 			return -EINVAL;
1124 		}
1125 		return 0;
1126 	}
1127 
1128 	if (intf == agdev->as_out_intf) {
1129 		ep = agdev->out_ep;
1130 		prm = &uac2->c_prm;
1131 		config_ep_by_speed(gadget, fn, ep);
1132 		agdev->as_out_alt = alt;
1133 		req_len = prm->max_psize;
1134 	} else if (intf == agdev->as_in_intf) {
1135 		struct f_uac2_opts *opts = agdev_to_uac2_opts(agdev);
1136 		unsigned int factor, rate;
1137 		struct usb_endpoint_descriptor *ep_desc;
1138 
1139 		ep = agdev->in_ep;
1140 		prm = &uac2->p_prm;
1141 		config_ep_by_speed(gadget, fn, ep);
1142 		agdev->as_in_alt = alt;
1143 
1144 		/* pre-calculate the playback endpoint's interval */
1145 		if (gadget->speed == USB_SPEED_FULL) {
1146 			ep_desc = &fs_epin_desc;
1147 			factor = 1000;
1148 		} else {
1149 			ep_desc = &hs_epin_desc;
1150 			factor = 125;
1151 		}
1152 
1153 		/* pre-compute some values for iso_complete() */
1154 		uac2->p_framesize = opts->p_ssize *
1155 				    num_channels(opts->p_chmask);
1156 		rate = opts->p_srate * uac2->p_framesize;
1157 		uac2->p_interval = (1 << (ep_desc->bInterval - 1)) * factor;
1158 		uac2->p_pktsize = min_t(unsigned int, rate / uac2->p_interval,
1159 					prm->max_psize);
1160 
1161 		if (uac2->p_pktsize < prm->max_psize)
1162 			uac2->p_pktsize_residue = rate % uac2->p_interval;
1163 		else
1164 			uac2->p_pktsize_residue = 0;
1165 
1166 		req_len = uac2->p_pktsize;
1167 		uac2->p_residue = 0;
1168 	} else {
1169 		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1170 		return -EINVAL;
1171 	}
1172 
1173 	if (alt == 0) {
1174 		free_ep(prm, ep);
1175 		return 0;
1176 	}
1177 
1178 	prm->ep_enabled = true;
1179 	usb_ep_enable(ep);
1180 
1181 	for (i = 0; i < USB_XFERS; i++) {
1182 		if (!prm->ureq[i].req) {
1183 			req = usb_ep_alloc_request(ep, GFP_ATOMIC);
1184 			if (req == NULL)
1185 				return -ENOMEM;
1186 
1187 			prm->ureq[i].req = req;
1188 			prm->ureq[i].pp = prm;
1189 
1190 			req->zero = 0;
1191 			req->context = &prm->ureq[i];
1192 			req->length = req_len;
1193 			req->complete = agdev_iso_complete;
1194 			req->buf = prm->rbuf + i * prm->max_psize;
1195 		}
1196 
1197 		if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
1198 			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1199 	}
1200 
1201 	return 0;
1202 }
1203 
1204 static int
1205 afunc_get_alt(struct usb_function *fn, unsigned intf)
1206 {
1207 	struct audio_dev *agdev = func_to_agdev(fn);
1208 	struct snd_uac2_chip *uac2 = &agdev->uac2;
1209 
1210 	if (intf == agdev->ac_intf)
1211 		return agdev->ac_alt;
1212 	else if (intf == agdev->as_out_intf)
1213 		return agdev->as_out_alt;
1214 	else if (intf == agdev->as_in_intf)
1215 		return agdev->as_in_alt;
1216 	else
1217 		dev_err(&uac2->pdev.dev,
1218 			"%s:%d Invalid Interface %d!\n",
1219 			__func__, __LINE__, intf);
1220 
1221 	return -EINVAL;
1222 }
1223 
1224 static void
1225 afunc_disable(struct usb_function *fn)
1226 {
1227 	struct audio_dev *agdev = func_to_agdev(fn);
1228 	struct snd_uac2_chip *uac2 = &agdev->uac2;
1229 
1230 	free_ep(&uac2->p_prm, agdev->in_ep);
1231 	agdev->as_in_alt = 0;
1232 
1233 	free_ep(&uac2->c_prm, agdev->out_ep);
1234 	agdev->as_out_alt = 0;
1235 }
1236 
1237 static int
1238 in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1239 {
1240 	struct usb_request *req = fn->config->cdev->req;
1241 	struct audio_dev *agdev = func_to_agdev(fn);
1242 	struct snd_uac2_chip *uac2 = &agdev->uac2;
1243 	struct f_uac2_opts *opts;
1244 	u16 w_length = le16_to_cpu(cr->wLength);
1245 	u16 w_index = le16_to_cpu(cr->wIndex);
1246 	u16 w_value = le16_to_cpu(cr->wValue);
1247 	u8 entity_id = (w_index >> 8) & 0xff;
1248 	u8 control_selector = w_value >> 8;
1249 	int value = -EOPNOTSUPP;
1250 	int p_srate, c_srate;
1251 
1252 	opts = agdev_to_uac2_opts(agdev);
1253 	p_srate = opts->p_srate;
1254 	c_srate = opts->c_srate;
1255 
1256 	if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1257 		struct cntrl_cur_lay3 c;
1258 
1259 		if (entity_id == USB_IN_CLK_ID)
1260 			c.dCUR = p_srate;
1261 		else if (entity_id == USB_OUT_CLK_ID)
1262 			c.dCUR = c_srate;
1263 
1264 		value = min_t(unsigned, w_length, sizeof c);
1265 		memcpy(req->buf, &c, value);
1266 	} else if (control_selector == UAC2_CS_CONTROL_CLOCK_VALID) {
1267 		*(u8 *)req->buf = 1;
1268 		value = min_t(unsigned, w_length, 1);
1269 	} else {
1270 		dev_err(&uac2->pdev.dev,
1271 			"%s:%d control_selector=%d TODO!\n",
1272 			__func__, __LINE__, control_selector);
1273 	}
1274 
1275 	return value;
1276 }
1277 
1278 static int
1279 in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1280 {
1281 	struct usb_request *req = fn->config->cdev->req;
1282 	struct audio_dev *agdev = func_to_agdev(fn);
1283 	struct snd_uac2_chip *uac2 = &agdev->uac2;
1284 	struct f_uac2_opts *opts;
1285 	u16 w_length = le16_to_cpu(cr->wLength);
1286 	u16 w_index = le16_to_cpu(cr->wIndex);
1287 	u16 w_value = le16_to_cpu(cr->wValue);
1288 	u8 entity_id = (w_index >> 8) & 0xff;
1289 	u8 control_selector = w_value >> 8;
1290 	struct cntrl_range_lay3 r;
1291 	int value = -EOPNOTSUPP;
1292 	int p_srate, c_srate;
1293 
1294 	opts = agdev_to_uac2_opts(agdev);
1295 	p_srate = opts->p_srate;
1296 	c_srate = opts->c_srate;
1297 
1298 	if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1299 		if (entity_id == USB_IN_CLK_ID)
1300 			r.dMIN = p_srate;
1301 		else if (entity_id == USB_OUT_CLK_ID)
1302 			r.dMIN = c_srate;
1303 		else
1304 			return -EOPNOTSUPP;
1305 
1306 		r.dMAX = r.dMIN;
1307 		r.dRES = 0;
1308 		r.wNumSubRanges = 1;
1309 
1310 		value = min_t(unsigned, w_length, sizeof r);
1311 		memcpy(req->buf, &r, value);
1312 	} else {
1313 		dev_err(&uac2->pdev.dev,
1314 			"%s:%d control_selector=%d TODO!\n",
1315 			__func__, __LINE__, control_selector);
1316 	}
1317 
1318 	return value;
1319 }
1320 
1321 static int
1322 ac_rq_in(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1323 {
1324 	if (cr->bRequest == UAC2_CS_CUR)
1325 		return in_rq_cur(fn, cr);
1326 	else if (cr->bRequest == UAC2_CS_RANGE)
1327 		return in_rq_range(fn, cr);
1328 	else
1329 		return -EOPNOTSUPP;
1330 }
1331 
1332 static int
1333 out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1334 {
1335 	u16 w_length = le16_to_cpu(cr->wLength);
1336 	u16 w_value = le16_to_cpu(cr->wValue);
1337 	u8 control_selector = w_value >> 8;
1338 
1339 	if (control_selector == UAC2_CS_CONTROL_SAM_FREQ)
1340 		return w_length;
1341 
1342 	return -EOPNOTSUPP;
1343 }
1344 
1345 static int
1346 setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1347 {
1348 	struct audio_dev *agdev = func_to_agdev(fn);
1349 	struct snd_uac2_chip *uac2 = &agdev->uac2;
1350 	u16 w_index = le16_to_cpu(cr->wIndex);
1351 	u8 intf = w_index & 0xff;
1352 
1353 	if (intf != agdev->ac_intf) {
1354 		dev_err(&uac2->pdev.dev,
1355 			"%s:%d Error!\n", __func__, __LINE__);
1356 		return -EOPNOTSUPP;
1357 	}
1358 
1359 	if (cr->bRequestType & USB_DIR_IN)
1360 		return ac_rq_in(fn, cr);
1361 	else if (cr->bRequest == UAC2_CS_CUR)
1362 		return out_rq_cur(fn, cr);
1363 
1364 	return -EOPNOTSUPP;
1365 }
1366 
1367 static int
1368 afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1369 {
1370 	struct usb_composite_dev *cdev = fn->config->cdev;
1371 	struct audio_dev *agdev = func_to_agdev(fn);
1372 	struct snd_uac2_chip *uac2 = &agdev->uac2;
1373 	struct usb_request *req = cdev->req;
1374 	u16 w_length = le16_to_cpu(cr->wLength);
1375 	int value = -EOPNOTSUPP;
1376 
1377 	/* Only Class specific requests are supposed to reach here */
1378 	if ((cr->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
1379 		return -EOPNOTSUPP;
1380 
1381 	if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
1382 		value = setup_rq_inf(fn, cr);
1383 	else
1384 		dev_err(&uac2->pdev.dev, "%s:%d Error!\n", __func__, __LINE__);
1385 
1386 	if (value >= 0) {
1387 		req->length = value;
1388 		req->zero = value < w_length;
1389 		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
1390 		if (value < 0) {
1391 			dev_err(&uac2->pdev.dev,
1392 				"%s:%d Error!\n", __func__, __LINE__);
1393 			req->status = 0;
1394 		}
1395 	}
1396 
1397 	return value;
1398 }
1399 
1400 static inline struct f_uac2_opts *to_f_uac2_opts(struct config_item *item)
1401 {
1402 	return container_of(to_config_group(item), struct f_uac2_opts,
1403 			    func_inst.group);
1404 }
1405 
1406 CONFIGFS_ATTR_STRUCT(f_uac2_opts);
1407 CONFIGFS_ATTR_OPS(f_uac2_opts);
1408 
1409 static void f_uac2_attr_release(struct config_item *item)
1410 {
1411 	struct f_uac2_opts *opts = to_f_uac2_opts(item);
1412 
1413 	usb_put_function_instance(&opts->func_inst);
1414 }
1415 
1416 static struct configfs_item_operations f_uac2_item_ops = {
1417 	.release	= f_uac2_attr_release,
1418 	.show_attribute	= f_uac2_opts_attr_show,
1419 	.store_attribute = f_uac2_opts_attr_store,
1420 };
1421 
1422 #define UAC2_ATTRIBUTE(name)						\
1423 static ssize_t f_uac2_opts_##name##_show(struct f_uac2_opts *opts,	\
1424 					 char *page)			\
1425 {									\
1426 	int result;							\
1427 									\
1428 	mutex_lock(&opts->lock);					\
1429 	result = sprintf(page, "%u\n", opts->name);			\
1430 	mutex_unlock(&opts->lock);					\
1431 									\
1432 	return result;							\
1433 }									\
1434 									\
1435 static ssize_t f_uac2_opts_##name##_store(struct f_uac2_opts *opts,	\
1436 					  const char *page, size_t len)	\
1437 {									\
1438 	int ret;							\
1439 	u32 num;							\
1440 									\
1441 	mutex_lock(&opts->lock);					\
1442 	if (opts->refcnt) {						\
1443 		ret = -EBUSY;						\
1444 		goto end;						\
1445 	}								\
1446 									\
1447 	ret = kstrtou32(page, 0, &num);					\
1448 	if (ret)							\
1449 		goto end;						\
1450 									\
1451 	opts->name = num;						\
1452 	ret = len;							\
1453 									\
1454 end:									\
1455 	mutex_unlock(&opts->lock);					\
1456 	return ret;							\
1457 }									\
1458 									\
1459 static struct f_uac2_opts_attribute f_uac2_opts_##name =		\
1460 	__CONFIGFS_ATTR(name, S_IRUGO | S_IWUSR,			\
1461 			f_uac2_opts_##name##_show,			\
1462 			f_uac2_opts_##name##_store)
1463 
1464 UAC2_ATTRIBUTE(p_chmask);
1465 UAC2_ATTRIBUTE(p_srate);
1466 UAC2_ATTRIBUTE(p_ssize);
1467 UAC2_ATTRIBUTE(c_chmask);
1468 UAC2_ATTRIBUTE(c_srate);
1469 UAC2_ATTRIBUTE(c_ssize);
1470 
1471 static struct configfs_attribute *f_uac2_attrs[] = {
1472 	&f_uac2_opts_p_chmask.attr,
1473 	&f_uac2_opts_p_srate.attr,
1474 	&f_uac2_opts_p_ssize.attr,
1475 	&f_uac2_opts_c_chmask.attr,
1476 	&f_uac2_opts_c_srate.attr,
1477 	&f_uac2_opts_c_ssize.attr,
1478 	NULL,
1479 };
1480 
1481 static struct config_item_type f_uac2_func_type = {
1482 	.ct_item_ops	= &f_uac2_item_ops,
1483 	.ct_attrs	= f_uac2_attrs,
1484 	.ct_owner	= THIS_MODULE,
1485 };
1486 
1487 static void afunc_free_inst(struct usb_function_instance *f)
1488 {
1489 	struct f_uac2_opts *opts;
1490 
1491 	opts = container_of(f, struct f_uac2_opts, func_inst);
1492 	kfree(opts);
1493 }
1494 
1495 static struct usb_function_instance *afunc_alloc_inst(void)
1496 {
1497 	struct f_uac2_opts *opts;
1498 
1499 	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1500 	if (!opts)
1501 		return ERR_PTR(-ENOMEM);
1502 
1503 	mutex_init(&opts->lock);
1504 	opts->func_inst.free_func_inst = afunc_free_inst;
1505 
1506 	config_group_init_type_name(&opts->func_inst.group, "",
1507 				    &f_uac2_func_type);
1508 
1509 	opts->p_chmask = UAC2_DEF_PCHMASK;
1510 	opts->p_srate = UAC2_DEF_PSRATE;
1511 	opts->p_ssize = UAC2_DEF_PSSIZE;
1512 	opts->c_chmask = UAC2_DEF_CCHMASK;
1513 	opts->c_srate = UAC2_DEF_CSRATE;
1514 	opts->c_ssize = UAC2_DEF_CSSIZE;
1515 	return &opts->func_inst;
1516 }
1517 
1518 static void afunc_free(struct usb_function *f)
1519 {
1520 	struct audio_dev *agdev;
1521 	struct f_uac2_opts *opts;
1522 
1523 	agdev = func_to_agdev(f);
1524 	opts = container_of(f->fi, struct f_uac2_opts, func_inst);
1525 	kfree(agdev);
1526 	mutex_lock(&opts->lock);
1527 	--opts->refcnt;
1528 	mutex_unlock(&opts->lock);
1529 }
1530 
1531 static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
1532 {
1533 	struct audio_dev *agdev = func_to_agdev(f);
1534 	struct uac2_rtd_params *prm;
1535 
1536 	alsa_uac2_exit(agdev);
1537 
1538 	prm = &agdev->uac2.p_prm;
1539 	kfree(prm->rbuf);
1540 
1541 	prm = &agdev->uac2.c_prm;
1542 	kfree(prm->rbuf);
1543 	usb_free_all_descriptors(f);
1544 
1545 	if (agdev->in_ep)
1546 		agdev->in_ep->driver_data = NULL;
1547 	if (agdev->out_ep)
1548 		agdev->out_ep->driver_data = NULL;
1549 }
1550 
1551 struct usb_function *afunc_alloc(struct usb_function_instance *fi)
1552 {
1553 	struct audio_dev *agdev;
1554 	struct f_uac2_opts *opts;
1555 
1556 	agdev = kzalloc(sizeof(*agdev), GFP_KERNEL);
1557 	if (agdev == NULL)
1558 		return ERR_PTR(-ENOMEM);
1559 
1560 	opts = container_of(fi, struct f_uac2_opts, func_inst);
1561 	mutex_lock(&opts->lock);
1562 	++opts->refcnt;
1563 	mutex_unlock(&opts->lock);
1564 
1565 	agdev->func.name = "uac2_func";
1566 	agdev->func.bind = afunc_bind;
1567 	agdev->func.unbind = afunc_unbind;
1568 	agdev->func.set_alt = afunc_set_alt;
1569 	agdev->func.get_alt = afunc_get_alt;
1570 	agdev->func.disable = afunc_disable;
1571 	agdev->func.setup = afunc_setup;
1572 	agdev->func.free_func = afunc_free;
1573 
1574 	return &agdev->func;
1575 }
1576 
1577 DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
1578 MODULE_LICENSE("GPL");
1579 MODULE_AUTHOR("Yadwinder Singh");
1580 MODULE_AUTHOR("Jaswinder Singh");
1581