2 * f_uac2.c -- USB Audio Class 2.0 Function
5 * Yadwinder Singh (yadi.brar01@gmail.com)
6 * Jaswinder Singh (jaswinder.singh@linaro.org)
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.
14 #include <linux/usb/audio.h>
15 #include <linux/usb/audio-v2.h>
16 #include <linux/platform_device.h>
17 #include <linux/module.h>
19 #include <sound/core.h>
20 #include <sound/pcm.h>
21 #include <sound/pcm_params.h>
25 /* Keep everyone on toes */
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
36 #define USB_OUT_IT_ID 1
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
43 #define CONTROL_ABSENT 0
44 #define CONTROL_RDONLY 1
45 #define CONTROL_RDWR 3
47 #define CLK_FREQ_CTRL 0
48 #define CLK_VLD_CTRL 2
57 static const char *uac2_name
= "snd_uac2";
60 struct uac2_rtd_params
*pp
; /* parent param */
61 struct usb_request
*req
;
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 */
69 unsigned char *dma_area
;
71 struct snd_pcm_substream
*ss
;
81 struct uac2_req ureq
[USB_XFERS
];
86 struct snd_uac2_chip
{
87 struct platform_device pdev
;
88 struct platform_driver pdrv
;
90 struct uac2_rtd_params p_prm
;
91 struct uac2_rtd_params c_prm
;
93 struct snd_card
*card
;
96 /* timekeeping for the playback endpoint */
97 unsigned int p_interval
;
98 unsigned int p_residue
;
100 /* pre-calculated values for playback iso completion */
101 unsigned int p_pktsize
;
102 unsigned int p_pktsize_residue
;
103 unsigned int p_framesize
;
106 #define BUFF_SIZE_MAX (PAGE_SIZE * 16)
107 #define PRD_SIZE_MAX PAGE_SIZE
108 #define MIN_PERIODS 4
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
,
123 u8 as_out_intf
, as_out_alt
;
124 u8 as_in_intf
, as_in_alt
;
126 struct usb_ep
*in_ep
, *out_ep
;
127 struct usb_function func
;
129 /* The ALSA Sound Card it represents on the USB-Client side */
130 struct snd_uac2_chip uac2
;
134 struct audio_dev
*func_to_agdev(struct usb_function
*f
)
136 return container_of(f
, struct audio_dev
, func
);
140 struct audio_dev
*uac2_to_agdev(struct snd_uac2_chip
*u
)
142 return container_of(u
, struct audio_dev
, uac2
);
146 struct snd_uac2_chip
*pdev_to_uac2(struct platform_device
*p
)
148 return container_of(p
, struct snd_uac2_chip
, pdev
);
152 struct f_uac2_opts
*agdev_to_uac2_opts(struct audio_dev
*agdev
)
154 return container_of(agdev
->func
.fi
, struct f_uac2_opts
, func_inst
);
158 uint
num_channels(uint chanmask
)
163 num
+= (chanmask
& 1);
171 agdev_iso_complete(struct usb_ep
*ep
, struct usb_request
*req
)
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
;
183 /* i/f shutting down */
184 if (!prm
->ep_enabled
|| req
->status
== -ESHUTDOWN
)
188 * We can't really do much about bad xfers.
189 * Afterall, the ISOCH xfers could fail legitimately.
192 pr_debug("%s: iso_complete status(%d) %d/%d\n",
193 __func__
, status
, req
->actual
, req
->length
);
197 /* Do nothing if ALSA isn't active */
201 spin_lock_irqsave(&prm
->lock
, flags
);
203 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
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.
210 req
->length
= uac2
->p_pktsize
;
211 uac2
->p_residue
+= uac2
->p_pktsize_residue
;
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.
218 if (uac2
->p_residue
/ uac2
->p_interval
>= uac2
->p_framesize
) {
219 req
->length
+= uac2
->p_framesize
;
220 uac2
->p_residue
-= uac2
->p_framesize
*
224 req
->actual
= req
->length
;
227 pending
= prm
->hw_ptr
% prm
->period_size
;
228 pending
+= req
->actual
;
229 if (pending
>= prm
->period_size
)
232 hw_ptr
= prm
->hw_ptr
;
233 prm
->hw_ptr
= (prm
->hw_ptr
+ req
->actual
) % prm
->dma_bytes
;
235 spin_unlock_irqrestore(&prm
->lock
, flags
);
237 /* Pack USB load in ALSA ring buffer */
238 pending
= prm
->dma_bytes
- hw_ptr
;
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
);
246 memcpy(req
->buf
, prm
->dma_area
+ hw_ptr
, req
->actual
);
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
);
254 memcpy(prm
->dma_area
+ hw_ptr
, req
->buf
, req
->actual
);
259 if (usb_ep_queue(ep
, req
, GFP_ATOMIC
))
260 dev_err(&uac2
->pdev
.dev
, "%d Error!\n", __LINE__
);
263 snd_pcm_period_elapsed(substream
);
269 uac2_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
271 struct snd_uac2_chip
*uac2
= snd_pcm_substream_chip(substream
);
272 struct uac2_rtd_params
*prm
;
276 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
281 spin_lock_irqsave(&prm
->lock
, flags
);
287 case SNDRV_PCM_TRIGGER_START
:
288 case SNDRV_PCM_TRIGGER_RESUME
:
291 case SNDRV_PCM_TRIGGER_STOP
:
292 case SNDRV_PCM_TRIGGER_SUSPEND
:
299 spin_unlock_irqrestore(&prm
->lock
, flags
);
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
);
308 static snd_pcm_uframes_t
uac2_pcm_pointer(struct snd_pcm_substream
*substream
)
310 struct snd_uac2_chip
*uac2
= snd_pcm_substream_chip(substream
);
311 struct uac2_rtd_params
*prm
;
313 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
318 return bytes_to_frames(substream
->runtime
, prm
->hw_ptr
);
321 static int uac2_pcm_hw_params(struct snd_pcm_substream
*substream
,
322 struct snd_pcm_hw_params
*hw_params
)
324 struct snd_uac2_chip
*uac2
= snd_pcm_substream_chip(substream
);
325 struct uac2_rtd_params
*prm
;
328 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
333 err
= snd_pcm_lib_malloc_pages(substream
,
334 params_buffer_bytes(hw_params
));
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
);
344 static int uac2_pcm_hw_free(struct snd_pcm_substream
*substream
)
346 struct snd_uac2_chip
*uac2
= snd_pcm_substream_chip(substream
);
347 struct uac2_rtd_params
*prm
;
349 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
354 prm
->dma_area
= NULL
;
356 prm
->period_size
= 0;
358 return snd_pcm_lib_free_pages(substream
);
361 static int uac2_pcm_open(struct snd_pcm_substream
*substream
)
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
;
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
;
381 runtime
->hw
= uac2_pcm_hardware
;
383 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
384 spin_lock_init(&uac2
->p_prm
.lock
);
385 runtime
->hw
.rate_min
= p_srate
;
388 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_S24_3LE
;
391 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_S32_LE
;
394 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_S16_LE
;
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
;
401 spin_lock_init(&uac2
->c_prm
.lock
);
402 runtime
->hw
.rate_min
= c_srate
;
405 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_S24_3LE
;
408 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_S32_LE
;
411 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_S16_LE
;
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
;
419 runtime
->hw
.rate_max
= runtime
->hw
.rate_min
;
420 runtime
->hw
.channels_max
= runtime
->hw
.channels_min
;
422 snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
);
427 /* ALSA cries without these function pointers */
428 static int uac2_pcm_null(struct snd_pcm_substream
*substream
)
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
,
444 static int snd_uac2_probe(struct platform_device
*pdev
)
446 struct snd_uac2_chip
*uac2
= pdev_to_uac2(pdev
);
447 struct snd_card
*card
;
449 struct audio_dev
*audio_dev
;
450 struct f_uac2_opts
*opts
;
452 int p_chmask
, c_chmask
;
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
;
459 /* Choose any slot, with no id */
460 err
= snd_card_new(&pdev
->dev
, -1, NULL
, THIS_MODULE
, 0, &card
);
467 * Create first PCM device
468 * Create a substream only for non-zero channel streams
470 err
= snd_pcm_new(uac2
->card
, "UAC2 PCM", 0,
471 p_chmask
? 1 : 0, c_chmask
? 1 : 0, &pcm
);
475 strcpy(pcm
->name
, "UAC2 PCM");
476 pcm
->private_data
= uac2
;
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
);
483 strcpy(card
->driver
, "UAC2_Gadget");
484 strcpy(card
->shortname
, "UAC2_Gadget");
485 sprintf(card
->longname
, "UAC2_Gadget %i", pdev
->id
);
487 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_CONTINUOUS
,
488 snd_dma_continuous_data(GFP_KERNEL
), 0, BUFF_SIZE_MAX
);
490 err
= snd_card_register(card
);
492 platform_set_drvdata(pdev
, card
);
505 static int snd_uac2_remove(struct platform_device
*pdev
)
507 struct snd_card
*card
= platform_get_drvdata(pdev
);
510 return snd_card_free(card
);
515 static void snd_uac2_release(struct device
*dev
)
517 dev_dbg(dev
, "releasing '%s'\n", dev_name(dev
));
520 static int alsa_uac2_init(struct audio_dev
*agdev
)
522 struct snd_uac2_chip
*uac2
= &agdev
->uac2
;
525 uac2
->pdrv
.probe
= snd_uac2_probe
;
526 uac2
->pdrv
.remove
= snd_uac2_remove
;
527 uac2
->pdrv
.driver
.name
= uac2_name
;
530 uac2
->pdev
.name
= uac2_name
;
531 uac2
->pdev
.dev
.release
= snd_uac2_release
;
533 /* Register snd_uac2 driver */
534 err
= platform_driver_register(&uac2
->pdrv
);
538 /* Register snd_uac2 device */
539 err
= platform_device_register(&uac2
->pdev
);
541 platform_driver_unregister(&uac2
->pdrv
);
546 static void alsa_uac2_exit(struct audio_dev
*agdev
)
548 struct snd_uac2_chip
*uac2
= &agdev
->uac2
;
550 platform_driver_unregister(&uac2
->pdrv
);
551 platform_device_unregister(&uac2
->pdev
);
555 /* --------- USB Function Interface ------------- */
572 static char clksrc_in
[8];
573 static char clksrc_out
[8];
575 static struct usb_string strings_fn
[] = {
576 [STR_ASSOC
].s
= "Source/Sink",
577 [STR_IF_CTRL
].s
= "Topology Control",
578 [STR_CLKSRC_IN
].s
= clksrc_in
,
579 [STR_CLKSRC_OUT
].s
= clksrc_out
,
580 [STR_USB_IT
].s
= "USBH Out",
581 [STR_IO_IT
].s
= "USBD Out",
582 [STR_USB_OT
].s
= "USBH In",
583 [STR_IO_OT
].s
= "USBD In",
584 [STR_AS_OUT_ALT0
].s
= "Playback Inactive",
585 [STR_AS_OUT_ALT1
].s
= "Playback Active",
586 [STR_AS_IN_ALT0
].s
= "Capture Inactive",
587 [STR_AS_IN_ALT1
].s
= "Capture Active",
591 static struct usb_gadget_strings str_fn
= {
592 .language
= 0x0409, /* en-us */
593 .strings
= strings_fn
,
596 static struct usb_gadget_strings
*fn_strings
[] = {
601 static struct usb_qualifier_descriptor devqual_desc
= {
602 .bLength
= sizeof devqual_desc
,
603 .bDescriptorType
= USB_DT_DEVICE_QUALIFIER
,
605 .bcdUSB
= cpu_to_le16(0x200),
606 .bDeviceClass
= USB_CLASS_MISC
,
607 .bDeviceSubClass
= 0x02,
608 .bDeviceProtocol
= 0x01,
609 .bNumConfigurations
= 1,
613 static struct usb_interface_assoc_descriptor iad_desc
= {
614 .bLength
= sizeof iad_desc
,
615 .bDescriptorType
= USB_DT_INTERFACE_ASSOCIATION
,
617 .bFirstInterface
= 0,
618 .bInterfaceCount
= 3,
619 .bFunctionClass
= USB_CLASS_AUDIO
,
620 .bFunctionSubClass
= UAC2_FUNCTION_SUBCLASS_UNDEFINED
,
621 .bFunctionProtocol
= UAC_VERSION_2
,
624 /* Audio Control Interface */
625 static struct usb_interface_descriptor std_ac_if_desc
= {
626 .bLength
= sizeof std_ac_if_desc
,
627 .bDescriptorType
= USB_DT_INTERFACE
,
629 .bAlternateSetting
= 0,
631 .bInterfaceClass
= USB_CLASS_AUDIO
,
632 .bInterfaceSubClass
= USB_SUBCLASS_AUDIOCONTROL
,
633 .bInterfaceProtocol
= UAC_VERSION_2
,
636 /* Clock source for IN traffic */
637 static struct uac_clock_source_descriptor in_clk_src_desc
= {
638 .bLength
= sizeof in_clk_src_desc
,
639 .bDescriptorType
= USB_DT_CS_INTERFACE
,
641 .bDescriptorSubtype
= UAC2_CLOCK_SOURCE
,
642 .bClockID
= USB_IN_CLK_ID
,
643 .bmAttributes
= UAC_CLOCK_SOURCE_TYPE_INT_FIXED
,
644 .bmControls
= (CONTROL_RDONLY
<< CLK_FREQ_CTRL
),
648 /* Clock source for OUT traffic */
649 static struct uac_clock_source_descriptor out_clk_src_desc
= {
650 .bLength
= sizeof out_clk_src_desc
,
651 .bDescriptorType
= USB_DT_CS_INTERFACE
,
653 .bDescriptorSubtype
= UAC2_CLOCK_SOURCE
,
654 .bClockID
= USB_OUT_CLK_ID
,
655 .bmAttributes
= UAC_CLOCK_SOURCE_TYPE_INT_FIXED
,
656 .bmControls
= (CONTROL_RDONLY
<< CLK_FREQ_CTRL
),
660 /* Input Terminal for USB_OUT */
661 static struct uac2_input_terminal_descriptor usb_out_it_desc
= {
662 .bLength
= sizeof usb_out_it_desc
,
663 .bDescriptorType
= USB_DT_CS_INTERFACE
,
665 .bDescriptorSubtype
= UAC_INPUT_TERMINAL
,
666 .bTerminalID
= USB_OUT_IT_ID
,
667 .wTerminalType
= cpu_to_le16(UAC_TERMINAL_STREAMING
),
669 .bCSourceID
= USB_OUT_CLK_ID
,
671 .bmControls
= (CONTROL_RDWR
<< COPY_CTRL
),
674 /* Input Terminal for I/O-In */
675 static struct uac2_input_terminal_descriptor io_in_it_desc
= {
676 .bLength
= sizeof io_in_it_desc
,
677 .bDescriptorType
= USB_DT_CS_INTERFACE
,
679 .bDescriptorSubtype
= UAC_INPUT_TERMINAL
,
680 .bTerminalID
= IO_IN_IT_ID
,
681 .wTerminalType
= cpu_to_le16(UAC_INPUT_TERMINAL_UNDEFINED
),
683 .bCSourceID
= USB_IN_CLK_ID
,
685 .bmControls
= (CONTROL_RDWR
<< COPY_CTRL
),
688 /* Ouput Terminal for USB_IN */
689 static struct uac2_output_terminal_descriptor usb_in_ot_desc
= {
690 .bLength
= sizeof usb_in_ot_desc
,
691 .bDescriptorType
= USB_DT_CS_INTERFACE
,
693 .bDescriptorSubtype
= UAC_OUTPUT_TERMINAL
,
694 .bTerminalID
= USB_IN_OT_ID
,
695 .wTerminalType
= cpu_to_le16(UAC_TERMINAL_STREAMING
),
697 .bSourceID
= IO_IN_IT_ID
,
698 .bCSourceID
= USB_IN_CLK_ID
,
699 .bmControls
= (CONTROL_RDWR
<< COPY_CTRL
),
702 /* Ouput Terminal for I/O-Out */
703 static struct uac2_output_terminal_descriptor io_out_ot_desc
= {
704 .bLength
= sizeof io_out_ot_desc
,
705 .bDescriptorType
= USB_DT_CS_INTERFACE
,
707 .bDescriptorSubtype
= UAC_OUTPUT_TERMINAL
,
708 .bTerminalID
= IO_OUT_OT_ID
,
709 .wTerminalType
= cpu_to_le16(UAC_OUTPUT_TERMINAL_UNDEFINED
),
711 .bSourceID
= USB_OUT_IT_ID
,
712 .bCSourceID
= USB_OUT_CLK_ID
,
713 .bmControls
= (CONTROL_RDWR
<< COPY_CTRL
),
716 static struct uac2_ac_header_descriptor ac_hdr_desc
= {
717 .bLength
= sizeof ac_hdr_desc
,
718 .bDescriptorType
= USB_DT_CS_INTERFACE
,
720 .bDescriptorSubtype
= UAC_MS_HEADER
,
721 .bcdADC
= cpu_to_le16(0x200),
722 .bCategory
= UAC2_FUNCTION_IO_BOX
,
723 .wTotalLength
= sizeof in_clk_src_desc
+ sizeof out_clk_src_desc
724 + sizeof usb_out_it_desc
+ sizeof io_in_it_desc
725 + sizeof usb_in_ot_desc
+ sizeof io_out_ot_desc
,
729 /* Audio Streaming OUT Interface - Alt0 */
730 static struct usb_interface_descriptor std_as_out_if0_desc
= {
731 .bLength
= sizeof std_as_out_if0_desc
,
732 .bDescriptorType
= USB_DT_INTERFACE
,
734 .bAlternateSetting
= 0,
736 .bInterfaceClass
= USB_CLASS_AUDIO
,
737 .bInterfaceSubClass
= USB_SUBCLASS_AUDIOSTREAMING
,
738 .bInterfaceProtocol
= UAC_VERSION_2
,
741 /* Audio Streaming OUT Interface - Alt1 */
742 static struct usb_interface_descriptor std_as_out_if1_desc
= {
743 .bLength
= sizeof std_as_out_if1_desc
,
744 .bDescriptorType
= USB_DT_INTERFACE
,
746 .bAlternateSetting
= 1,
748 .bInterfaceClass
= USB_CLASS_AUDIO
,
749 .bInterfaceSubClass
= USB_SUBCLASS_AUDIOSTREAMING
,
750 .bInterfaceProtocol
= UAC_VERSION_2
,
753 /* Audio Stream OUT Intface Desc */
754 static struct uac2_as_header_descriptor as_out_hdr_desc
= {
755 .bLength
= sizeof as_out_hdr_desc
,
756 .bDescriptorType
= USB_DT_CS_INTERFACE
,
758 .bDescriptorSubtype
= UAC_AS_GENERAL
,
759 .bTerminalLink
= USB_OUT_IT_ID
,
761 .bFormatType
= UAC_FORMAT_TYPE_I
,
762 .bmFormats
= cpu_to_le32(UAC_FORMAT_TYPE_I_PCM
),
766 /* Audio USB_OUT Format */
767 static struct uac2_format_type_i_descriptor as_out_fmt1_desc
= {
768 .bLength
= sizeof as_out_fmt1_desc
,
769 .bDescriptorType
= USB_DT_CS_INTERFACE
,
770 .bDescriptorSubtype
= UAC_FORMAT_TYPE
,
771 .bFormatType
= UAC_FORMAT_TYPE_I
,
774 /* STD AS ISO OUT Endpoint */
775 static struct usb_endpoint_descriptor fs_epout_desc
= {
776 .bLength
= USB_DT_ENDPOINT_SIZE
,
777 .bDescriptorType
= USB_DT_ENDPOINT
,
779 .bEndpointAddress
= USB_DIR_OUT
,
780 .bmAttributes
= USB_ENDPOINT_XFER_ISOC
| USB_ENDPOINT_SYNC_ASYNC
,
781 .wMaxPacketSize
= cpu_to_le16(1023),
785 static struct usb_endpoint_descriptor hs_epout_desc
= {
786 .bLength
= USB_DT_ENDPOINT_SIZE
,
787 .bDescriptorType
= USB_DT_ENDPOINT
,
789 .bmAttributes
= USB_ENDPOINT_XFER_ISOC
| USB_ENDPOINT_SYNC_ASYNC
,
790 .wMaxPacketSize
= cpu_to_le16(1024),
794 /* CS AS ISO OUT Endpoint */
795 static struct uac2_iso_endpoint_descriptor as_iso_out_desc
= {
796 .bLength
= sizeof as_iso_out_desc
,
797 .bDescriptorType
= USB_DT_CS_ENDPOINT
,
799 .bDescriptorSubtype
= UAC_EP_GENERAL
,
802 .bLockDelayUnits
= 0,
806 /* Audio Streaming IN Interface - Alt0 */
807 static struct usb_interface_descriptor std_as_in_if0_desc
= {
808 .bLength
= sizeof std_as_in_if0_desc
,
809 .bDescriptorType
= USB_DT_INTERFACE
,
811 .bAlternateSetting
= 0,
813 .bInterfaceClass
= USB_CLASS_AUDIO
,
814 .bInterfaceSubClass
= USB_SUBCLASS_AUDIOSTREAMING
,
815 .bInterfaceProtocol
= UAC_VERSION_2
,
818 /* Audio Streaming IN Interface - Alt1 */
819 static struct usb_interface_descriptor std_as_in_if1_desc
= {
820 .bLength
= sizeof std_as_in_if1_desc
,
821 .bDescriptorType
= USB_DT_INTERFACE
,
823 .bAlternateSetting
= 1,
825 .bInterfaceClass
= USB_CLASS_AUDIO
,
826 .bInterfaceSubClass
= USB_SUBCLASS_AUDIOSTREAMING
,
827 .bInterfaceProtocol
= UAC_VERSION_2
,
830 /* Audio Stream IN Intface Desc */
831 static struct uac2_as_header_descriptor as_in_hdr_desc
= {
832 .bLength
= sizeof as_in_hdr_desc
,
833 .bDescriptorType
= USB_DT_CS_INTERFACE
,
835 .bDescriptorSubtype
= UAC_AS_GENERAL
,
836 .bTerminalLink
= USB_IN_OT_ID
,
838 .bFormatType
= UAC_FORMAT_TYPE_I
,
839 .bmFormats
= cpu_to_le32(UAC_FORMAT_TYPE_I_PCM
),
843 /* Audio USB_IN Format */
844 static struct uac2_format_type_i_descriptor as_in_fmt1_desc
= {
845 .bLength
= sizeof as_in_fmt1_desc
,
846 .bDescriptorType
= USB_DT_CS_INTERFACE
,
847 .bDescriptorSubtype
= UAC_FORMAT_TYPE
,
848 .bFormatType
= UAC_FORMAT_TYPE_I
,
851 /* STD AS ISO IN Endpoint */
852 static struct usb_endpoint_descriptor fs_epin_desc
= {
853 .bLength
= USB_DT_ENDPOINT_SIZE
,
854 .bDescriptorType
= USB_DT_ENDPOINT
,
856 .bEndpointAddress
= USB_DIR_IN
,
857 .bmAttributes
= USB_ENDPOINT_XFER_ISOC
| USB_ENDPOINT_SYNC_ASYNC
,
858 .wMaxPacketSize
= cpu_to_le16(1023),
862 static struct usb_endpoint_descriptor hs_epin_desc
= {
863 .bLength
= USB_DT_ENDPOINT_SIZE
,
864 .bDescriptorType
= USB_DT_ENDPOINT
,
866 .bmAttributes
= USB_ENDPOINT_XFER_ISOC
| USB_ENDPOINT_SYNC_ASYNC
,
867 .wMaxPacketSize
= cpu_to_le16(1024),
871 /* CS AS ISO IN Endpoint */
872 static struct uac2_iso_endpoint_descriptor as_iso_in_desc
= {
873 .bLength
= sizeof as_iso_in_desc
,
874 .bDescriptorType
= USB_DT_CS_ENDPOINT
,
876 .bDescriptorSubtype
= UAC_EP_GENERAL
,
879 .bLockDelayUnits
= 0,
883 static struct usb_descriptor_header
*fs_audio_desc
[] = {
884 (struct usb_descriptor_header
*)&iad_desc
,
885 (struct usb_descriptor_header
*)&std_ac_if_desc
,
887 (struct usb_descriptor_header
*)&ac_hdr_desc
,
888 (struct usb_descriptor_header
*)&in_clk_src_desc
,
889 (struct usb_descriptor_header
*)&out_clk_src_desc
,
890 (struct usb_descriptor_header
*)&usb_out_it_desc
,
891 (struct usb_descriptor_header
*)&io_in_it_desc
,
892 (struct usb_descriptor_header
*)&usb_in_ot_desc
,
893 (struct usb_descriptor_header
*)&io_out_ot_desc
,
895 (struct usb_descriptor_header
*)&std_as_out_if0_desc
,
896 (struct usb_descriptor_header
*)&std_as_out_if1_desc
,
898 (struct usb_descriptor_header
*)&as_out_hdr_desc
,
899 (struct usb_descriptor_header
*)&as_out_fmt1_desc
,
900 (struct usb_descriptor_header
*)&fs_epout_desc
,
901 (struct usb_descriptor_header
*)&as_iso_out_desc
,
903 (struct usb_descriptor_header
*)&std_as_in_if0_desc
,
904 (struct usb_descriptor_header
*)&std_as_in_if1_desc
,
906 (struct usb_descriptor_header
*)&as_in_hdr_desc
,
907 (struct usb_descriptor_header
*)&as_in_fmt1_desc
,
908 (struct usb_descriptor_header
*)&fs_epin_desc
,
909 (struct usb_descriptor_header
*)&as_iso_in_desc
,
913 static struct usb_descriptor_header
*hs_audio_desc
[] = {
914 (struct usb_descriptor_header
*)&iad_desc
,
915 (struct usb_descriptor_header
*)&std_ac_if_desc
,
917 (struct usb_descriptor_header
*)&ac_hdr_desc
,
918 (struct usb_descriptor_header
*)&in_clk_src_desc
,
919 (struct usb_descriptor_header
*)&out_clk_src_desc
,
920 (struct usb_descriptor_header
*)&usb_out_it_desc
,
921 (struct usb_descriptor_header
*)&io_in_it_desc
,
922 (struct usb_descriptor_header
*)&usb_in_ot_desc
,
923 (struct usb_descriptor_header
*)&io_out_ot_desc
,
925 (struct usb_descriptor_header
*)&std_as_out_if0_desc
,
926 (struct usb_descriptor_header
*)&std_as_out_if1_desc
,
928 (struct usb_descriptor_header
*)&as_out_hdr_desc
,
929 (struct usb_descriptor_header
*)&as_out_fmt1_desc
,
930 (struct usb_descriptor_header
*)&hs_epout_desc
,
931 (struct usb_descriptor_header
*)&as_iso_out_desc
,
933 (struct usb_descriptor_header
*)&std_as_in_if0_desc
,
934 (struct usb_descriptor_header
*)&std_as_in_if1_desc
,
936 (struct usb_descriptor_header
*)&as_in_hdr_desc
,
937 (struct usb_descriptor_header
*)&as_in_fmt1_desc
,
938 (struct usb_descriptor_header
*)&hs_epin_desc
,
939 (struct usb_descriptor_header
*)&as_iso_in_desc
,
943 struct cntrl_cur_lay3
{
947 struct cntrl_range_lay3
{
955 free_ep(struct uac2_rtd_params
*prm
, struct usb_ep
*ep
)
957 struct snd_uac2_chip
*uac2
= prm
->uac2
;
960 if (!prm
->ep_enabled
)
963 prm
->ep_enabled
= false;
965 for (i
= 0; i
< USB_XFERS
; i
++) {
966 if (prm
->ureq
[i
].req
) {
967 usb_ep_dequeue(ep
, prm
->ureq
[i
].req
);
968 usb_ep_free_request(ep
, prm
->ureq
[i
].req
);
969 prm
->ureq
[i
].req
= NULL
;
973 if (usb_ep_disable(ep
))
974 dev_err(&uac2
->pdev
.dev
,
975 "%s:%d Error!\n", __func__
, __LINE__
);
978 static void set_ep_max_packet_size(const struct f_uac2_opts
*uac2_opts
,
979 struct usb_endpoint_descriptor
*ep_desc
,
980 unsigned int factor
, bool is_playback
)
982 int chmask
, srate
, ssize
;
986 chmask
= uac2_opts
->p_chmask
;
987 srate
= uac2_opts
->p_srate
;
988 ssize
= uac2_opts
->p_ssize
;
990 chmask
= uac2_opts
->c_chmask
;
991 srate
= uac2_opts
->c_srate
;
992 ssize
= uac2_opts
->c_ssize
;
995 max_packet_size
= num_channels(chmask
) * ssize
*
996 DIV_ROUND_UP(srate
, factor
/ (1 << (ep_desc
->bInterval
- 1)));
997 ep_desc
->wMaxPacketSize
= cpu_to_le16(min_t(u16
, max_packet_size
,
998 le16_to_cpu(ep_desc
->wMaxPacketSize
)));
1002 afunc_bind(struct usb_configuration
*cfg
, struct usb_function
*fn
)
1004 struct audio_dev
*agdev
= func_to_agdev(fn
);
1005 struct snd_uac2_chip
*uac2
= &agdev
->uac2
;
1006 struct usb_composite_dev
*cdev
= cfg
->cdev
;
1007 struct usb_gadget
*gadget
= cdev
->gadget
;
1008 struct device
*dev
= &uac2
->pdev
.dev
;
1009 struct uac2_rtd_params
*prm
;
1010 struct f_uac2_opts
*uac2_opts
;
1011 struct usb_string
*us
;
1014 uac2_opts
= container_of(fn
->fi
, struct f_uac2_opts
, func_inst
);
1016 us
= usb_gstrings_attach(cdev
, fn_strings
, ARRAY_SIZE(strings_fn
));
1019 iad_desc
.iFunction
= us
[STR_ASSOC
].id
;
1020 std_ac_if_desc
.iInterface
= us
[STR_IF_CTRL
].id
;
1021 in_clk_src_desc
.iClockSource
= us
[STR_CLKSRC_IN
].id
;
1022 out_clk_src_desc
.iClockSource
= us
[STR_CLKSRC_OUT
].id
;
1023 usb_out_it_desc
.iTerminal
= us
[STR_USB_IT
].id
;
1024 io_in_it_desc
.iTerminal
= us
[STR_IO_IT
].id
;
1025 usb_in_ot_desc
.iTerminal
= us
[STR_USB_OT
].id
;
1026 io_out_ot_desc
.iTerminal
= us
[STR_IO_OT
].id
;
1027 std_as_out_if0_desc
.iInterface
= us
[STR_AS_OUT_ALT0
].id
;
1028 std_as_out_if1_desc
.iInterface
= us
[STR_AS_OUT_ALT1
].id
;
1029 std_as_in_if0_desc
.iInterface
= us
[STR_AS_IN_ALT0
].id
;
1030 std_as_in_if1_desc
.iInterface
= us
[STR_AS_IN_ALT1
].id
;
1033 /* Initialize the configurable parameters */
1034 usb_out_it_desc
.bNrChannels
= num_channels(uac2_opts
->c_chmask
);
1035 usb_out_it_desc
.bmChannelConfig
= cpu_to_le32(uac2_opts
->c_chmask
);
1036 io_in_it_desc
.bNrChannels
= num_channels(uac2_opts
->p_chmask
);
1037 io_in_it_desc
.bmChannelConfig
= cpu_to_le32(uac2_opts
->p_chmask
);
1038 as_out_hdr_desc
.bNrChannels
= num_channels(uac2_opts
->c_chmask
);
1039 as_out_hdr_desc
.bmChannelConfig
= cpu_to_le32(uac2_opts
->c_chmask
);
1040 as_in_hdr_desc
.bNrChannels
= num_channels(uac2_opts
->p_chmask
);
1041 as_in_hdr_desc
.bmChannelConfig
= cpu_to_le32(uac2_opts
->p_chmask
);
1042 as_out_fmt1_desc
.bSubslotSize
= uac2_opts
->c_ssize
;
1043 as_out_fmt1_desc
.bBitResolution
= uac2_opts
->c_ssize
* 8;
1044 as_in_fmt1_desc
.bSubslotSize
= uac2_opts
->p_ssize
;
1045 as_in_fmt1_desc
.bBitResolution
= uac2_opts
->p_ssize
* 8;
1047 snprintf(clksrc_in
, sizeof(clksrc_in
), "%uHz", uac2_opts
->p_srate
);
1048 snprintf(clksrc_out
, sizeof(clksrc_out
), "%uHz", uac2_opts
->c_srate
);
1050 ret
= usb_interface_id(cfg
, fn
);
1052 dev_err(dev
, "%s:%d Error!\n", __func__
, __LINE__
);
1055 std_ac_if_desc
.bInterfaceNumber
= ret
;
1056 agdev
->ac_intf
= ret
;
1059 ret
= usb_interface_id(cfg
, fn
);
1061 dev_err(dev
, "%s:%d Error!\n", __func__
, __LINE__
);
1064 std_as_out_if0_desc
.bInterfaceNumber
= ret
;
1065 std_as_out_if1_desc
.bInterfaceNumber
= ret
;
1066 agdev
->as_out_intf
= ret
;
1067 agdev
->as_out_alt
= 0;
1069 ret
= usb_interface_id(cfg
, fn
);
1071 dev_err(dev
, "%s:%d Error!\n", __func__
, __LINE__
);
1074 std_as_in_if0_desc
.bInterfaceNumber
= ret
;
1075 std_as_in_if1_desc
.bInterfaceNumber
= ret
;
1076 agdev
->as_in_intf
= ret
;
1077 agdev
->as_in_alt
= 0;
1079 agdev
->out_ep
= usb_ep_autoconfig(gadget
, &fs_epout_desc
);
1080 if (!agdev
->out_ep
) {
1081 dev_err(dev
, "%s:%d Error!\n", __func__
, __LINE__
);
1084 agdev
->out_ep
->driver_data
= agdev
;
1086 agdev
->in_ep
= usb_ep_autoconfig(gadget
, &fs_epin_desc
);
1087 if (!agdev
->in_ep
) {
1088 dev_err(dev
, "%s:%d Error!\n", __func__
, __LINE__
);
1091 agdev
->in_ep
->driver_data
= agdev
;
1093 uac2
->p_prm
.uac2
= uac2
;
1094 uac2
->c_prm
.uac2
= uac2
;
1096 /* Calculate wMaxPacketSize according to audio bandwidth */
1097 set_ep_max_packet_size(uac2_opts
, &fs_epin_desc
, 1000, true);
1098 set_ep_max_packet_size(uac2_opts
, &fs_epout_desc
, 1000, false);
1099 set_ep_max_packet_size(uac2_opts
, &hs_epin_desc
, 8000, true);
1100 set_ep_max_packet_size(uac2_opts
, &hs_epout_desc
, 8000, false);
1102 hs_epout_desc
.bEndpointAddress
= fs_epout_desc
.bEndpointAddress
;
1103 hs_epin_desc
.bEndpointAddress
= fs_epin_desc
.bEndpointAddress
;
1105 ret
= usb_assign_descriptors(fn
, fs_audio_desc
, hs_audio_desc
, NULL
);
1109 prm
= &agdev
->uac2
.c_prm
;
1110 prm
->max_psize
= hs_epout_desc
.wMaxPacketSize
;
1111 prm
->rbuf
= kzalloc(prm
->max_psize
* USB_XFERS
, GFP_KERNEL
);
1114 goto err_free_descs
;
1117 prm
= &agdev
->uac2
.p_prm
;
1118 prm
->max_psize
= hs_epin_desc
.wMaxPacketSize
;
1119 prm
->rbuf
= kzalloc(prm
->max_psize
* USB_XFERS
, GFP_KERNEL
);
1122 goto err_free_descs
;
1125 ret
= alsa_uac2_init(agdev
);
1127 goto err_free_descs
;
1131 usb_free_all_descriptors(fn
);
1133 kfree(agdev
->uac2
.p_prm
.rbuf
);
1134 kfree(agdev
->uac2
.c_prm
.rbuf
);
1136 agdev
->in_ep
->driver_data
= NULL
;
1138 agdev
->out_ep
->driver_data
= NULL
;
1143 afunc_set_alt(struct usb_function
*fn
, unsigned intf
, unsigned alt
)
1145 struct usb_composite_dev
*cdev
= fn
->config
->cdev
;
1146 struct audio_dev
*agdev
= func_to_agdev(fn
);
1147 struct snd_uac2_chip
*uac2
= &agdev
->uac2
;
1148 struct usb_gadget
*gadget
= cdev
->gadget
;
1149 struct device
*dev
= &uac2
->pdev
.dev
;
1150 struct usb_request
*req
;
1152 struct uac2_rtd_params
*prm
;
1155 /* No i/f has more than 2 alt settings */
1157 dev_err(dev
, "%s:%d Error!\n", __func__
, __LINE__
);
1161 if (intf
== agdev
->ac_intf
) {
1162 /* Control I/f has only 1 AltSetting - 0 */
1164 dev_err(dev
, "%s:%d Error!\n", __func__
, __LINE__
);
1170 if (intf
== agdev
->as_out_intf
) {
1173 config_ep_by_speed(gadget
, fn
, ep
);
1174 agdev
->as_out_alt
= alt
;
1175 req_len
= prm
->max_psize
;
1176 } else if (intf
== agdev
->as_in_intf
) {
1177 struct f_uac2_opts
*opts
= agdev_to_uac2_opts(agdev
);
1178 unsigned int factor
, rate
;
1179 struct usb_endpoint_descriptor
*ep_desc
;
1183 config_ep_by_speed(gadget
, fn
, ep
);
1184 agdev
->as_in_alt
= alt
;
1186 /* pre-calculate the playback endpoint's interval */
1187 if (gadget
->speed
== USB_SPEED_FULL
) {
1188 ep_desc
= &fs_epin_desc
;
1191 ep_desc
= &hs_epin_desc
;
1195 /* pre-compute some values for iso_complete() */
1196 uac2
->p_framesize
= opts
->p_ssize
*
1197 num_channels(opts
->p_chmask
);
1198 rate
= opts
->p_srate
* uac2
->p_framesize
;
1199 uac2
->p_interval
= factor
/ (1 << (ep_desc
->bInterval
- 1));
1200 uac2
->p_pktsize
= min_t(unsigned int, rate
/ uac2
->p_interval
,
1203 if (uac2
->p_pktsize
< prm
->max_psize
)
1204 uac2
->p_pktsize_residue
= rate
% uac2
->p_interval
;
1206 uac2
->p_pktsize_residue
= 0;
1208 req_len
= uac2
->p_pktsize
;
1209 uac2
->p_residue
= 0;
1211 dev_err(dev
, "%s:%d Error!\n", __func__
, __LINE__
);
1220 prm
->ep_enabled
= true;
1223 for (i
= 0; i
< USB_XFERS
; i
++) {
1224 if (!prm
->ureq
[i
].req
) {
1225 req
= usb_ep_alloc_request(ep
, GFP_ATOMIC
);
1229 prm
->ureq
[i
].req
= req
;
1230 prm
->ureq
[i
].pp
= prm
;
1233 req
->context
= &prm
->ureq
[i
];
1234 req
->length
= req_len
;
1235 req
->complete
= agdev_iso_complete
;
1236 req
->buf
= prm
->rbuf
+ i
* prm
->max_psize
;
1239 if (usb_ep_queue(ep
, prm
->ureq
[i
].req
, GFP_ATOMIC
))
1240 dev_err(dev
, "%s:%d Error!\n", __func__
, __LINE__
);
1247 afunc_get_alt(struct usb_function
*fn
, unsigned intf
)
1249 struct audio_dev
*agdev
= func_to_agdev(fn
);
1250 struct snd_uac2_chip
*uac2
= &agdev
->uac2
;
1252 if (intf
== agdev
->ac_intf
)
1253 return agdev
->ac_alt
;
1254 else if (intf
== agdev
->as_out_intf
)
1255 return agdev
->as_out_alt
;
1256 else if (intf
== agdev
->as_in_intf
)
1257 return agdev
->as_in_alt
;
1259 dev_err(&uac2
->pdev
.dev
,
1260 "%s:%d Invalid Interface %d!\n",
1261 __func__
, __LINE__
, intf
);
1267 afunc_disable(struct usb_function
*fn
)
1269 struct audio_dev
*agdev
= func_to_agdev(fn
);
1270 struct snd_uac2_chip
*uac2
= &agdev
->uac2
;
1272 free_ep(&uac2
->p_prm
, agdev
->in_ep
);
1273 agdev
->as_in_alt
= 0;
1275 free_ep(&uac2
->c_prm
, agdev
->out_ep
);
1276 agdev
->as_out_alt
= 0;
1280 in_rq_cur(struct usb_function
*fn
, const struct usb_ctrlrequest
*cr
)
1282 struct usb_request
*req
= fn
->config
->cdev
->req
;
1283 struct audio_dev
*agdev
= func_to_agdev(fn
);
1284 struct snd_uac2_chip
*uac2
= &agdev
->uac2
;
1285 struct f_uac2_opts
*opts
;
1286 u16 w_length
= le16_to_cpu(cr
->wLength
);
1287 u16 w_index
= le16_to_cpu(cr
->wIndex
);
1288 u16 w_value
= le16_to_cpu(cr
->wValue
);
1289 u8 entity_id
= (w_index
>> 8) & 0xff;
1290 u8 control_selector
= w_value
>> 8;
1291 int value
= -EOPNOTSUPP
;
1292 int p_srate
, c_srate
;
1294 opts
= agdev_to_uac2_opts(agdev
);
1295 p_srate
= opts
->p_srate
;
1296 c_srate
= opts
->c_srate
;
1298 if (control_selector
== UAC2_CS_CONTROL_SAM_FREQ
) {
1299 struct cntrl_cur_lay3 c
;
1301 if (entity_id
== USB_IN_CLK_ID
)
1303 else if (entity_id
== USB_OUT_CLK_ID
)
1306 value
= min_t(unsigned, w_length
, sizeof c
);
1307 memcpy(req
->buf
, &c
, value
);
1308 } else if (control_selector
== UAC2_CS_CONTROL_CLOCK_VALID
) {
1309 *(u8
*)req
->buf
= 1;
1310 value
= min_t(unsigned, w_length
, 1);
1312 dev_err(&uac2
->pdev
.dev
,
1313 "%s:%d control_selector=%d TODO!\n",
1314 __func__
, __LINE__
, control_selector
);
1321 in_rq_range(struct usb_function
*fn
, const struct usb_ctrlrequest
*cr
)
1323 struct usb_request
*req
= fn
->config
->cdev
->req
;
1324 struct audio_dev
*agdev
= func_to_agdev(fn
);
1325 struct snd_uac2_chip
*uac2
= &agdev
->uac2
;
1326 struct f_uac2_opts
*opts
;
1327 u16 w_length
= le16_to_cpu(cr
->wLength
);
1328 u16 w_index
= le16_to_cpu(cr
->wIndex
);
1329 u16 w_value
= le16_to_cpu(cr
->wValue
);
1330 u8 entity_id
= (w_index
>> 8) & 0xff;
1331 u8 control_selector
= w_value
>> 8;
1332 struct cntrl_range_lay3 r
;
1333 int value
= -EOPNOTSUPP
;
1334 int p_srate
, c_srate
;
1336 opts
= agdev_to_uac2_opts(agdev
);
1337 p_srate
= opts
->p_srate
;
1338 c_srate
= opts
->c_srate
;
1340 if (control_selector
== UAC2_CS_CONTROL_SAM_FREQ
) {
1341 if (entity_id
== USB_IN_CLK_ID
)
1343 else if (entity_id
== USB_OUT_CLK_ID
)
1350 r
.wNumSubRanges
= 1;
1352 value
= min_t(unsigned, w_length
, sizeof r
);
1353 memcpy(req
->buf
, &r
, value
);
1355 dev_err(&uac2
->pdev
.dev
,
1356 "%s:%d control_selector=%d TODO!\n",
1357 __func__
, __LINE__
, control_selector
);
1364 ac_rq_in(struct usb_function
*fn
, const struct usb_ctrlrequest
*cr
)
1366 if (cr
->bRequest
== UAC2_CS_CUR
)
1367 return in_rq_cur(fn
, cr
);
1368 else if (cr
->bRequest
== UAC2_CS_RANGE
)
1369 return in_rq_range(fn
, cr
);
1375 out_rq_cur(struct usb_function
*fn
, const struct usb_ctrlrequest
*cr
)
1377 u16 w_length
= le16_to_cpu(cr
->wLength
);
1378 u16 w_value
= le16_to_cpu(cr
->wValue
);
1379 u8 control_selector
= w_value
>> 8;
1381 if (control_selector
== UAC2_CS_CONTROL_SAM_FREQ
)
1388 setup_rq_inf(struct usb_function
*fn
, const struct usb_ctrlrequest
*cr
)
1390 struct audio_dev
*agdev
= func_to_agdev(fn
);
1391 struct snd_uac2_chip
*uac2
= &agdev
->uac2
;
1392 u16 w_index
= le16_to_cpu(cr
->wIndex
);
1393 u8 intf
= w_index
& 0xff;
1395 if (intf
!= agdev
->ac_intf
) {
1396 dev_err(&uac2
->pdev
.dev
,
1397 "%s:%d Error!\n", __func__
, __LINE__
);
1401 if (cr
->bRequestType
& USB_DIR_IN
)
1402 return ac_rq_in(fn
, cr
);
1403 else if (cr
->bRequest
== UAC2_CS_CUR
)
1404 return out_rq_cur(fn
, cr
);
1410 afunc_setup(struct usb_function
*fn
, const struct usb_ctrlrequest
*cr
)
1412 struct usb_composite_dev
*cdev
= fn
->config
->cdev
;
1413 struct audio_dev
*agdev
= func_to_agdev(fn
);
1414 struct snd_uac2_chip
*uac2
= &agdev
->uac2
;
1415 struct usb_request
*req
= cdev
->req
;
1416 u16 w_length
= le16_to_cpu(cr
->wLength
);
1417 int value
= -EOPNOTSUPP
;
1419 /* Only Class specific requests are supposed to reach here */
1420 if ((cr
->bRequestType
& USB_TYPE_MASK
) != USB_TYPE_CLASS
)
1423 if ((cr
->bRequestType
& USB_RECIP_MASK
) == USB_RECIP_INTERFACE
)
1424 value
= setup_rq_inf(fn
, cr
);
1426 dev_err(&uac2
->pdev
.dev
, "%s:%d Error!\n", __func__
, __LINE__
);
1429 req
->length
= value
;
1430 req
->zero
= value
< w_length
;
1431 value
= usb_ep_queue(cdev
->gadget
->ep0
, req
, GFP_ATOMIC
);
1433 dev_err(&uac2
->pdev
.dev
,
1434 "%s:%d Error!\n", __func__
, __LINE__
);
1442 static inline struct f_uac2_opts
*to_f_uac2_opts(struct config_item
*item
)
1444 return container_of(to_config_group(item
), struct f_uac2_opts
,
1448 CONFIGFS_ATTR_STRUCT(f_uac2_opts
);
1449 CONFIGFS_ATTR_OPS(f_uac2_opts
);
1451 static void f_uac2_attr_release(struct config_item
*item
)
1453 struct f_uac2_opts
*opts
= to_f_uac2_opts(item
);
1455 usb_put_function_instance(&opts
->func_inst
);
1458 static struct configfs_item_operations f_uac2_item_ops
= {
1459 .release
= f_uac2_attr_release
,
1460 .show_attribute
= f_uac2_opts_attr_show
,
1461 .store_attribute
= f_uac2_opts_attr_store
,
1464 #define UAC2_ATTRIBUTE(name) \
1465 static ssize_t f_uac2_opts_##name##_show(struct f_uac2_opts *opts, \
1470 mutex_lock(&opts->lock); \
1471 result = sprintf(page, "%u\n", opts->name); \
1472 mutex_unlock(&opts->lock); \
1477 static ssize_t f_uac2_opts_##name##_store(struct f_uac2_opts *opts, \
1478 const char *page, size_t len) \
1483 mutex_lock(&opts->lock); \
1484 if (opts->refcnt) { \
1489 ret = kstrtou32(page, 0, &num); \
1497 mutex_unlock(&opts->lock); \
1501 static struct f_uac2_opts_attribute f_uac2_opts_##name = \
1502 __CONFIGFS_ATTR(name, S_IRUGO | S_IWUSR, \
1503 f_uac2_opts_##name##_show, \
1504 f_uac2_opts_##name##_store)
1506 UAC2_ATTRIBUTE(p_chmask
);
1507 UAC2_ATTRIBUTE(p_srate
);
1508 UAC2_ATTRIBUTE(p_ssize
);
1509 UAC2_ATTRIBUTE(c_chmask
);
1510 UAC2_ATTRIBUTE(c_srate
);
1511 UAC2_ATTRIBUTE(c_ssize
);
1513 static struct configfs_attribute
*f_uac2_attrs
[] = {
1514 &f_uac2_opts_p_chmask
.attr
,
1515 &f_uac2_opts_p_srate
.attr
,
1516 &f_uac2_opts_p_ssize
.attr
,
1517 &f_uac2_opts_c_chmask
.attr
,
1518 &f_uac2_opts_c_srate
.attr
,
1519 &f_uac2_opts_c_ssize
.attr
,
1523 static struct config_item_type f_uac2_func_type
= {
1524 .ct_item_ops
= &f_uac2_item_ops
,
1525 .ct_attrs
= f_uac2_attrs
,
1526 .ct_owner
= THIS_MODULE
,
1529 static void afunc_free_inst(struct usb_function_instance
*f
)
1531 struct f_uac2_opts
*opts
;
1533 opts
= container_of(f
, struct f_uac2_opts
, func_inst
);
1537 static struct usb_function_instance
*afunc_alloc_inst(void)
1539 struct f_uac2_opts
*opts
;
1541 opts
= kzalloc(sizeof(*opts
), GFP_KERNEL
);
1543 return ERR_PTR(-ENOMEM
);
1545 mutex_init(&opts
->lock
);
1546 opts
->func_inst
.free_func_inst
= afunc_free_inst
;
1548 config_group_init_type_name(&opts
->func_inst
.group
, "",
1551 opts
->p_chmask
= UAC2_DEF_PCHMASK
;
1552 opts
->p_srate
= UAC2_DEF_PSRATE
;
1553 opts
->p_ssize
= UAC2_DEF_PSSIZE
;
1554 opts
->c_chmask
= UAC2_DEF_CCHMASK
;
1555 opts
->c_srate
= UAC2_DEF_CSRATE
;
1556 opts
->c_ssize
= UAC2_DEF_CSSIZE
;
1557 return &opts
->func_inst
;
1560 static void afunc_free(struct usb_function
*f
)
1562 struct audio_dev
*agdev
;
1563 struct f_uac2_opts
*opts
;
1565 agdev
= func_to_agdev(f
);
1566 opts
= container_of(f
->fi
, struct f_uac2_opts
, func_inst
);
1568 mutex_lock(&opts
->lock
);
1570 mutex_unlock(&opts
->lock
);
1573 static void afunc_unbind(struct usb_configuration
*c
, struct usb_function
*f
)
1575 struct audio_dev
*agdev
= func_to_agdev(f
);
1576 struct uac2_rtd_params
*prm
;
1578 alsa_uac2_exit(agdev
);
1580 prm
= &agdev
->uac2
.p_prm
;
1583 prm
= &agdev
->uac2
.c_prm
;
1585 usb_free_all_descriptors(f
);
1588 agdev
->in_ep
->driver_data
= NULL
;
1590 agdev
->out_ep
->driver_data
= NULL
;
1593 static struct usb_function
*afunc_alloc(struct usb_function_instance
*fi
)
1595 struct audio_dev
*agdev
;
1596 struct f_uac2_opts
*opts
;
1598 agdev
= kzalloc(sizeof(*agdev
), GFP_KERNEL
);
1600 return ERR_PTR(-ENOMEM
);
1602 opts
= container_of(fi
, struct f_uac2_opts
, func_inst
);
1603 mutex_lock(&opts
->lock
);
1605 mutex_unlock(&opts
->lock
);
1607 agdev
->func
.name
= "uac2_func";
1608 agdev
->func
.bind
= afunc_bind
;
1609 agdev
->func
.unbind
= afunc_unbind
;
1610 agdev
->func
.set_alt
= afunc_set_alt
;
1611 agdev
->func
.get_alt
= afunc_get_alt
;
1612 agdev
->func
.disable
= afunc_disable
;
1613 agdev
->func
.setup
= afunc_setup
;
1614 agdev
->func
.free_func
= afunc_free
;
1616 return &agdev
->func
;
1619 DECLARE_USB_FUNCTION_INIT(uac2
, afunc_alloc_inst
, afunc_alloc
);
1620 MODULE_LICENSE("GPL");
1621 MODULE_AUTHOR("Yadwinder Singh");
1622 MODULE_AUTHOR("Jaswinder Singh");