projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
usb: gadget: function: uvc: disable endpoints on ->disable()
[deliverable/linux.git] / drivers / usb / gadget / function / f_uac2.c
CommitLineData
132fcb46
JB		 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
f8f93d24
AP		 23#include "u_uac2.h"
24
132fcb46
JB		 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
57const char *uac2_name = "snd_uac2";
58
59struct uac2_req {
60 struct uac2_rtd_params *pp; /* parent param */
61 struct usb_request *req;
62};
63
64struct uac2_rtd_params {
eb127cb5 65 struct snd_uac2_chip *uac2; /* parent chip */
132fcb46
JB		 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
86struct 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;
9bb87f16
DM		 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;
132fcb46
JB		 104};
105
106#define BUFF_SIZE_MAX (PAGE_SIZE * 16)
107#define PRD_SIZE_MAX PAGE_SIZE
108#define MIN_PERIODS 4
109
110static 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
121struct audio_dev {
4ce63571
SAS		 122 u8 ac_intf, ac_alt;
123 u8 as_out_intf, as_out_alt;
124 u8 as_in_intf, as_in_alt;
132fcb46
JB		 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
132fcb46
JB		 133static inline
134struct audio_dev *func_to_agdev(struct usb_function *f)
135{
136 return container_of(f, struct audio_dev, func);
137}
138
139static inline
140struct audio_dev *uac2_to_agdev(struct snd_uac2_chip *u)
141{
142 return container_of(u, struct audio_dev, uac2);
143}
144
145static inline
146struct snd_uac2_chip *pdev_to_uac2(struct platform_device *p)
147{
148 return container_of(p, struct snd_uac2_chip, pdev);
149}
150
254b3bf6
DM		 151static inline
152struct 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
132fcb46
JB		 157static inline
158uint 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
170static void
171agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
172{
173 unsigned pending;
174 unsigned long flags;
ec9e4313 175 unsigned int hw_ptr;
132fcb46 176 bool update_alsa = false;
132fcb46
JB		 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;
eb127cb5 181 struct snd_uac2_chip *uac2 = prm->uac2;
132fcb46
JB		 182
183 /* i/f shutting down */
1ade5d7e 184 if (!prm->ep_enabled || req->status == -ESHUTDOWN)
132fcb46
JB		 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
9bb87f16
DM		 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
132fcb46 224 req->actual = req->length;
9bb87f16 225 }
132fcb46
JB		 226
227 pending = prm->hw_ptr % prm->period_size;
228 pending += req->actual;
229 if (pending >= prm->period_size)
230 update_alsa = true;
231
ec9e4313 232 hw_ptr = prm->hw_ptr;
132fcb46
JB		 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 */
ec9e4313
DM		 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
132fcb46
JB		 258exit:
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
268static int
269uac2_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
270{
271 struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
132fcb46
JB		 272 struct uac2_rtd_params *prm;
273 unsigned long flags;
132fcb46
JB		 274 int err = 0;
275
b6424353 276 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
132fcb46 277 prm = &uac2->p_prm;
b6424353 278 else
132fcb46 279 prm = &uac2->c_prm;
132fcb46
JB		 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
308static 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
321static 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
344static 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
361static 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;
f8f93d24
AP		 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;
9bb87f16 379 uac2->p_residue = 0;
132fcb46
JB		 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;
55f7840a
SR		 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 }
132fcb46
JB		 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;
55f7840a
SR		 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 }
132fcb46
JB		 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 */
428static int uac2_pcm_null(struct snd_pcm_substream *substream)
429{
430 return 0;
431}
432
433static 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
41ac7b3a 444static int snd_uac2_probe(struct platform_device *pdev)
132fcb46
JB		 445{
446 struct snd_uac2_chip *uac2 = pdev_to_uac2(pdev);
447 struct snd_card *card;
448 struct snd_pcm *pcm;
f8f93d24
AP		 449 struct audio_dev *audio_dev;
450 struct f_uac2_opts *opts;
132fcb46 451 int err;
f8f93d24
AP		 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;
132fcb46
JB		 458
459 /* Choose any slot, with no id */
13345095 460 err = snd_card_new(&pdev->dev, -1, NULL, THIS_MODULE, 0, &card);
132fcb46
JB		 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
132fcb46
JB		 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
496snd_fail:
497 snd_card_free(card);
498
499 uac2->pcm = NULL;
500 uac2->card = NULL;
501
502 return err;
503}
504
1e1a27c3 505static int snd_uac2_remove(struct platform_device *pdev)
132fcb46
JB		 506{
507 struct snd_card *card = platform_get_drvdata(pdev);
508
132fcb46
JB		 509 if (card)
510 return snd_card_free(card);
511
512 return 0;
513}
514
515static 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
540static 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
551enum {
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
132fcb46
JB		 566static char clksrc_in[8];
567static char clksrc_out[8];
132fcb46
JB		 568
569static struct usb_string strings_fn[] = {
b36c3479
SAS		 570 [STR_ASSOC].s = "Source/Sink",
571 [STR_IF_CTRL].s = "Topology Control",
132fcb46
JB		 572 [STR_CLKSRC_IN].s = clksrc_in,
573 [STR_CLKSRC_OUT].s = clksrc_out,
b36c3479
SAS		 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",
132fcb46
JB		 582 { },
583};
584
585static struct usb_gadget_strings str_fn = {
586 .language = 0x0409, /* en-us */
587 .strings = strings_fn,
588};
589
590static struct usb_gadget_strings *fn_strings[] = {
591 &str_fn,
592 NULL,
593};
594
595static 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
607static 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 */
619static 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 */
631struct 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 */
643struct 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 */
655struct 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 */
669struct 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 */
683struct 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 */
697struct 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
710struct 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 */
724static 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 */
736static 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 */
748struct 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 */
761struct 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 */
769struct 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
778struct 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 */
787static 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 */
799static 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 */
811static 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 */
823struct 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 */
836struct 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 */
844struct 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
853struct 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 */
862static 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
873static 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
903static 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
933struct cntrl_cur_lay3 {
934 __u32 dCUR;
935};
936
937struct cntrl_range_lay3 {
938 __u16 wNumSubRanges;
939 __u32 dMIN;
940 __u32 dMAX;
941 __u32 dRES;
942} __packed;
943
944static inline void
945free_ep(struct uac2_rtd_params *prm, struct usb_ep *ep)
946{
eb127cb5 947 struct snd_uac2_chip *uac2 = prm->uac2;
132fcb46
JB		 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
f8f93d24 965static int
132fcb46
JB		 966afunc_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;
a8147dab 972 struct device *dev = &uac2->pdev.dev;
132fcb46 973 struct uac2_rtd_params *prm;
f8f93d24 974 struct f_uac2_opts *uac2_opts;
f408757f 975 struct usb_string *us;
132fcb46
JB		 976 int ret;
977
f8f93d24 978 uac2_opts = container_of(fn->fi, struct f_uac2_opts, func_inst);
f8f93d24 979
f408757f
AP		 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
f8f93d24 996
f8f93d24
AP		 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);
f8f93d24 1013
132fcb46
JB		 1014 ret = usb_interface_id(cfg, fn);
1015 if (ret < 0) {
a8147dab 1016 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
132fcb46
JB		 1017 return ret;
1018 }
1019 std_ac_if_desc.bInterfaceNumber = ret;
4ce63571
SAS		 1020 agdev->ac_intf = ret;
1021 agdev->ac_alt = 0;
132fcb46
JB		 1022
1023 ret = usb_interface_id(cfg, fn);
1024 if (ret < 0) {
a8147dab 1025 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
132fcb46
JB		 1026 return ret;
1027 }
1028 std_as_out_if0_desc.bInterfaceNumber = ret;
1029 std_as_out_if1_desc.bInterfaceNumber = ret;
4ce63571
SAS		 1030 agdev->as_out_intf = ret;
1031 agdev->as_out_alt = 0;
132fcb46
JB		 1032
1033 ret = usb_interface_id(cfg, fn);
1034 if (ret < 0) {
a8147dab 1035 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
132fcb46
JB		 1036 return ret;
1037 }
1038 std_as_in_if0_desc.bInterfaceNumber = ret;
1039 std_as_in_if1_desc.bInterfaceNumber = ret;
4ce63571
SAS		 1040 agdev->as_in_intf = ret;
1041 agdev->as_in_alt = 0;
132fcb46
JB		 1042
1043 agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
391aa852 1044 if (!agdev->out_ep) {
a8147dab 1045 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
391aa852
SAS		 1046 goto err;
1047 }
132fcb46
JB		 1048 agdev->out_ep->driver_data = agdev;
1049
1050 agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
391aa852 1051 if (!agdev->in_ep) {
a8147dab 1052 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
391aa852
SAS		 1053 goto err;
1054 }
132fcb46
JB		 1055 agdev->in_ep->driver_data = agdev;
1056
eb127cb5
JB		 1057 uac2->p_prm.uac2 = uac2;
1058 uac2->c_prm.uac2 = uac2;
1059
132fcb46
JB		 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
10287bae
SAS		 1065 ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, NULL);
1066 if (ret)
1067 goto err;
132fcb46
JB		 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;
391aa852 1074 goto err;
132fcb46
JB		 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;
391aa852 1082 goto err;
132fcb46
JB		 1083 }
1084
391aa852
SAS		 1085 ret = alsa_uac2_init(agdev);
1086 if (ret)
1087 goto err;
1088 return 0;
1089err:
1090 kfree(agdev->uac2.p_prm.rbuf);
1091 kfree(agdev->uac2.c_prm.rbuf);
10287bae 1092 usb_free_all_descriptors(fn);
391aa852
SAS		 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;
132fcb46
JB		 1098}
1099
132fcb46
JB		 1100static int
1101afunc_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;
a8147dab 1107 struct device *dev = &uac2->pdev.dev;
132fcb46
JB		 1108 struct usb_request *req;
1109 struct usb_ep *ep;
1110 struct uac2_rtd_params *prm;
9bb87f16 1111 int req_len, i;
132fcb46
JB		 1112
1113 /* No i/f has more than 2 alt settings */
1114 if (alt > 1) {
a8147dab 1115 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
132fcb46
JB		 1116 return -EINVAL;
1117 }
1118
4ce63571 1119 if (intf == agdev->ac_intf) {
132fcb46
JB		 1120 /* Control I/f has only 1 AltSetting - 0 */
1121 if (alt) {
a8147dab 1122 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
132fcb46
JB		 1123 return -EINVAL;
1124 }
1125 return 0;
1126 }
1127
4ce63571 1128 if (intf == agdev->as_out_intf) {
132fcb46
JB		 1129 ep = agdev->out_ep;
1130 prm = &uac2->c_prm;
1131 config_ep_by_speed(gadget, fn, ep);
4ce63571 1132 agdev->as_out_alt = alt;
9bb87f16 1133 req_len = prm->max_psize;
4ce63571 1134 } else if (intf == agdev->as_in_intf) {
9bb87f16
DM		 1135 struct f_uac2_opts *opts = agdev_to_uac2_opts(agdev);
1136 unsigned int factor, rate;
1137 struct usb_endpoint_descriptor *ep_desc;
1138
132fcb46
JB		 1139 ep = agdev->in_ep;
1140 prm = &uac2->p_prm;
1141 config_ep_by_speed(gadget, fn, ep);
4ce63571 1142 agdev->as_in_alt = alt;
9bb87f16
DM		 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;
132fcb46 1168 } else {
a8147dab 1169 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
132fcb46
JB		 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++) {
430fdbd3
DM		 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];
9bb87f16 1192 req->length = req_len;
430fdbd3 1193 req->complete = agdev_iso_complete;
9bb87f16 1194 req->buf = prm->rbuf + i * prm->max_psize;
132fcb46
JB		 1195 }
1196
430fdbd3 1197 if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
a8147dab 1198 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
132fcb46
JB		 1199 }
1200
1201 return 0;
1202}
1203
1204static int
1205afunc_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
4ce63571
SAS		 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;
132fcb46
JB		 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
1224static void
1225afunc_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);
4ce63571 1231 agdev->as_in_alt = 0;
132fcb46
JB		 1232
1233 free_ep(&uac2->c_prm, agdev->out_ep);
4ce63571 1234 agdev->as_out_alt = 0;
132fcb46
JB		 1235}
1236
1237static int
1238in_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;
f8f93d24 1243 struct f_uac2_opts *opts;
132fcb46
JB		 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;
f8f93d24
AP		 1250 int p_srate, c_srate;
1251
254b3bf6 1252 opts = agdev_to_uac2_opts(agdev);
f8f93d24
AP		 1253 p_srate = opts->p_srate;
1254 c_srate = opts->c_srate;
132fcb46
JB		 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
1278static int
1279in_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;
f8f93d24 1284 struct f_uac2_opts *opts;
132fcb46
JB		 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;
f8f93d24
AP		 1292 int p_srate, c_srate;
1293
254b3bf6 1294 opts = agdev_to_uac2_opts(agdev);
f8f93d24
AP		 1295 p_srate = opts->p_srate;
1296 c_srate = opts->c_srate;
132fcb46
JB		 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
1321static int
1322ac_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
1332static int
1333out_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
1345static int
1346setup_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
4ce63571 1353 if (intf != agdev->ac_intf) {
132fcb46
JB		 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
1367static int
1368afunc_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
3aeea3c5
AP		 1400static 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
1406CONFIGFS_ATTR_STRUCT(f_uac2_opts);
1407CONFIGFS_ATTR_OPS(f_uac2_opts);
1408
1409static 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
1416static 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) \
1423static 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 \
1435static 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 \
1454end: \
1455 mutex_unlock(&opts->lock); \
1456 return ret; \
1457} \
1458 \
1459static 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
1464UAC2_ATTRIBUTE(p_chmask);
1465UAC2_ATTRIBUTE(p_srate);
1466UAC2_ATTRIBUTE(p_ssize);
1467UAC2_ATTRIBUTE(c_chmask);
1468UAC2_ATTRIBUTE(c_srate);
1469UAC2_ATTRIBUTE(c_ssize);
1470
1471static 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
1481static 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
f8f93d24
AP		 1487static 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
1495static 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
3aeea3c5 1503 mutex_init(&opts->lock);
f8f93d24
AP		 1504 opts->func_inst.free_func_inst = afunc_free_inst;
1505
3aeea3c5
AP		 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;
f8f93d24
AP		 1515 return &opts->func_inst;
1516}
1517
1518static void afunc_free(struct usb_function *f)
1519{
1520 struct audio_dev *agdev;
3aeea3c5 1521 struct f_uac2_opts *opts;
f8f93d24
AP		 1522
1523 agdev = func_to_agdev(f);
3aeea3c5 1524 opts = container_of(f->fi, struct f_uac2_opts, func_inst);
f8f93d24 1525 kfree(agdev);
3aeea3c5
AP		 1526 mutex_lock(&opts->lock);
1527 --opts->refcnt;
1528 mutex_unlock(&opts->lock);
f8f93d24
AP		 1529}
1530
1531static 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
1551struct 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);
3aeea3c5
AP		 1561 mutex_lock(&opts->lock);
1562 ++opts->refcnt;
1563 mutex_unlock(&opts->lock);
f8f93d24
AP		 1564
1565 agdev->func.name = "uac2_func";
f8f93d24
AP		 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
1577DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
1578MODULE_LICENSE("GPL");
1579MODULE_AUTHOR("Yadwinder Singh");
1580MODULE_AUTHOR("Jaswinder Singh");
Linux kernel - Deliverables
This page took 0.24366 seconds and 5 git commands to generate.