2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 #include <linux/init.h>
19 #include <linux/slab.h>
20 #include <linux/usb.h>
21 #include <linux/usb/audio.h>
22 #include <linux/usb/audio-v2.h>
23 #include <linux/usb/audio-v3.h>
25 #include <sound/core.h>
26 #include <sound/pcm.h>
27 #include <sound/control.h>
28 #include <sound/tlv.h>
45 static void free_substream(struct snd_usb_substream
*subs
)
47 struct audioformat
*fp
, *n
;
49 if (!subs
->num_formats
)
50 return; /* not initialized */
51 list_for_each_entry_safe(fp
, n
, &subs
->fmt_list
, list
) {
52 kfree(fp
->rate_table
);
56 kfree(subs
->rate_list
.list
);
62 * free a usb stream instance
64 static void snd_usb_audio_stream_free(struct snd_usb_stream
*stream
)
66 free_substream(&stream
->substream
[0]);
67 free_substream(&stream
->substream
[1]);
68 list_del(&stream
->list
);
72 static void snd_usb_audio_pcm_free(struct snd_pcm
*pcm
)
74 struct snd_usb_stream
*stream
= pcm
->private_data
;
77 snd_usb_audio_stream_free(stream
);
82 * initialize the substream instance.
85 static void snd_usb_init_substream(struct snd_usb_stream
*as
,
87 struct audioformat
*fp
,
88 struct snd_usb_power_domain
*pd
)
90 struct snd_usb_substream
*subs
= &as
->substream
[stream
];
92 INIT_LIST_HEAD(&subs
->fmt_list
);
93 spin_lock_init(&subs
->lock
);
96 subs
->direction
= stream
;
97 subs
->dev
= as
->chip
->dev
;
98 subs
->txfr_quirk
= as
->chip
->txfr_quirk
;
99 subs
->tx_length_quirk
= as
->chip
->tx_length_quirk
;
100 subs
->speed
= snd_usb_get_speed(subs
->dev
);
101 subs
->pkt_offset_adj
= 0;
103 snd_usb_set_pcm_ops(as
->pcm
, stream
);
105 list_add_tail(&fp
->list
, &subs
->fmt_list
);
106 subs
->formats
|= fp
->formats
;
108 subs
->fmt_type
= fp
->fmt_type
;
109 subs
->ep_num
= fp
->endpoint
;
110 if (fp
->channels
> subs
->channels_max
)
111 subs
->channels_max
= fp
->channels
;
115 /* Initialize Power Domain to idle status D1 */
116 snd_usb_power_domain_set(subs
->stream
->chip
, pd
,
120 snd_usb_preallocate_buffer(subs
);
123 /* kctl callbacks for usb-audio channel maps */
124 static int usb_chmap_ctl_info(struct snd_kcontrol
*kcontrol
,
125 struct snd_ctl_elem_info
*uinfo
)
127 struct snd_pcm_chmap
*info
= snd_kcontrol_chip(kcontrol
);
128 struct snd_usb_substream
*subs
= info
->private_data
;
130 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
131 uinfo
->count
= subs
->channels_max
;
132 uinfo
->value
.integer
.min
= 0;
133 uinfo
->value
.integer
.max
= SNDRV_CHMAP_LAST
;
137 /* check whether a duplicated entry exists in the audiofmt list */
138 static bool have_dup_chmap(struct snd_usb_substream
*subs
,
139 struct audioformat
*fp
)
141 struct audioformat
*prev
= fp
;
143 list_for_each_entry_continue_reverse(prev
, &subs
->fmt_list
, list
) {
145 !memcmp(prev
->chmap
, fp
->chmap
, sizeof(*fp
->chmap
)))
151 static int usb_chmap_ctl_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
152 unsigned int size
, unsigned int __user
*tlv
)
154 struct snd_pcm_chmap
*info
= snd_kcontrol_chip(kcontrol
);
155 struct snd_usb_substream
*subs
= info
->private_data
;
156 struct audioformat
*fp
;
157 unsigned int __user
*dst
;
162 if (put_user(SNDRV_CTL_TLVT_CONTAINER
, tlv
))
166 list_for_each_entry(fp
, &subs
->fmt_list
, list
) {
171 if (have_dup_chmap(subs
, fp
))
174 ch_bytes
= fp
->chmap
->channels
* 4;
175 if (size
< 8 + ch_bytes
)
177 if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED
, dst
) ||
178 put_user(ch_bytes
, dst
+ 1))
181 for (i
= 0; i
< fp
->chmap
->channels
; i
++, dst
++) {
182 if (put_user(fp
->chmap
->map
[i
], dst
))
186 count
+= 8 + ch_bytes
;
187 size
-= 8 + ch_bytes
;
189 if (put_user(count
, tlv
+ 1))
194 static int usb_chmap_ctl_get(struct snd_kcontrol
*kcontrol
,
195 struct snd_ctl_elem_value
*ucontrol
)
197 struct snd_pcm_chmap
*info
= snd_kcontrol_chip(kcontrol
);
198 struct snd_usb_substream
*subs
= info
->private_data
;
199 struct snd_pcm_chmap_elem
*chmap
= NULL
;
202 memset(ucontrol
->value
.integer
.value
, 0,
203 sizeof(ucontrol
->value
.integer
.value
));
204 if (subs
->cur_audiofmt
)
205 chmap
= subs
->cur_audiofmt
->chmap
;
207 for (i
= 0; i
< chmap
->channels
; i
++)
208 ucontrol
->value
.integer
.value
[i
] = chmap
->map
[i
];
213 /* create a chmap kctl assigned to the given USB substream */
214 static int add_chmap(struct snd_pcm
*pcm
, int stream
,
215 struct snd_usb_substream
*subs
)
217 struct audioformat
*fp
;
218 struct snd_pcm_chmap
*chmap
;
219 struct snd_kcontrol
*kctl
;
222 list_for_each_entry(fp
, &subs
->fmt_list
, list
)
225 /* no chmap is found */
229 err
= snd_pcm_add_chmap_ctls(pcm
, stream
, NULL
, 0, 0, &chmap
);
233 /* override handlers */
234 chmap
->private_data
= subs
;
236 kctl
->info
= usb_chmap_ctl_info
;
237 kctl
->get
= usb_chmap_ctl_get
;
238 kctl
->tlv
.c
= usb_chmap_ctl_tlv
;
243 /* convert from USB ChannelConfig bits to ALSA chmap element */
244 static struct snd_pcm_chmap_elem
*convert_chmap(int channels
, unsigned int bits
,
247 static unsigned int uac1_maps
[] = {
248 SNDRV_CHMAP_FL
, /* left front */
249 SNDRV_CHMAP_FR
, /* right front */
250 SNDRV_CHMAP_FC
, /* center front */
251 SNDRV_CHMAP_LFE
, /* LFE */
252 SNDRV_CHMAP_SL
, /* left surround */
253 SNDRV_CHMAP_SR
, /* right surround */
254 SNDRV_CHMAP_FLC
, /* left of center */
255 SNDRV_CHMAP_FRC
, /* right of center */
256 SNDRV_CHMAP_RC
, /* surround */
257 SNDRV_CHMAP_SL
, /* side left */
258 SNDRV_CHMAP_SR
, /* side right */
259 SNDRV_CHMAP_TC
, /* top */
262 static unsigned int uac2_maps
[] = {
263 SNDRV_CHMAP_FL
, /* front left */
264 SNDRV_CHMAP_FR
, /* front right */
265 SNDRV_CHMAP_FC
, /* front center */
266 SNDRV_CHMAP_LFE
, /* LFE */
267 SNDRV_CHMAP_RL
, /* back left */
268 SNDRV_CHMAP_RR
, /* back right */
269 SNDRV_CHMAP_FLC
, /* front left of center */
270 SNDRV_CHMAP_FRC
, /* front right of center */
271 SNDRV_CHMAP_RC
, /* back center */
272 SNDRV_CHMAP_SL
, /* side left */
273 SNDRV_CHMAP_SR
, /* side right */
274 SNDRV_CHMAP_TC
, /* top center */
275 SNDRV_CHMAP_TFL
, /* top front left */
276 SNDRV_CHMAP_TFC
, /* top front center */
277 SNDRV_CHMAP_TFR
, /* top front right */
278 SNDRV_CHMAP_TRL
, /* top back left */
279 SNDRV_CHMAP_TRC
, /* top back center */
280 SNDRV_CHMAP_TRR
, /* top back right */
281 SNDRV_CHMAP_TFLC
, /* top front left of center */
282 SNDRV_CHMAP_TFRC
, /* top front right of center */
283 SNDRV_CHMAP_LLFE
, /* left LFE */
284 SNDRV_CHMAP_RLFE
, /* right LFE */
285 SNDRV_CHMAP_TSL
, /* top side left */
286 SNDRV_CHMAP_TSR
, /* top side right */
287 SNDRV_CHMAP_BC
, /* bottom center */
288 SNDRV_CHMAP_RLC
, /* back left of center */
289 SNDRV_CHMAP_RRC
, /* back right of center */
292 struct snd_pcm_chmap_elem
*chmap
;
293 const unsigned int *maps
;
296 if (channels
> ARRAY_SIZE(chmap
->map
))
299 chmap
= kzalloc(sizeof(*chmap
), GFP_KERNEL
);
303 maps
= protocol
== UAC_VERSION_2
? uac2_maps
: uac1_maps
;
304 chmap
->channels
= channels
;
308 for (; bits
&& *maps
; maps
++, bits
>>= 1)
310 chmap
->map
[c
++] = *maps
;
312 /* If we're missing wChannelConfig, then guess something
313 to make sure the channel map is not skipped entirely */
315 chmap
->map
[c
++] = SNDRV_CHMAP_MONO
;
317 for (; c
< channels
&& *maps
; maps
++)
318 chmap
->map
[c
++] = *maps
;
321 for (; c
< channels
; c
++)
322 chmap
->map
[c
] = SNDRV_CHMAP_UNKNOWN
;
327 /* UAC3 device stores channels information in Cluster Descriptors */
329 snd_pcm_chmap_elem
*convert_chmap_v3(struct uac3_cluster_header_descriptor
332 unsigned int channels
= cluster
->bNrChannels
;
333 struct snd_pcm_chmap_elem
*chmap
;
337 if (channels
> ARRAY_SIZE(chmap
->map
))
340 chmap
= kzalloc(sizeof(*chmap
), GFP_KERNEL
);
344 len
= le16_to_cpu(cluster
->wLength
);
346 p
+= sizeof(struct uac3_cluster_header_descriptor
);
348 while (((p
- (void *)cluster
) < len
) && (c
< channels
)) {
349 struct uac3_cluster_segment_descriptor
*cs_desc
= p
;
353 cs_len
= le16_to_cpu(cs_desc
->wLength
);
354 cs_type
= cs_desc
->bSegmentType
;
356 if (cs_type
== UAC3_CHANNEL_INFORMATION
) {
357 struct uac3_cluster_information_segment_descriptor
*is
= p
;
361 * TODO: this conversion is not complete, update it
362 * after adding UAC3 values to asound.h
364 switch (is
->bChRelationship
) {
366 map
= SNDRV_CHMAP_MONO
;
369 case UAC3_CH_FRONT_LEFT
:
370 case UAC3_CH_HEADPHONE_LEFT
:
371 map
= SNDRV_CHMAP_FL
;
374 case UAC3_CH_FRONT_RIGHT
:
375 case UAC3_CH_HEADPHONE_RIGHT
:
376 map
= SNDRV_CHMAP_FR
;
378 case UAC3_CH_FRONT_CENTER
:
379 map
= SNDRV_CHMAP_FC
;
381 case UAC3_CH_FRONT_LEFT_OF_CENTER
:
382 map
= SNDRV_CHMAP_FLC
;
384 case UAC3_CH_FRONT_RIGHT_OF_CENTER
:
385 map
= SNDRV_CHMAP_FRC
;
387 case UAC3_CH_SIDE_LEFT
:
388 map
= SNDRV_CHMAP_SL
;
390 case UAC3_CH_SIDE_RIGHT
:
391 map
= SNDRV_CHMAP_SR
;
393 case UAC3_CH_BACK_LEFT
:
394 map
= SNDRV_CHMAP_RL
;
396 case UAC3_CH_BACK_RIGHT
:
397 map
= SNDRV_CHMAP_RR
;
399 case UAC3_CH_BACK_CENTER
:
400 map
= SNDRV_CHMAP_RC
;
402 case UAC3_CH_BACK_LEFT_OF_CENTER
:
403 map
= SNDRV_CHMAP_RLC
;
405 case UAC3_CH_BACK_RIGHT_OF_CENTER
:
406 map
= SNDRV_CHMAP_RRC
;
408 case UAC3_CH_TOP_CENTER
:
409 map
= SNDRV_CHMAP_TC
;
411 case UAC3_CH_TOP_FRONT_LEFT
:
412 map
= SNDRV_CHMAP_TFL
;
414 case UAC3_CH_TOP_FRONT_RIGHT
:
415 map
= SNDRV_CHMAP_TFR
;
417 case UAC3_CH_TOP_FRONT_CENTER
:
418 map
= SNDRV_CHMAP_TFC
;
420 case UAC3_CH_TOP_FRONT_LOC
:
421 map
= SNDRV_CHMAP_TFLC
;
423 case UAC3_CH_TOP_FRONT_ROC
:
424 map
= SNDRV_CHMAP_TFRC
;
426 case UAC3_CH_TOP_SIDE_LEFT
:
427 map
= SNDRV_CHMAP_TSL
;
429 case UAC3_CH_TOP_SIDE_RIGHT
:
430 map
= SNDRV_CHMAP_TSR
;
432 case UAC3_CH_TOP_BACK_LEFT
:
433 map
= SNDRV_CHMAP_TRL
;
435 case UAC3_CH_TOP_BACK_RIGHT
:
436 map
= SNDRV_CHMAP_TRR
;
438 case UAC3_CH_TOP_BACK_CENTER
:
439 map
= SNDRV_CHMAP_TRC
;
441 case UAC3_CH_BOTTOM_CENTER
:
442 map
= SNDRV_CHMAP_BC
;
444 case UAC3_CH_LOW_FREQUENCY_EFFECTS
:
445 map
= SNDRV_CHMAP_LFE
;
447 case UAC3_CH_LFE_LEFT
:
448 map
= SNDRV_CHMAP_LLFE
;
450 case UAC3_CH_LFE_RIGHT
:
451 map
= SNDRV_CHMAP_RLFE
;
453 case UAC3_CH_RELATIONSHIP_UNDEFINED
:
455 map
= SNDRV_CHMAP_UNKNOWN
;
458 chmap
->map
[c
++] = map
;
464 pr_err("%s: channel number mismatch\n", __func__
);
466 chmap
->channels
= channels
;
468 for (; c
< channels
; c
++)
469 chmap
->map
[c
] = SNDRV_CHMAP_UNKNOWN
;
475 * add this endpoint to the chip instance.
476 * if a stream with the same endpoint already exists, append to it.
477 * if not, create a new pcm stream. note, fp is added to the substream
478 * fmt_list and will be freed on the chip instance release. do not free
479 * fp or do remove it from the substream fmt_list to avoid double-free.
481 static int __snd_usb_add_audio_stream(struct snd_usb_audio
*chip
,
483 struct audioformat
*fp
,
484 struct snd_usb_power_domain
*pd
)
487 struct snd_usb_stream
*as
;
488 struct snd_usb_substream
*subs
;
492 list_for_each_entry(as
, &chip
->pcm_list
, list
) {
493 if (as
->fmt_type
!= fp
->fmt_type
)
495 subs
= &as
->substream
[stream
];
496 if (subs
->ep_num
== fp
->endpoint
) {
497 list_add_tail(&fp
->list
, &subs
->fmt_list
);
499 subs
->formats
|= fp
->formats
;
503 /* look for an empty stream */
504 list_for_each_entry(as
, &chip
->pcm_list
, list
) {
505 if (as
->fmt_type
!= fp
->fmt_type
)
507 subs
= &as
->substream
[stream
];
510 err
= snd_pcm_new_stream(as
->pcm
, stream
, 1);
513 snd_usb_init_substream(as
, stream
, fp
, pd
);
514 return add_chmap(as
->pcm
, stream
, subs
);
517 /* create a new pcm */
518 as
= kzalloc(sizeof(*as
), GFP_KERNEL
);
521 as
->pcm_index
= chip
->pcm_devs
;
523 as
->fmt_type
= fp
->fmt_type
;
524 err
= snd_pcm_new(chip
->card
, "USB Audio", chip
->pcm_devs
,
525 stream
== SNDRV_PCM_STREAM_PLAYBACK
? 1 : 0,
526 stream
== SNDRV_PCM_STREAM_PLAYBACK
? 0 : 1,
533 pcm
->private_data
= as
;
534 pcm
->private_free
= snd_usb_audio_pcm_free
;
536 if (chip
->pcm_devs
> 0)
537 sprintf(pcm
->name
, "USB Audio #%d", chip
->pcm_devs
);
539 strcpy(pcm
->name
, "USB Audio");
541 snd_usb_init_substream(as
, stream
, fp
, pd
);
544 * Keep using head insertion for M-Audio Audiophile USB (tm) which has a
545 * fix to swap capture stream order in conf/cards/USB-audio.conf
547 if (chip
->usb_id
== USB_ID(0x0763, 0x2003))
548 list_add(&as
->list
, &chip
->pcm_list
);
550 list_add_tail(&as
->list
, &chip
->pcm_list
);
554 snd_usb_proc_pcm_format_add(as
);
556 return add_chmap(pcm
, stream
, &as
->substream
[stream
]);
559 int snd_usb_add_audio_stream(struct snd_usb_audio
*chip
,
561 struct audioformat
*fp
)
563 return __snd_usb_add_audio_stream(chip
, stream
, fp
, NULL
);
566 static int snd_usb_add_audio_stream_v3(struct snd_usb_audio
*chip
,
568 struct audioformat
*fp
,
569 struct snd_usb_power_domain
*pd
)
571 return __snd_usb_add_audio_stream(chip
, stream
, fp
, pd
);
574 static int parse_uac_endpoint_attributes(struct snd_usb_audio
*chip
,
575 struct usb_host_interface
*alts
,
576 int protocol
, int iface_no
)
578 /* parsed with a v1 header here. that's ok as we only look at the
579 * header first which is the same for both versions */
580 struct uac_iso_endpoint_descriptor
*csep
;
581 struct usb_interface_descriptor
*altsd
= get_iface_desc(alts
);
584 csep
= snd_usb_find_desc(alts
->endpoint
[0].extra
, alts
->endpoint
[0].extralen
, NULL
, USB_DT_CS_ENDPOINT
);
586 /* Creamware Noah has this descriptor after the 2nd endpoint */
587 if (!csep
&& altsd
->bNumEndpoints
>= 2)
588 csep
= snd_usb_find_desc(alts
->endpoint
[1].extra
, alts
->endpoint
[1].extralen
, NULL
, USB_DT_CS_ENDPOINT
);
591 * If we can't locate the USB_DT_CS_ENDPOINT descriptor in the extra
592 * bytes after the first endpoint, go search the entire interface.
593 * Some devices have it directly *before* the standard endpoint.
596 csep
= snd_usb_find_desc(alts
->extra
, alts
->extralen
, NULL
, USB_DT_CS_ENDPOINT
);
598 if (!csep
|| csep
->bLength
< 7 ||
599 csep
->bDescriptorSubtype
!= UAC_EP_GENERAL
) {
601 "%u:%d : no or invalid class specific endpoint descriptor\n",
602 iface_no
, altsd
->bAlternateSetting
);
606 if (protocol
== UAC_VERSION_1
) {
607 attributes
= csep
->bmAttributes
;
608 } else if (protocol
== UAC_VERSION_2
) {
609 struct uac2_iso_endpoint_descriptor
*csep2
=
610 (struct uac2_iso_endpoint_descriptor
*) csep
;
612 attributes
= csep
->bmAttributes
& UAC_EP_CS_ATTR_FILL_MAX
;
614 /* emulate the endpoint attributes of a v1 device */
615 if (csep2
->bmControls
& UAC2_CONTROL_PITCH
)
616 attributes
|= UAC_EP_CS_ATTR_PITCH_CONTROL
;
617 } else { /* UAC_VERSION_3 */
618 struct uac3_iso_endpoint_descriptor
*csep3
=
619 (struct uac3_iso_endpoint_descriptor
*) csep
;
621 /* emulate the endpoint attributes of a v1 device */
622 if (le32_to_cpu(csep3
->bmControls
) & UAC2_CONTROL_PITCH
)
623 attributes
|= UAC_EP_CS_ATTR_PITCH_CONTROL
;
629 /* find an input terminal descriptor (either UAC1 or UAC2) with the given
633 snd_usb_find_input_terminal_descriptor(struct usb_host_interface
*ctrl_iface
,
636 struct uac2_input_terminal_descriptor
*term
= NULL
;
638 while ((term
= snd_usb_find_csint_desc(ctrl_iface
->extra
,
639 ctrl_iface
->extralen
,
640 term
, UAC_INPUT_TERMINAL
))) {
641 if (term
->bTerminalID
== terminal_id
)
649 snd_usb_find_output_terminal_descriptor(struct usb_host_interface
*ctrl_iface
,
652 /* OK to use with both UAC2 and UAC3 */
653 struct uac2_output_terminal_descriptor
*term
= NULL
;
655 while ((term
= snd_usb_find_csint_desc(ctrl_iface
->extra
,
656 ctrl_iface
->extralen
,
657 term
, UAC_OUTPUT_TERMINAL
))) {
658 if (term
->bTerminalID
== terminal_id
)
665 static struct audioformat
*
666 audio_format_alloc_init(struct snd_usb_audio
*chip
,
667 struct usb_host_interface
*alts
,
668 int protocol
, int iface_no
, int altset_idx
,
669 int altno
, int num_channels
, int clock
)
671 struct audioformat
*fp
;
673 fp
= kzalloc(sizeof(*fp
), GFP_KERNEL
);
677 fp
->iface
= iface_no
;
678 fp
->altsetting
= altno
;
679 fp
->altset_idx
= altset_idx
;
680 fp
->endpoint
= get_endpoint(alts
, 0)->bEndpointAddress
;
681 fp
->ep_attr
= get_endpoint(alts
, 0)->bmAttributes
;
682 fp
->datainterval
= snd_usb_parse_datainterval(chip
, alts
);
683 fp
->protocol
= protocol
;
684 fp
->maxpacksize
= le16_to_cpu(get_endpoint(alts
, 0)->wMaxPacketSize
);
685 fp
->channels
= num_channels
;
686 if (snd_usb_get_speed(chip
->dev
) == USB_SPEED_HIGH
)
687 fp
->maxpacksize
= (((fp
->maxpacksize
>> 11) & 3) + 1)
688 * (fp
->maxpacksize
& 0x7ff);
690 INIT_LIST_HEAD(&fp
->list
);
695 static struct audioformat
*
696 snd_usb_get_audioformat_uac12(struct snd_usb_audio
*chip
,
697 struct usb_host_interface
*alts
,
698 int protocol
, int iface_no
, int altset_idx
,
699 int altno
, int stream
, int bm_quirk
)
701 struct usb_device
*dev
= chip
->dev
;
702 struct uac_format_type_i_continuous_descriptor
*fmt
;
703 unsigned int num_channels
= 0, chconfig
= 0;
704 struct audioformat
*fp
;
708 /* get audio formats */
709 if (protocol
== UAC_VERSION_1
) {
710 struct uac1_as_header_descriptor
*as
=
711 snd_usb_find_csint_desc(alts
->extra
, alts
->extralen
,
712 NULL
, UAC_AS_GENERAL
);
713 struct uac_input_terminal_descriptor
*iterm
;
717 "%u:%d : UAC_AS_GENERAL descriptor not found\n",
722 if (as
->bLength
< sizeof(*as
)) {
724 "%u:%d : invalid UAC_AS_GENERAL desc\n",
729 format
= le16_to_cpu(as
->wFormatTag
); /* remember the format value */
731 iterm
= snd_usb_find_input_terminal_descriptor(chip
->ctrl_intf
,
734 num_channels
= iterm
->bNrChannels
;
735 chconfig
= le16_to_cpu(iterm
->wChannelConfig
);
737 } else { /* UAC_VERSION_2 */
738 struct uac2_input_terminal_descriptor
*input_term
;
739 struct uac2_output_terminal_descriptor
*output_term
;
740 struct uac2_as_header_descriptor
*as
=
741 snd_usb_find_csint_desc(alts
->extra
, alts
->extralen
,
742 NULL
, UAC_AS_GENERAL
);
746 "%u:%d : UAC_AS_GENERAL descriptor not found\n",
751 if (as
->bLength
< sizeof(*as
)) {
753 "%u:%d : invalid UAC_AS_GENERAL desc\n",
758 num_channels
= as
->bNrChannels
;
759 format
= le32_to_cpu(as
->bmFormats
);
760 chconfig
= le32_to_cpu(as
->bmChannelConfig
);
763 * lookup the terminal associated to this interface
764 * to extract the clock
766 input_term
= snd_usb_find_input_terminal_descriptor(chip
->ctrl_intf
,
769 clock
= input_term
->bCSourceID
;
770 if (!chconfig
&& (num_channels
== input_term
->bNrChannels
))
771 chconfig
= le32_to_cpu(input_term
->bmChannelConfig
);
775 output_term
= snd_usb_find_output_terminal_descriptor(chip
->ctrl_intf
,
778 clock
= output_term
->bCSourceID
;
783 "%u:%d : bogus bTerminalLink %d\n",
784 iface_no
, altno
, as
->bTerminalLink
);
789 /* get format type */
790 fmt
= snd_usb_find_csint_desc(alts
->extra
, alts
->extralen
,
791 NULL
, UAC_FORMAT_TYPE
);
794 "%u:%d : no UAC_FORMAT_TYPE desc\n",
798 if (((protocol
== UAC_VERSION_1
) && (fmt
->bLength
< 8))
799 || ((protocol
== UAC_VERSION_2
) &&
800 (fmt
->bLength
< 6))) {
802 "%u:%d : invalid UAC_FORMAT_TYPE desc\n",
808 * Blue Microphones workaround: The last altsetting is
809 * identical with the previous one, except for a larger
810 * packet size, but is actually a mislabeled two-channel
811 * setting; ignore it.
813 * Part 2: analyze quirk flag and format
815 if (bm_quirk
&& fmt
->bNrChannels
== 1 && fmt
->bSubframeSize
== 2)
818 fp
= audio_format_alloc_init(chip
, alts
, protocol
, iface_no
,
819 altset_idx
, altno
, num_channels
, clock
);
821 return ERR_PTR(-ENOMEM
);
823 fp
->attributes
= parse_uac_endpoint_attributes(chip
, alts
, protocol
,
826 /* some quirks for attributes here */
827 snd_usb_audioformat_attributes_quirk(chip
, fp
, stream
);
829 /* ok, let's parse further... */
830 if (snd_usb_parse_audio_format(chip
, fp
, format
,
832 kfree(fp
->rate_table
);
838 if (fp
->channels
!= num_channels
)
841 fp
->chmap
= convert_chmap(fp
->channels
, chconfig
, protocol
);
846 static struct audioformat
*
847 snd_usb_get_audioformat_uac3(struct snd_usb_audio
*chip
,
848 struct usb_host_interface
*alts
,
849 struct snd_usb_power_domain
**pd_out
,
850 int iface_no
, int altset_idx
,
851 int altno
, int stream
)
853 struct usb_device
*dev
= chip
->dev
;
854 struct uac3_input_terminal_descriptor
*input_term
;
855 struct uac3_output_terminal_descriptor
*output_term
;
856 struct uac3_cluster_header_descriptor
*cluster
;
857 struct uac3_as_header_descriptor
*as
= NULL
;
858 struct uac3_hc_descriptor_header hc_header
;
859 struct snd_pcm_chmap_elem
*chmap
;
860 struct snd_usb_power_domain
*pd
;
861 unsigned char badd_profile
;
862 u64 badd_formats
= 0;
863 unsigned int num_channels
;
864 struct audioformat
*fp
;
865 u16 cluster_id
, wLength
;
869 badd_profile
= chip
->badd_profile
;
871 if (badd_profile
>= UAC3_FUNCTION_SUBCLASS_GENERIC_IO
) {
872 unsigned int maxpacksize
=
873 le16_to_cpu(get_endpoint(alts
, 0)->wMaxPacketSize
);
875 switch (maxpacksize
) {
878 "%u:%d : incorrect wMaxPacketSize for BADD profile\n",
881 case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_16
:
882 case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_16
:
883 badd_formats
= SNDRV_PCM_FMTBIT_S16_LE
;
886 case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_24
:
887 case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_24
:
888 badd_formats
= SNDRV_PCM_FMTBIT_S24_3LE
;
891 case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_16
:
892 case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_16
:
893 badd_formats
= SNDRV_PCM_FMTBIT_S16_LE
;
896 case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_24
:
897 case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_24
:
898 badd_formats
= SNDRV_PCM_FMTBIT_S24_3LE
;
903 chmap
= kzalloc(sizeof(*chmap
), GFP_KERNEL
);
905 return ERR_PTR(-ENOMEM
);
907 if (num_channels
== 1) {
908 chmap
->map
[0] = SNDRV_CHMAP_MONO
;
910 chmap
->map
[0] = SNDRV_CHMAP_FL
;
911 chmap
->map
[1] = SNDRV_CHMAP_FR
;
914 chmap
->channels
= num_channels
;
915 clock
= UAC3_BADD_CS_ID9
;
919 as
= snd_usb_find_csint_desc(alts
->extra
, alts
->extralen
,
920 NULL
, UAC_AS_GENERAL
);
923 "%u:%d : UAC_AS_GENERAL descriptor not found\n",
928 if (as
->bLength
< sizeof(*as
)) {
930 "%u:%d : invalid UAC_AS_GENERAL desc\n",
935 cluster_id
= le16_to_cpu(as
->wClusterDescrID
);
938 "%u:%d : no cluster descriptor\n",
944 * Get number of channels and channel map through
945 * High Capability Cluster Descriptor
947 * First step: get High Capability header and
948 * read size of Cluster Descriptor
950 err
= snd_usb_ctl_msg(chip
->dev
,
951 usb_rcvctrlpipe(chip
->dev
, 0),
952 UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR
,
953 USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
955 snd_usb_ctrl_intf(chip
),
956 &hc_header
, sizeof(hc_header
));
959 else if (err
!= sizeof(hc_header
)) {
961 "%u:%d : can't get High Capability descriptor\n",
963 return ERR_PTR(-EIO
);
967 * Second step: allocate needed amount of memory
968 * and request Cluster Descriptor
970 wLength
= le16_to_cpu(hc_header
.wLength
);
971 cluster
= kzalloc(wLength
, GFP_KERNEL
);
973 return ERR_PTR(-ENOMEM
);
974 err
= snd_usb_ctl_msg(chip
->dev
,
975 usb_rcvctrlpipe(chip
->dev
, 0),
976 UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR
,
977 USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
979 snd_usb_ctrl_intf(chip
),
984 } else if (err
!= wLength
) {
986 "%u:%d : can't get Cluster Descriptor\n",
989 return ERR_PTR(-EIO
);
992 num_channels
= cluster
->bNrChannels
;
993 chmap
= convert_chmap_v3(cluster
);
997 * lookup the terminal associated to this interface
998 * to extract the clock
1000 input_term
= snd_usb_find_input_terminal_descriptor(chip
->ctrl_intf
,
1003 clock
= input_term
->bCSourceID
;
1007 output_term
= snd_usb_find_output_terminal_descriptor(chip
->ctrl_intf
,
1010 clock
= output_term
->bCSourceID
;
1014 dev_err(&dev
->dev
, "%u:%d : bogus bTerminalLink %d\n",
1015 iface_no
, altno
, as
->bTerminalLink
);
1020 fp
= audio_format_alloc_init(chip
, alts
, UAC_VERSION_3
, iface_no
,
1021 altset_idx
, altno
, num_channels
, clock
);
1024 return ERR_PTR(-ENOMEM
);
1029 if (badd_profile
>= UAC3_FUNCTION_SUBCLASS_GENERIC_IO
) {
1030 fp
->attributes
= 0; /* No attributes */
1032 fp
->fmt_type
= UAC_FORMAT_TYPE_I
;
1033 fp
->formats
= badd_formats
;
1035 fp
->nr_rates
= 0; /* SNDRV_PCM_RATE_CONTINUOUS */
1036 fp
->rate_min
= UAC3_BADD_SAMPLING_RATE
;
1037 fp
->rate_max
= UAC3_BADD_SAMPLING_RATE
;
1038 fp
->rates
= SNDRV_PCM_RATE_CONTINUOUS
;
1040 pd
= kzalloc(sizeof(*pd
), GFP_KERNEL
);
1042 kfree(fp
->rate_table
);
1046 pd
->pd_id
= (stream
== SNDRV_PCM_STREAM_PLAYBACK
) ?
1047 UAC3_BADD_PD_ID10
: UAC3_BADD_PD_ID11
;
1048 pd
->pd_d1d0_rec
= UAC3_BADD_PD_RECOVER_D1D0
;
1049 pd
->pd_d2d0_rec
= UAC3_BADD_PD_RECOVER_D2D0
;
1052 fp
->attributes
= parse_uac_endpoint_attributes(chip
, alts
,
1056 pd
= snd_usb_find_power_domain(chip
->ctrl_intf
,
1059 /* ok, let's parse further... */
1060 if (snd_usb_parse_audio_format_v3(chip
, fp
, as
, stream
) < 0) {
1063 kfree(fp
->rate_table
);
1075 int snd_usb_parse_audio_interface(struct snd_usb_audio
*chip
, int iface_no
)
1077 struct usb_device
*dev
;
1078 struct usb_interface
*iface
;
1079 struct usb_host_interface
*alts
;
1080 struct usb_interface_descriptor
*altsd
;
1081 int i
, altno
, err
, stream
;
1082 struct audioformat
*fp
= NULL
;
1083 struct snd_usb_power_domain
*pd
= NULL
;
1088 /* parse the interface's altsettings */
1089 iface
= usb_ifnum_to_if(dev
, iface_no
);
1091 num
= iface
->num_altsetting
;
1094 * Dallas DS4201 workaround: It presents 5 altsettings, but the last
1095 * one misses syncpipe, and does not produce any sound.
1097 if (chip
->usb_id
== USB_ID(0x04fa, 0x4201))
1100 for (i
= 0; i
< num
; i
++) {
1101 alts
= &iface
->altsetting
[i
];
1102 altsd
= get_iface_desc(alts
);
1103 protocol
= altsd
->bInterfaceProtocol
;
1104 /* skip invalid one */
1105 if (((altsd
->bInterfaceClass
!= USB_CLASS_AUDIO
||
1106 (altsd
->bInterfaceSubClass
!= USB_SUBCLASS_AUDIOSTREAMING
&&
1107 altsd
->bInterfaceSubClass
!= USB_SUBCLASS_VENDOR_SPEC
)) &&
1108 altsd
->bInterfaceClass
!= USB_CLASS_VENDOR_SPEC
) ||
1109 altsd
->bNumEndpoints
< 1 ||
1110 le16_to_cpu(get_endpoint(alts
, 0)->wMaxPacketSize
) == 0)
1112 /* must be isochronous */
1113 if ((get_endpoint(alts
, 0)->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) !=
1114 USB_ENDPOINT_XFER_ISOC
)
1116 /* check direction */
1117 stream
= (get_endpoint(alts
, 0)->bEndpointAddress
& USB_DIR_IN
) ?
1118 SNDRV_PCM_STREAM_CAPTURE
: SNDRV_PCM_STREAM_PLAYBACK
;
1119 altno
= altsd
->bAlternateSetting
;
1121 if (snd_usb_apply_interface_quirk(chip
, iface_no
, altno
))
1125 * Roland audio streaming interfaces are marked with protocols
1126 * 0/1/2, but are UAC 1 compatible.
1128 if (USB_ID_VENDOR(chip
->usb_id
) == 0x0582 &&
1129 altsd
->bInterfaceClass
== USB_CLASS_VENDOR_SPEC
&&
1131 protocol
= UAC_VERSION_1
;
1135 dev_dbg(&dev
->dev
, "%u:%d: unknown interface protocol %#02x, assuming v1\n",
1136 iface_no
, altno
, protocol
);
1137 protocol
= UAC_VERSION_1
;
1141 case UAC_VERSION_2
: {
1145 * Blue Microphones workaround: The last altsetting is
1146 * identical with the previous one, except for a larger
1147 * packet size, but is actually a mislabeled two-channel
1148 * setting; ignore it.
1150 * Part 1: prepare quirk flag
1152 if (altno
== 2 && num
== 3 &&
1153 fp
&& fp
->altsetting
== 1 && fp
->channels
== 1 &&
1154 fp
->formats
== SNDRV_PCM_FMTBIT_S16_LE
&&
1155 protocol
== UAC_VERSION_1
&&
1156 le16_to_cpu(get_endpoint(alts
, 0)->wMaxPacketSize
) ==
1157 fp
->maxpacksize
* 2)
1160 fp
= snd_usb_get_audioformat_uac12(chip
, alts
, protocol
,
1166 fp
= snd_usb_get_audioformat_uac3(chip
, alts
, &pd
,
1167 iface_no
, i
, altno
, stream
);
1173 else if (IS_ERR(fp
))
1176 dev_dbg(&dev
->dev
, "%u:%d: add audio endpoint %#x\n", iface_no
, altno
, fp
->endpoint
);
1177 if (protocol
== UAC_VERSION_3
)
1178 err
= snd_usb_add_audio_stream_v3(chip
, stream
, fp
, pd
);
1180 err
= snd_usb_add_audio_stream(chip
, stream
, fp
);
1183 list_del(&fp
->list
); /* unlink for avoiding double-free */
1185 kfree(fp
->rate_table
);
1190 /* try to set the interface... */
1191 usb_set_interface(chip
->dev
, iface_no
, altno
);
1192 snd_usb_init_pitch(chip
, iface_no
, alts
, fp
);
1193 snd_usb_init_sample_rate(chip
, iface_no
, alts
, fp
, fp
->rate_max
);