1 // SPDX-License-Identifier: GPL-2.0-or-later
6 #include <linux/init.h>
7 #include <linux/slab.h>
9 #include <linux/usb/audio.h>
10 #include <linux/usb/audio-v2.h>
11 #include <linux/usb/audio-v3.h>
13 #include <sound/core.h>
14 #include <sound/pcm.h>
15 #include <sound/control.h>
16 #include <sound/tlv.h>
31 static void audioformat_free(struct audioformat
*fp
)
33 list_del(&fp
->list
); /* unlink for avoiding double-free */
34 kfree(fp
->rate_table
);
42 static void free_substream(struct snd_usb_substream
*subs
)
44 struct audioformat
*fp
, *n
;
46 if (!subs
->num_formats
)
47 return; /* not initialized */
48 list_for_each_entry_safe(fp
, n
, &subs
->fmt_list
, list
)
51 snd_media_stream_delete(subs
);
56 * free a usb stream instance
58 static void snd_usb_audio_stream_free(struct snd_usb_stream
*stream
)
60 free_substream(&stream
->substream
[0]);
61 free_substream(&stream
->substream
[1]);
62 list_del(&stream
->list
);
66 static void snd_usb_audio_pcm_free(struct snd_pcm
*pcm
)
68 struct snd_usb_stream
*stream
= pcm
->private_data
;
71 snd_usb_audio_stream_free(stream
);
76 * initialize the substream instance.
79 static void snd_usb_init_substream(struct snd_usb_stream
*as
,
81 struct audioformat
*fp
,
82 struct snd_usb_power_domain
*pd
)
84 struct snd_usb_substream
*subs
= &as
->substream
[stream
];
86 INIT_LIST_HEAD(&subs
->fmt_list
);
87 spin_lock_init(&subs
->lock
);
90 subs
->direction
= stream
;
91 subs
->dev
= as
->chip
->dev
;
92 subs
->txfr_quirk
= !!(as
->chip
->quirk_flags
& QUIRK_FLAG_ALIGN_TRANSFER
);
93 subs
->tx_length_quirk
= !!(as
->chip
->quirk_flags
& QUIRK_FLAG_TX_LENGTH
);
94 subs
->speed
= snd_usb_get_speed(subs
->dev
);
95 subs
->pkt_offset_adj
= 0;
96 subs
->stream_offset_adj
= 0;
98 snd_usb_set_pcm_ops(as
->pcm
, stream
);
100 list_add_tail(&fp
->list
, &subs
->fmt_list
);
101 subs
->formats
|= fp
->formats
;
103 subs
->fmt_type
= fp
->fmt_type
;
104 subs
->ep_num
= fp
->endpoint
;
105 if (fp
->channels
> subs
->channels_max
)
106 subs
->channels_max
= fp
->channels
;
110 /* Initialize Power Domain to idle status D1 */
111 snd_usb_power_domain_set(subs
->stream
->chip
, pd
,
115 snd_usb_preallocate_buffer(subs
);
118 /* kctl callbacks for usb-audio channel maps */
119 static int usb_chmap_ctl_info(struct snd_kcontrol
*kcontrol
,
120 struct snd_ctl_elem_info
*uinfo
)
122 struct snd_pcm_chmap
*info
= snd_kcontrol_chip(kcontrol
);
123 struct snd_usb_substream
*subs
= info
->private_data
;
125 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
126 uinfo
->count
= subs
->channels_max
;
127 uinfo
->value
.integer
.min
= 0;
128 uinfo
->value
.integer
.max
= SNDRV_CHMAP_LAST
;
132 /* check whether a duplicated entry exists in the audiofmt list */
133 static bool have_dup_chmap(struct snd_usb_substream
*subs
,
134 struct audioformat
*fp
)
136 struct audioformat
*prev
= fp
;
138 list_for_each_entry_continue_reverse(prev
, &subs
->fmt_list
, list
) {
140 !memcmp(prev
->chmap
, fp
->chmap
, sizeof(*fp
->chmap
)))
146 static int usb_chmap_ctl_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
147 unsigned int size
, unsigned int __user
*tlv
)
149 struct snd_pcm_chmap
*info
= snd_kcontrol_chip(kcontrol
);
150 struct snd_usb_substream
*subs
= info
->private_data
;
151 struct audioformat
*fp
;
152 unsigned int __user
*dst
;
157 if (put_user(SNDRV_CTL_TLVT_CONTAINER
, tlv
))
161 list_for_each_entry(fp
, &subs
->fmt_list
, list
) {
166 if (have_dup_chmap(subs
, fp
))
169 ch_bytes
= fp
->chmap
->channels
* 4;
170 if (size
< 8 + ch_bytes
)
172 if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED
, dst
) ||
173 put_user(ch_bytes
, dst
+ 1))
176 for (i
= 0; i
< fp
->chmap
->channels
; i
++, dst
++) {
177 if (put_user(fp
->chmap
->map
[i
], dst
))
181 count
+= 8 + ch_bytes
;
182 size
-= 8 + ch_bytes
;
184 if (put_user(count
, tlv
+ 1))
189 static int usb_chmap_ctl_get(struct snd_kcontrol
*kcontrol
,
190 struct snd_ctl_elem_value
*ucontrol
)
192 struct snd_pcm_chmap
*info
= snd_kcontrol_chip(kcontrol
);
193 struct snd_usb_substream
*subs
= info
->private_data
;
194 struct snd_pcm_chmap_elem
*chmap
= NULL
;
197 if (subs
->cur_audiofmt
)
198 chmap
= subs
->cur_audiofmt
->chmap
;
200 for (i
= 0; i
< chmap
->channels
; i
++)
201 ucontrol
->value
.integer
.value
[i
] = chmap
->map
[i
];
203 for (; i
< subs
->channels_max
; i
++)
204 ucontrol
->value
.integer
.value
[i
] = 0;
208 /* create a chmap kctl assigned to the given USB substream */
209 static int add_chmap(struct snd_pcm
*pcm
, int stream
,
210 struct snd_usb_substream
*subs
)
212 struct audioformat
*fp
;
213 struct snd_pcm_chmap
*chmap
;
214 struct snd_kcontrol
*kctl
;
217 list_for_each_entry(fp
, &subs
->fmt_list
, list
)
220 /* no chmap is found */
224 err
= snd_pcm_add_chmap_ctls(pcm
, stream
, NULL
, 0, 0, &chmap
);
228 /* override handlers */
229 chmap
->private_data
= subs
;
231 kctl
->info
= usb_chmap_ctl_info
;
232 kctl
->get
= usb_chmap_ctl_get
;
233 kctl
->tlv
.c
= usb_chmap_ctl_tlv
;
238 /* convert from USB ChannelConfig bits to ALSA chmap element */
239 static struct snd_pcm_chmap_elem
*convert_chmap(int channels
, unsigned int bits
,
242 static const unsigned int uac1_maps
[] = {
243 SNDRV_CHMAP_FL
, /* left front */
244 SNDRV_CHMAP_FR
, /* right front */
245 SNDRV_CHMAP_FC
, /* center front */
246 SNDRV_CHMAP_LFE
, /* LFE */
247 SNDRV_CHMAP_SL
, /* left surround */
248 SNDRV_CHMAP_SR
, /* right surround */
249 SNDRV_CHMAP_FLC
, /* left of center */
250 SNDRV_CHMAP_FRC
, /* right of center */
251 SNDRV_CHMAP_RC
, /* surround */
252 SNDRV_CHMAP_SL
, /* side left */
253 SNDRV_CHMAP_SR
, /* side right */
254 SNDRV_CHMAP_TC
, /* top */
257 static const unsigned int uac2_maps
[] = {
258 SNDRV_CHMAP_FL
, /* front left */
259 SNDRV_CHMAP_FR
, /* front right */
260 SNDRV_CHMAP_FC
, /* front center */
261 SNDRV_CHMAP_LFE
, /* LFE */
262 SNDRV_CHMAP_RL
, /* back left */
263 SNDRV_CHMAP_RR
, /* back right */
264 SNDRV_CHMAP_FLC
, /* front left of center */
265 SNDRV_CHMAP_FRC
, /* front right of center */
266 SNDRV_CHMAP_RC
, /* back center */
267 SNDRV_CHMAP_SL
, /* side left */
268 SNDRV_CHMAP_SR
, /* side right */
269 SNDRV_CHMAP_TC
, /* top center */
270 SNDRV_CHMAP_TFL
, /* top front left */
271 SNDRV_CHMAP_TFC
, /* top front center */
272 SNDRV_CHMAP_TFR
, /* top front right */
273 SNDRV_CHMAP_TRL
, /* top back left */
274 SNDRV_CHMAP_TRC
, /* top back center */
275 SNDRV_CHMAP_TRR
, /* top back right */
276 SNDRV_CHMAP_TFLC
, /* top front left of center */
277 SNDRV_CHMAP_TFRC
, /* top front right of center */
278 SNDRV_CHMAP_LLFE
, /* left LFE */
279 SNDRV_CHMAP_RLFE
, /* right LFE */
280 SNDRV_CHMAP_TSL
, /* top side left */
281 SNDRV_CHMAP_TSR
, /* top side right */
282 SNDRV_CHMAP_BC
, /* bottom center */
283 SNDRV_CHMAP_RLC
, /* back left of center */
284 SNDRV_CHMAP_RRC
, /* back right of center */
287 struct snd_pcm_chmap_elem
*chmap
;
288 const unsigned int *maps
;
291 if (channels
> ARRAY_SIZE(chmap
->map
))
294 chmap
= kzalloc(sizeof(*chmap
), GFP_KERNEL
);
298 maps
= protocol
== UAC_VERSION_2
? uac2_maps
: uac1_maps
;
299 chmap
->channels
= channels
;
303 for (; bits
&& *maps
; maps
++, bits
>>= 1)
305 chmap
->map
[c
++] = *maps
;
307 /* If we're missing wChannelConfig, then guess something
308 to make sure the channel map is not skipped entirely */
310 chmap
->map
[c
++] = SNDRV_CHMAP_MONO
;
312 for (; c
< channels
&& *maps
; maps
++)
313 chmap
->map
[c
++] = *maps
;
316 for (; c
< channels
; c
++)
317 chmap
->map
[c
] = SNDRV_CHMAP_UNKNOWN
;
322 /* UAC3 device stores channels information in Cluster Descriptors */
324 snd_pcm_chmap_elem
*convert_chmap_v3(struct uac3_cluster_header_descriptor
327 unsigned int channels
= cluster
->bNrChannels
;
328 struct snd_pcm_chmap_elem
*chmap
;
332 if (channels
> ARRAY_SIZE(chmap
->map
))
335 chmap
= kzalloc(sizeof(*chmap
), GFP_KERNEL
);
339 len
= le16_to_cpu(cluster
->wLength
);
341 p
+= sizeof(struct uac3_cluster_header_descriptor
);
343 while (((p
- (void *)cluster
) < len
) && (c
< channels
)) {
344 struct uac3_cluster_segment_descriptor
*cs_desc
= p
;
348 cs_len
= le16_to_cpu(cs_desc
->wLength
);
349 cs_type
= cs_desc
->bSegmentType
;
351 if (cs_type
== UAC3_CHANNEL_INFORMATION
) {
352 struct uac3_cluster_information_segment_descriptor
*is
= p
;
356 * TODO: this conversion is not complete, update it
357 * after adding UAC3 values to asound.h
359 switch (is
->bChRelationship
) {
361 map
= SNDRV_CHMAP_MONO
;
364 case UAC3_CH_FRONT_LEFT
:
365 case UAC3_CH_HEADPHONE_LEFT
:
366 map
= SNDRV_CHMAP_FL
;
369 case UAC3_CH_FRONT_RIGHT
:
370 case UAC3_CH_HEADPHONE_RIGHT
:
371 map
= SNDRV_CHMAP_FR
;
373 case UAC3_CH_FRONT_CENTER
:
374 map
= SNDRV_CHMAP_FC
;
376 case UAC3_CH_FRONT_LEFT_OF_CENTER
:
377 map
= SNDRV_CHMAP_FLC
;
379 case UAC3_CH_FRONT_RIGHT_OF_CENTER
:
380 map
= SNDRV_CHMAP_FRC
;
382 case UAC3_CH_SIDE_LEFT
:
383 map
= SNDRV_CHMAP_SL
;
385 case UAC3_CH_SIDE_RIGHT
:
386 map
= SNDRV_CHMAP_SR
;
388 case UAC3_CH_BACK_LEFT
:
389 map
= SNDRV_CHMAP_RL
;
391 case UAC3_CH_BACK_RIGHT
:
392 map
= SNDRV_CHMAP_RR
;
394 case UAC3_CH_BACK_CENTER
:
395 map
= SNDRV_CHMAP_RC
;
397 case UAC3_CH_BACK_LEFT_OF_CENTER
:
398 map
= SNDRV_CHMAP_RLC
;
400 case UAC3_CH_BACK_RIGHT_OF_CENTER
:
401 map
= SNDRV_CHMAP_RRC
;
403 case UAC3_CH_TOP_CENTER
:
404 map
= SNDRV_CHMAP_TC
;
406 case UAC3_CH_TOP_FRONT_LEFT
:
407 map
= SNDRV_CHMAP_TFL
;
409 case UAC3_CH_TOP_FRONT_RIGHT
:
410 map
= SNDRV_CHMAP_TFR
;
412 case UAC3_CH_TOP_FRONT_CENTER
:
413 map
= SNDRV_CHMAP_TFC
;
415 case UAC3_CH_TOP_FRONT_LOC
:
416 map
= SNDRV_CHMAP_TFLC
;
418 case UAC3_CH_TOP_FRONT_ROC
:
419 map
= SNDRV_CHMAP_TFRC
;
421 case UAC3_CH_TOP_SIDE_LEFT
:
422 map
= SNDRV_CHMAP_TSL
;
424 case UAC3_CH_TOP_SIDE_RIGHT
:
425 map
= SNDRV_CHMAP_TSR
;
427 case UAC3_CH_TOP_BACK_LEFT
:
428 map
= SNDRV_CHMAP_TRL
;
430 case UAC3_CH_TOP_BACK_RIGHT
:
431 map
= SNDRV_CHMAP_TRR
;
433 case UAC3_CH_TOP_BACK_CENTER
:
434 map
= SNDRV_CHMAP_TRC
;
436 case UAC3_CH_BOTTOM_CENTER
:
437 map
= SNDRV_CHMAP_BC
;
439 case UAC3_CH_LOW_FREQUENCY_EFFECTS
:
440 map
= SNDRV_CHMAP_LFE
;
442 case UAC3_CH_LFE_LEFT
:
443 map
= SNDRV_CHMAP_LLFE
;
445 case UAC3_CH_LFE_RIGHT
:
446 map
= SNDRV_CHMAP_RLFE
;
448 case UAC3_CH_RELATIONSHIP_UNDEFINED
:
450 map
= SNDRV_CHMAP_UNKNOWN
;
453 chmap
->map
[c
++] = map
;
459 pr_err("%s: channel number mismatch\n", __func__
);
461 chmap
->channels
= channels
;
463 for (; c
< channels
; c
++)
464 chmap
->map
[c
] = SNDRV_CHMAP_UNKNOWN
;
470 * add this endpoint to the chip instance.
471 * if a stream with the same endpoint already exists, append to it.
472 * if not, create a new pcm stream. note, fp is added to the substream
473 * fmt_list and will be freed on the chip instance release. do not free
474 * fp or do remove it from the substream fmt_list to avoid double-free.
476 static int __snd_usb_add_audio_stream(struct snd_usb_audio
*chip
,
478 struct audioformat
*fp
,
479 struct snd_usb_power_domain
*pd
)
482 struct snd_usb_stream
*as
;
483 struct snd_usb_substream
*subs
;
487 list_for_each_entry(as
, &chip
->pcm_list
, list
) {
488 if (as
->fmt_type
!= fp
->fmt_type
)
490 subs
= &as
->substream
[stream
];
491 if (subs
->ep_num
== fp
->endpoint
) {
492 list_add_tail(&fp
->list
, &subs
->fmt_list
);
494 subs
->formats
|= fp
->formats
;
499 if (chip
->card
->registered
)
500 chip
->need_delayed_register
= true;
502 /* look for an empty stream */
503 list_for_each_entry(as
, &chip
->pcm_list
, list
) {
504 if (as
->fmt_type
!= fp
->fmt_type
)
506 subs
= &as
->substream
[stream
];
509 err
= snd_pcm_new_stream(as
->pcm
, stream
, 1);
512 snd_usb_init_substream(as
, stream
, fp
, pd
);
513 return add_chmap(as
->pcm
, stream
, subs
);
516 /* create a new pcm */
517 as
= kzalloc(sizeof(*as
), GFP_KERNEL
);
520 as
->pcm_index
= chip
->pcm_devs
;
522 as
->fmt_type
= fp
->fmt_type
;
523 err
= snd_pcm_new(chip
->card
, "USB Audio", chip
->pcm_devs
,
524 stream
== SNDRV_PCM_STREAM_PLAYBACK
? 1 : 0,
525 stream
== SNDRV_PCM_STREAM_PLAYBACK
? 0 : 1,
532 pcm
->private_data
= as
;
533 pcm
->private_free
= snd_usb_audio_pcm_free
;
535 if (chip
->pcm_devs
> 0)
536 sprintf(pcm
->name
, "USB Audio #%d", chip
->pcm_devs
);
538 strcpy(pcm
->name
, "USB Audio");
540 snd_usb_init_substream(as
, stream
, fp
, pd
);
543 * Keep using head insertion for M-Audio Audiophile USB (tm) which has a
544 * fix to swap capture stream order in conf/cards/USB-audio.conf
546 if (chip
->usb_id
== USB_ID(0x0763, 0x2003))
547 list_add(&as
->list
, &chip
->pcm_list
);
549 list_add_tail(&as
->list
, &chip
->pcm_list
);
553 snd_usb_proc_pcm_format_add(as
);
555 return add_chmap(pcm
, stream
, &as
->substream
[stream
]);
558 int snd_usb_add_audio_stream(struct snd_usb_audio
*chip
,
560 struct audioformat
*fp
)
562 return __snd_usb_add_audio_stream(chip
, stream
, fp
, NULL
);
565 static int snd_usb_add_audio_stream_v3(struct snd_usb_audio
*chip
,
567 struct audioformat
*fp
,
568 struct snd_usb_power_domain
*pd
)
570 return __snd_usb_add_audio_stream(chip
, stream
, fp
, pd
);
573 static int parse_uac_endpoint_attributes(struct snd_usb_audio
*chip
,
574 struct usb_host_interface
*alts
,
575 int protocol
, int iface_no
)
577 /* parsed with a v1 header here. that's ok as we only look at the
578 * header first which is the same for both versions */
579 struct uac_iso_endpoint_descriptor
*csep
;
580 struct usb_interface_descriptor
*altsd
= get_iface_desc(alts
);
583 csep
= snd_usb_find_desc(alts
->endpoint
[0].extra
, alts
->endpoint
[0].extralen
, NULL
, USB_DT_CS_ENDPOINT
);
585 /* Creamware Noah has this descriptor after the 2nd endpoint */
586 if (!csep
&& altsd
->bNumEndpoints
>= 2)
587 csep
= snd_usb_find_desc(alts
->endpoint
[1].extra
, alts
->endpoint
[1].extralen
, NULL
, USB_DT_CS_ENDPOINT
);
590 * If we can't locate the USB_DT_CS_ENDPOINT descriptor in the extra
591 * bytes after the first endpoint, go search the entire interface.
592 * Some devices have it directly *before* the standard endpoint.
595 csep
= snd_usb_find_desc(alts
->extra
, alts
->extralen
, NULL
, USB_DT_CS_ENDPOINT
);
597 if (!csep
|| csep
->bLength
< 7 ||
598 csep
->bDescriptorSubtype
!= UAC_EP_GENERAL
)
601 if (protocol
== UAC_VERSION_1
) {
602 attributes
= csep
->bmAttributes
;
603 } else if (protocol
== UAC_VERSION_2
) {
604 struct uac2_iso_endpoint_descriptor
*csep2
=
605 (struct uac2_iso_endpoint_descriptor
*) csep
;
607 if (csep2
->bLength
< sizeof(*csep2
))
609 attributes
= csep
->bmAttributes
& UAC_EP_CS_ATTR_FILL_MAX
;
611 /* emulate the endpoint attributes of a v1 device */
612 if (csep2
->bmControls
& UAC2_CONTROL_PITCH
)
613 attributes
|= UAC_EP_CS_ATTR_PITCH_CONTROL
;
614 } else { /* UAC_VERSION_3 */
615 struct uac3_iso_endpoint_descriptor
*csep3
=
616 (struct uac3_iso_endpoint_descriptor
*) csep
;
618 if (csep3
->bLength
< sizeof(*csep3
))
620 /* emulate the endpoint attributes of a v1 device */
621 if (le32_to_cpu(csep3
->bmControls
) & UAC2_CONTROL_PITCH
)
622 attributes
|= UAC_EP_CS_ATTR_PITCH_CONTROL
;
629 "%u:%d : no or invalid class specific endpoint descriptor\n",
630 iface_no
, altsd
->bAlternateSetting
);
634 /* find an input terminal descriptor (either UAC1 or UAC2) with the given
638 snd_usb_find_input_terminal_descriptor(struct usb_host_interface
*ctrl_iface
,
639 int terminal_id
, int protocol
)
641 struct uac2_input_terminal_descriptor
*term
= NULL
;
643 while ((term
= snd_usb_find_csint_desc(ctrl_iface
->extra
,
644 ctrl_iface
->extralen
,
645 term
, UAC_INPUT_TERMINAL
))) {
646 if (!snd_usb_validate_audio_desc(term
, protocol
))
648 if (term
->bTerminalID
== terminal_id
)
656 snd_usb_find_output_terminal_descriptor(struct usb_host_interface
*ctrl_iface
,
657 int terminal_id
, int protocol
)
659 /* OK to use with both UAC2 and UAC3 */
660 struct uac2_output_terminal_descriptor
*term
= NULL
;
662 while ((term
= snd_usb_find_csint_desc(ctrl_iface
->extra
,
663 ctrl_iface
->extralen
,
664 term
, UAC_OUTPUT_TERMINAL
))) {
665 if (!snd_usb_validate_audio_desc(term
, protocol
))
667 if (term
->bTerminalID
== terminal_id
)
674 static struct audioformat
*
675 audio_format_alloc_init(struct snd_usb_audio
*chip
,
676 struct usb_host_interface
*alts
,
677 int protocol
, int iface_no
, int altset_idx
,
678 int altno
, int num_channels
, int clock
)
680 struct audioformat
*fp
;
682 fp
= kzalloc(sizeof(*fp
), GFP_KERNEL
);
686 fp
->iface
= iface_no
;
687 fp
->altsetting
= altno
;
688 fp
->altset_idx
= altset_idx
;
689 fp
->endpoint
= get_endpoint(alts
, 0)->bEndpointAddress
;
690 fp
->ep_attr
= get_endpoint(alts
, 0)->bmAttributes
;
691 fp
->datainterval
= snd_usb_parse_datainterval(chip
, alts
);
692 fp
->protocol
= protocol
;
693 fp
->maxpacksize
= le16_to_cpu(get_endpoint(alts
, 0)->wMaxPacketSize
);
694 fp
->channels
= num_channels
;
695 if (snd_usb_get_speed(chip
->dev
) == USB_SPEED_HIGH
)
696 fp
->maxpacksize
= (((fp
->maxpacksize
>> 11) & 3) + 1)
697 * (fp
->maxpacksize
& 0x7ff);
699 INIT_LIST_HEAD(&fp
->list
);
704 static struct audioformat
*
705 snd_usb_get_audioformat_uac12(struct snd_usb_audio
*chip
,
706 struct usb_host_interface
*alts
,
707 int protocol
, int iface_no
, int altset_idx
,
708 int altno
, int stream
, int bm_quirk
)
710 struct usb_device
*dev
= chip
->dev
;
711 struct uac_format_type_i_continuous_descriptor
*fmt
;
712 unsigned int num_channels
= 0, chconfig
= 0;
713 struct audioformat
*fp
;
717 /* get audio formats */
718 if (protocol
== UAC_VERSION_1
) {
719 struct uac1_as_header_descriptor
*as
=
720 snd_usb_find_csint_desc(alts
->extra
, alts
->extralen
,
721 NULL
, UAC_AS_GENERAL
);
722 struct uac_input_terminal_descriptor
*iterm
;
726 "%u:%d : UAC_AS_GENERAL descriptor not found\n",
731 if (as
->bLength
< sizeof(*as
)) {
733 "%u:%d : invalid UAC_AS_GENERAL desc\n",
738 format
= le16_to_cpu(as
->wFormatTag
); /* remember the format value */
740 iterm
= snd_usb_find_input_terminal_descriptor(chip
->ctrl_intf
,
744 num_channels
= iterm
->bNrChannels
;
745 chconfig
= le16_to_cpu(iterm
->wChannelConfig
);
747 } else { /* UAC_VERSION_2 */
748 struct uac2_input_terminal_descriptor
*input_term
;
749 struct uac2_output_terminal_descriptor
*output_term
;
750 struct uac2_as_header_descriptor
*as
=
751 snd_usb_find_csint_desc(alts
->extra
, alts
->extralen
,
752 NULL
, UAC_AS_GENERAL
);
756 "%u:%d : UAC_AS_GENERAL descriptor not found\n",
761 if (as
->bLength
< sizeof(*as
)) {
763 "%u:%d : invalid UAC_AS_GENERAL desc\n",
768 num_channels
= as
->bNrChannels
;
769 format
= le32_to_cpu(as
->bmFormats
);
770 chconfig
= le32_to_cpu(as
->bmChannelConfig
);
773 * lookup the terminal associated to this interface
774 * to extract the clock
776 input_term
= snd_usb_find_input_terminal_descriptor(chip
->ctrl_intf
,
780 clock
= input_term
->bCSourceID
;
781 if (!chconfig
&& (num_channels
== input_term
->bNrChannels
))
782 chconfig
= le32_to_cpu(input_term
->bmChannelConfig
);
786 output_term
= snd_usb_find_output_terminal_descriptor(chip
->ctrl_intf
,
790 clock
= output_term
->bCSourceID
;
795 "%u:%d : bogus bTerminalLink %d\n",
796 iface_no
, altno
, as
->bTerminalLink
);
801 /* get format type */
802 fmt
= snd_usb_find_csint_desc(alts
->extra
, alts
->extralen
,
803 NULL
, UAC_FORMAT_TYPE
);
806 "%u:%d : no UAC_FORMAT_TYPE desc\n",
810 if (((protocol
== UAC_VERSION_1
) && (fmt
->bLength
< 8))
811 || ((protocol
== UAC_VERSION_2
) &&
812 (fmt
->bLength
< 6))) {
814 "%u:%d : invalid UAC_FORMAT_TYPE desc\n",
820 * Blue Microphones workaround: The last altsetting is
821 * identical with the previous one, except for a larger
822 * packet size, but is actually a mislabeled two-channel
823 * setting; ignore it.
825 * Part 2: analyze quirk flag and format
827 if (bm_quirk
&& fmt
->bNrChannels
== 1 && fmt
->bSubframeSize
== 2)
830 fp
= audio_format_alloc_init(chip
, alts
, protocol
, iface_no
,
831 altset_idx
, altno
, num_channels
, clock
);
833 return ERR_PTR(-ENOMEM
);
835 fp
->attributes
= parse_uac_endpoint_attributes(chip
, alts
, protocol
,
838 /* some quirks for attributes here */
839 snd_usb_audioformat_attributes_quirk(chip
, fp
, stream
);
841 /* ok, let's parse further... */
842 if (snd_usb_parse_audio_format(chip
, fp
, format
,
844 audioformat_free(fp
);
849 if (fp
->channels
!= num_channels
)
852 fp
->chmap
= convert_chmap(fp
->channels
, chconfig
, protocol
);
857 static struct audioformat
*
858 snd_usb_get_audioformat_uac3(struct snd_usb_audio
*chip
,
859 struct usb_host_interface
*alts
,
860 struct snd_usb_power_domain
**pd_out
,
861 int iface_no
, int altset_idx
,
862 int altno
, int stream
)
864 struct usb_device
*dev
= chip
->dev
;
865 struct uac3_input_terminal_descriptor
*input_term
;
866 struct uac3_output_terminal_descriptor
*output_term
;
867 struct uac3_cluster_header_descriptor
*cluster
;
868 struct uac3_as_header_descriptor
*as
= NULL
;
869 struct uac3_hc_descriptor_header hc_header
;
870 struct snd_pcm_chmap_elem
*chmap
;
871 struct snd_usb_power_domain
*pd
;
872 unsigned char badd_profile
;
873 u64 badd_formats
= 0;
874 unsigned int num_channels
;
875 struct audioformat
*fp
;
876 u16 cluster_id
, wLength
;
880 badd_profile
= chip
->badd_profile
;
882 if (badd_profile
>= UAC3_FUNCTION_SUBCLASS_GENERIC_IO
) {
883 unsigned int maxpacksize
=
884 le16_to_cpu(get_endpoint(alts
, 0)->wMaxPacketSize
);
886 switch (maxpacksize
) {
889 "%u:%d : incorrect wMaxPacketSize for BADD profile\n",
892 case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_16
:
893 case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_16
:
894 badd_formats
= SNDRV_PCM_FMTBIT_S16_LE
;
897 case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_24
:
898 case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_24
:
899 badd_formats
= SNDRV_PCM_FMTBIT_S24_3LE
;
902 case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_16
:
903 case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_16
:
904 badd_formats
= SNDRV_PCM_FMTBIT_S16_LE
;
907 case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_24
:
908 case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_24
:
909 badd_formats
= SNDRV_PCM_FMTBIT_S24_3LE
;
914 chmap
= kzalloc(sizeof(*chmap
), GFP_KERNEL
);
916 return ERR_PTR(-ENOMEM
);
918 if (num_channels
== 1) {
919 chmap
->map
[0] = SNDRV_CHMAP_MONO
;
921 chmap
->map
[0] = SNDRV_CHMAP_FL
;
922 chmap
->map
[1] = SNDRV_CHMAP_FR
;
925 chmap
->channels
= num_channels
;
926 clock
= UAC3_BADD_CS_ID9
;
930 as
= snd_usb_find_csint_desc(alts
->extra
, alts
->extralen
,
931 NULL
, UAC_AS_GENERAL
);
934 "%u:%d : UAC_AS_GENERAL descriptor not found\n",
939 if (as
->bLength
< sizeof(*as
)) {
941 "%u:%d : invalid UAC_AS_GENERAL desc\n",
946 cluster_id
= le16_to_cpu(as
->wClusterDescrID
);
949 "%u:%d : no cluster descriptor\n",
955 * Get number of channels and channel map through
956 * High Capability Cluster Descriptor
958 * First step: get High Capability header and
959 * read size of Cluster Descriptor
961 err
= snd_usb_ctl_msg(chip
->dev
,
962 usb_rcvctrlpipe(chip
->dev
, 0),
963 UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR
,
964 USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
966 snd_usb_ctrl_intf(chip
),
967 &hc_header
, sizeof(hc_header
));
970 else if (err
!= sizeof(hc_header
)) {
972 "%u:%d : can't get High Capability descriptor\n",
974 return ERR_PTR(-EIO
);
978 * Second step: allocate needed amount of memory
979 * and request Cluster Descriptor
981 wLength
= le16_to_cpu(hc_header
.wLength
);
982 cluster
= kzalloc(wLength
, GFP_KERNEL
);
984 return ERR_PTR(-ENOMEM
);
985 err
= snd_usb_ctl_msg(chip
->dev
,
986 usb_rcvctrlpipe(chip
->dev
, 0),
987 UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR
,
988 USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
990 snd_usb_ctrl_intf(chip
),
995 } else if (err
!= wLength
) {
997 "%u:%d : can't get Cluster Descriptor\n",
1000 return ERR_PTR(-EIO
);
1003 num_channels
= cluster
->bNrChannels
;
1004 chmap
= convert_chmap_v3(cluster
);
1008 * lookup the terminal associated to this interface
1009 * to extract the clock
1011 input_term
= snd_usb_find_input_terminal_descriptor(chip
->ctrl_intf
,
1015 clock
= input_term
->bCSourceID
;
1019 output_term
= snd_usb_find_output_terminal_descriptor(chip
->ctrl_intf
,
1023 clock
= output_term
->bCSourceID
;
1027 dev_err(&dev
->dev
, "%u:%d : bogus bTerminalLink %d\n",
1028 iface_no
, altno
, as
->bTerminalLink
);
1033 fp
= audio_format_alloc_init(chip
, alts
, UAC_VERSION_3
, iface_no
,
1034 altset_idx
, altno
, num_channels
, clock
);
1037 return ERR_PTR(-ENOMEM
);
1042 if (badd_profile
>= UAC3_FUNCTION_SUBCLASS_GENERIC_IO
) {
1043 fp
->attributes
= 0; /* No attributes */
1045 fp
->fmt_type
= UAC_FORMAT_TYPE_I
;
1046 fp
->formats
= badd_formats
;
1048 fp
->nr_rates
= 0; /* SNDRV_PCM_RATE_CONTINUOUS */
1049 fp
->rate_min
= UAC3_BADD_SAMPLING_RATE
;
1050 fp
->rate_max
= UAC3_BADD_SAMPLING_RATE
;
1051 fp
->rates
= SNDRV_PCM_RATE_CONTINUOUS
;
1053 pd
= kzalloc(sizeof(*pd
), GFP_KERNEL
);
1055 audioformat_free(fp
);
1058 pd
->pd_id
= (stream
== SNDRV_PCM_STREAM_PLAYBACK
) ?
1059 UAC3_BADD_PD_ID10
: UAC3_BADD_PD_ID11
;
1060 pd
->pd_d1d0_rec
= UAC3_BADD_PD_RECOVER_D1D0
;
1061 pd
->pd_d2d0_rec
= UAC3_BADD_PD_RECOVER_D2D0
;
1064 fp
->attributes
= parse_uac_endpoint_attributes(chip
, alts
,
1068 pd
= snd_usb_find_power_domain(chip
->ctrl_intf
,
1071 /* ok, let's parse further... */
1072 if (snd_usb_parse_audio_format_v3(chip
, fp
, as
, stream
) < 0) {
1074 audioformat_free(fp
);
1085 static int __snd_usb_parse_audio_interface(struct snd_usb_audio
*chip
,
1087 bool *has_non_pcm
, bool non_pcm
)
1089 struct usb_device
*dev
;
1090 struct usb_interface
*iface
;
1091 struct usb_host_interface
*alts
;
1092 struct usb_interface_descriptor
*altsd
;
1093 int i
, altno
, err
, stream
;
1094 struct audioformat
*fp
= NULL
;
1095 struct snd_usb_power_domain
*pd
= NULL
;
1100 /* parse the interface's altsettings */
1101 iface
= usb_ifnum_to_if(dev
, iface_no
);
1103 num
= iface
->num_altsetting
;
1106 * Dallas DS4201 workaround: It presents 5 altsettings, but the last
1107 * one misses syncpipe, and does not produce any sound.
1109 if (chip
->usb_id
== USB_ID(0x04fa, 0x4201) && num
>= 4)
1112 for (i
= 0; i
< num
; i
++) {
1113 alts
= &iface
->altsetting
[i
];
1114 altsd
= get_iface_desc(alts
);
1115 protocol
= altsd
->bInterfaceProtocol
;
1116 /* skip invalid one */
1117 if (((altsd
->bInterfaceClass
!= USB_CLASS_AUDIO
||
1118 (altsd
->bInterfaceSubClass
!= USB_SUBCLASS_AUDIOSTREAMING
&&
1119 altsd
->bInterfaceSubClass
!= USB_SUBCLASS_VENDOR_SPEC
)) &&
1120 altsd
->bInterfaceClass
!= USB_CLASS_VENDOR_SPEC
) ||
1121 altsd
->bNumEndpoints
< 1 ||
1122 le16_to_cpu(get_endpoint(alts
, 0)->wMaxPacketSize
) == 0)
1124 /* must be isochronous */
1125 if ((get_endpoint(alts
, 0)->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) !=
1126 USB_ENDPOINT_XFER_ISOC
)
1128 /* check direction */
1129 stream
= (get_endpoint(alts
, 0)->bEndpointAddress
& USB_DIR_IN
) ?
1130 SNDRV_PCM_STREAM_CAPTURE
: SNDRV_PCM_STREAM_PLAYBACK
;
1131 altno
= altsd
->bAlternateSetting
;
1133 if (snd_usb_apply_interface_quirk(chip
, iface_no
, altno
))
1137 * Roland audio streaming interfaces are marked with protocols
1138 * 0/1/2, but are UAC 1 compatible.
1140 if (USB_ID_VENDOR(chip
->usb_id
) == 0x0582 &&
1141 altsd
->bInterfaceClass
== USB_CLASS_VENDOR_SPEC
&&
1143 protocol
= UAC_VERSION_1
;
1147 dev_dbg(&dev
->dev
, "%u:%d: unknown interface protocol %#02x, assuming v1\n",
1148 iface_no
, altno
, protocol
);
1149 protocol
= UAC_VERSION_1
;
1152 case UAC_VERSION_2
: {
1156 * Blue Microphones workaround: The last altsetting is
1157 * identical with the previous one, except for a larger
1158 * packet size, but is actually a mislabeled two-channel
1159 * setting; ignore it.
1161 * Part 1: prepare quirk flag
1163 if (altno
== 2 && num
== 3 &&
1164 fp
&& fp
->altsetting
== 1 && fp
->channels
== 1 &&
1165 fp
->formats
== SNDRV_PCM_FMTBIT_S16_LE
&&
1166 protocol
== UAC_VERSION_1
&&
1167 le16_to_cpu(get_endpoint(alts
, 0)->wMaxPacketSize
) ==
1168 fp
->maxpacksize
* 2)
1171 fp
= snd_usb_get_audioformat_uac12(chip
, alts
, protocol
,
1177 fp
= snd_usb_get_audioformat_uac3(chip
, alts
, &pd
,
1178 iface_no
, i
, altno
, stream
);
1184 else if (IS_ERR(fp
))
1187 if (fp
->fmt_type
!= UAC_FORMAT_TYPE_I
)
1188 *has_non_pcm
= true;
1189 if ((fp
->fmt_type
== UAC_FORMAT_TYPE_I
) == non_pcm
) {
1190 audioformat_free(fp
);
1197 snd_usb_audioformat_set_sync_ep(chip
, fp
);
1199 dev_dbg(&dev
->dev
, "%u:%d: add audio endpoint %#x\n", iface_no
, altno
, fp
->endpoint
);
1200 if (protocol
== UAC_VERSION_3
)
1201 err
= snd_usb_add_audio_stream_v3(chip
, stream
, fp
, pd
);
1203 err
= snd_usb_add_audio_stream(chip
, stream
, fp
);
1206 audioformat_free(fp
);
1212 err
= snd_usb_add_endpoint(chip
, fp
->endpoint
,
1213 SND_USB_ENDPOINT_TYPE_DATA
);
1218 err
= snd_usb_add_endpoint(chip
, fp
->sync_ep
,
1220 SND_USB_ENDPOINT_TYPE_DATA
:
1221 SND_USB_ENDPOINT_TYPE_SYNC
);
1226 /* try to set the interface... */
1227 usb_set_interface(chip
->dev
, iface_no
, 0);
1228 snd_usb_init_pitch(chip
, fp
);
1229 snd_usb_init_sample_rate(chip
, fp
, fp
->rate_max
);
1230 usb_set_interface(chip
->dev
, iface_no
, altno
);
1235 int snd_usb_parse_audio_interface(struct snd_usb_audio
*chip
, int iface_no
)
1238 bool has_non_pcm
= false;
1240 /* parse PCM formats */
1241 err
= __snd_usb_parse_audio_interface(chip
, iface_no
, &has_non_pcm
, false);
1246 /* parse non-PCM formats */
1247 err
= __snd_usb_parse_audio_interface(chip
, iface_no
, &has_non_pcm
, true);