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