1 // SPDX-License-Identifier: GPL-2.0-or-later
5 #include <linux/init.h>
6 #include <linux/slab.h>
8 #include <linux/usb/audio.h>
9 #include <linux/usb/audio-v2.h>
10 #include <linux/usb/audio-v3.h>
12 #include <sound/core.h>
13 #include <sound/pcm.h>
24 * parse the audio format type I descriptor
25 * and returns the corresponding pcm format
28 * @fp: audioformat record
29 * @format: the format tag (wFormatTag)
30 * @fmt: the format type descriptor (v1/v2) or AudioStreaming descriptor (v3)
32 static u64
parse_audio_format_i_type(struct snd_usb_audio
*chip
,
33 struct audioformat
*fp
,
34 u64 format
, void *_fmt
)
36 int sample_width
, sample_bytes
;
39 switch (fp
->protocol
) {
42 struct uac_format_type_i_discrete_descriptor
*fmt
= _fmt
;
43 sample_width
= fmt
->bBitResolution
;
44 sample_bytes
= fmt
->bSubframeSize
;
45 format
= 1ULL << format
;
50 struct uac_format_type_i_ext_descriptor
*fmt
= _fmt
;
51 sample_width
= fmt
->bBitResolution
;
52 sample_bytes
= fmt
->bSubslotSize
;
54 if (format
& UAC2_FORMAT_TYPE_I_RAW_DATA
) {
55 pcm_formats
|= SNDRV_PCM_FMTBIT_SPECIAL
;
56 /* flag potentially raw DSD capable altsettings */
64 struct uac3_as_header_descriptor
*as
= _fmt
;
66 sample_width
= as
->bBitResolution
;
67 sample_bytes
= as
->bSubslotSize
;
69 if (format
& UAC3_FORMAT_TYPE_I_RAW_DATA
)
70 pcm_formats
|= SNDRV_PCM_FMTBIT_SPECIAL
;
77 fp
->fmt_bits
= sample_width
;
79 if ((pcm_formats
== 0) &&
80 (format
== 0 || format
== (1 << UAC_FORMAT_TYPE_I_UNDEFINED
))) {
81 /* some devices don't define this correctly... */
82 usb_audio_info(chip
, "%u:%d : format type 0 is detected, processed as PCM\n",
83 fp
->iface
, fp
->altsetting
);
84 format
= 1 << UAC_FORMAT_TYPE_I_PCM
;
86 if (format
& (1 << UAC_FORMAT_TYPE_I_PCM
)) {
87 if (((chip
->usb_id
== USB_ID(0x0582, 0x0016)) ||
89 (chip
->usb_id
== USB_ID(0x0582, 0x000c))) &&
91 sample_width
== 24 && sample_bytes
== 2)
93 else if (sample_width
> sample_bytes
* 8) {
94 usb_audio_info(chip
, "%u:%d : sample bitwidth %d in over sample bytes %d\n",
95 fp
->iface
, fp
->altsetting
,
96 sample_width
, sample_bytes
);
98 /* check the format byte size */
99 switch (sample_bytes
) {
101 pcm_formats
|= SNDRV_PCM_FMTBIT_S8
;
104 if (snd_usb_is_big_endian_format(chip
, fp
))
105 pcm_formats
|= SNDRV_PCM_FMTBIT_S16_BE
; /* grrr, big endian!! */
107 pcm_formats
|= SNDRV_PCM_FMTBIT_S16_LE
;
110 if (snd_usb_is_big_endian_format(chip
, fp
))
111 pcm_formats
|= SNDRV_PCM_FMTBIT_S24_3BE
; /* grrr, big endian!! */
113 pcm_formats
|= SNDRV_PCM_FMTBIT_S24_3LE
;
116 pcm_formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
120 "%u:%d : unsupported sample bitwidth %d in %d bytes\n",
121 fp
->iface
, fp
->altsetting
,
122 sample_width
, sample_bytes
);
126 if (format
& (1 << UAC_FORMAT_TYPE_I_PCM8
)) {
127 /* Dallas DS4201 workaround: it advertises U8 format, but really
129 if (chip
->usb_id
== USB_ID(0x04fa, 0x4201))
130 pcm_formats
|= SNDRV_PCM_FMTBIT_S8
;
132 pcm_formats
|= SNDRV_PCM_FMTBIT_U8
;
134 if (format
& (1 << UAC_FORMAT_TYPE_I_IEEE_FLOAT
)) {
135 pcm_formats
|= SNDRV_PCM_FMTBIT_FLOAT_LE
;
137 if (format
& (1 << UAC_FORMAT_TYPE_I_ALAW
)) {
138 pcm_formats
|= SNDRV_PCM_FMTBIT_A_LAW
;
140 if (format
& (1 << UAC_FORMAT_TYPE_I_MULAW
)) {
141 pcm_formats
|= SNDRV_PCM_FMTBIT_MU_LAW
;
143 if (format
& ~0x3f) {
145 "%u:%d : unsupported format bits %#llx\n",
146 fp
->iface
, fp
->altsetting
, format
);
149 pcm_formats
|= snd_usb_interface_dsd_format_quirks(chip
, fp
, sample_bytes
);
156 * parse the format descriptor and stores the possible sample rates
157 * on the audioformat table (audio class v1).
160 * @fp: audioformat record
161 * @fmt: the format descriptor
162 * @offset: the start offset of descriptor pointing the rate type
163 * (7 for type I and II, 8 for type II)
165 static int parse_audio_format_rates_v1(struct snd_usb_audio
*chip
, struct audioformat
*fp
,
166 unsigned char *fmt
, int offset
)
168 int nr_rates
= fmt
[offset
];
170 if (fmt
[0] < offset
+ 1 + 3 * (nr_rates
? nr_rates
: 2)) {
172 "%u:%d : invalid UAC_FORMAT_TYPE desc\n",
173 fp
->iface
, fp
->altsetting
);
179 * build the rate table and bitmap flags
183 fp
->rate_table
= kmalloc_array(nr_rates
, sizeof(int),
185 if (fp
->rate_table
== NULL
)
189 fp
->rate_min
= fp
->rate_max
= 0;
190 for (r
= 0, idx
= offset
+ 1; r
< nr_rates
; r
++, idx
+= 3) {
191 unsigned int rate
= combine_triple(&fmt
[idx
]);
194 /* C-Media CM6501 mislabels its 96 kHz altsetting */
195 /* Terratec Aureon 7.1 USB C-Media 6206, too */
196 if (rate
== 48000 && nr_rates
== 1 &&
197 (chip
->usb_id
== USB_ID(0x0d8c, 0x0201) ||
198 chip
->usb_id
== USB_ID(0x0d8c, 0x0102) ||
199 chip
->usb_id
== USB_ID(0x0ccd, 0x00b1)) &&
200 fp
->altsetting
== 5 && fp
->maxpacksize
== 392)
202 /* Creative VF0420/VF0470 Live Cams report 16 kHz instead of 8kHz */
204 (chip
->usb_id
== USB_ID(0x041e, 0x4064) ||
205 chip
->usb_id
== USB_ID(0x041e, 0x4068)))
208 fp
->rate_table
[fp
->nr_rates
] = rate
;
209 if (!fp
->rate_min
|| rate
< fp
->rate_min
)
211 if (!fp
->rate_max
|| rate
> fp
->rate_max
)
213 fp
->rates
|= snd_pcm_rate_to_rate_bit(rate
);
217 hwc_debug("All rates were zero. Skipping format!\n");
221 /* continuous rates */
222 fp
->rates
= SNDRV_PCM_RATE_CONTINUOUS
;
223 fp
->rate_min
= combine_triple(&fmt
[offset
+ 1]);
224 fp
->rate_max
= combine_triple(&fmt
[offset
+ 4]);
230 * Helper function to walk the array of sample rate triplets reported by
231 * the device. The problem is that we need to parse whole array first to
232 * get to know how many sample rates we have to expect.
233 * Then fp->rate_table can be allocated and filled.
235 static int parse_uac2_sample_rate_range(struct snd_usb_audio
*chip
,
236 struct audioformat
*fp
, int nr_triplets
,
237 const unsigned char *data
)
241 fp
->rates
= fp
->rate_min
= fp
->rate_max
= 0;
243 for (i
= 0; i
< nr_triplets
; i
++) {
244 int min
= combine_quad(&data
[2 + 12 * i
]);
245 int max
= combine_quad(&data
[6 + 12 * i
]);
246 int res
= combine_quad(&data
[10 + 12 * i
]);
249 if ((max
< 0) || (min
< 0) || (res
< 0) || (max
< min
))
253 * for ranges with res == 1, we announce a continuous sample
254 * rate range, and this function should return 0 for no further
260 fp
->rates
= SNDRV_PCM_RATE_CONTINUOUS
;
264 for (rate
= min
; rate
<= max
; rate
+= res
) {
266 fp
->rate_table
[nr_rates
] = rate
;
267 if (!fp
->rate_min
|| rate
< fp
->rate_min
)
269 if (!fp
->rate_max
|| rate
> fp
->rate_max
)
271 fp
->rates
|= snd_pcm_rate_to_rate_bit(rate
);
274 if (nr_rates
>= MAX_NR_RATES
) {
275 usb_audio_err(chip
, "invalid uac2 rates\n");
279 /* avoid endless loop */
289 * parse the format descriptor and stores the possible sample rates
290 * on the audioformat table (audio class v2 and v3).
292 static int parse_audio_format_rates_v2v3(struct snd_usb_audio
*chip
,
293 struct audioformat
*fp
)
295 struct usb_device
*dev
= chip
->dev
;
296 unsigned char tmp
[2], *data
;
297 int nr_triplets
, data_size
, ret
= 0;
298 int clock
= snd_usb_clock_find_source(chip
, fp
->protocol
,
303 "%s(): unable to find clock source (clock %d)\n",
308 /* get the number of sample rates first by only fetching 2 bytes */
309 ret
= snd_usb_ctl_msg(dev
, usb_rcvctrlpipe(dev
, 0), UAC2_CS_RANGE
,
310 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
| USB_DIR_IN
,
311 UAC2_CS_CONTROL_SAM_FREQ
<< 8,
312 snd_usb_ctrl_intf(chip
) | (clock
<< 8),
317 "%s(): unable to retrieve number of sample rates (clock %d)\n",
322 nr_triplets
= (tmp
[1] << 8) | tmp
[0];
323 data_size
= 2 + 12 * nr_triplets
;
324 data
= kzalloc(data_size
, GFP_KERNEL
);
330 /* now get the full information */
331 ret
= snd_usb_ctl_msg(dev
, usb_rcvctrlpipe(dev
, 0), UAC2_CS_RANGE
,
332 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
| USB_DIR_IN
,
333 UAC2_CS_CONTROL_SAM_FREQ
<< 8,
334 snd_usb_ctrl_intf(chip
) | (clock
<< 8),
339 "%s(): unable to retrieve sample rate range (clock %d)\n",
345 /* Call the triplet parser, and make sure fp->rate_table is NULL.
346 * We just use the return value to know how many sample rates we
347 * will have to deal with. */
348 kfree(fp
->rate_table
);
349 fp
->rate_table
= NULL
;
350 fp
->nr_rates
= parse_uac2_sample_rate_range(chip
, fp
, nr_triplets
, data
);
352 if (fp
->nr_rates
== 0) {
353 /* SNDRV_PCM_RATE_CONTINUOUS */
358 fp
->rate_table
= kmalloc_array(fp
->nr_rates
, sizeof(int), GFP_KERNEL
);
359 if (!fp
->rate_table
) {
364 /* Call the triplet parser again, but this time, fp->rate_table is
365 * allocated, so the rates will be stored */
366 parse_uac2_sample_rate_range(chip
, fp
, nr_triplets
, data
);
375 * parse the format type I and III descriptors
377 static int parse_audio_format_i(struct snd_usb_audio
*chip
,
378 struct audioformat
*fp
, u64 format
,
381 snd_pcm_format_t pcm_format
;
382 unsigned int fmt_type
;
385 switch (fp
->protocol
) {
388 case UAC_VERSION_2
: {
389 struct uac_format_type_i_continuous_descriptor
*fmt
= _fmt
;
391 fmt_type
= fmt
->bFormatType
;
394 case UAC_VERSION_3
: {
395 /* fp->fmt_type is already set in this case */
396 fmt_type
= fp
->fmt_type
;
401 if (fmt_type
== UAC_FORMAT_TYPE_III
) {
402 /* FIXME: the format type is really IECxxx
403 * but we give normal PCM format to get the existing
406 switch (chip
->usb_id
) {
408 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
409 if (chip
->setup
== 0x00 &&
411 pcm_format
= SNDRV_PCM_FORMAT_S16_BE
;
413 pcm_format
= SNDRV_PCM_FORMAT_S16_LE
;
416 pcm_format
= SNDRV_PCM_FORMAT_S16_LE
;
418 fp
->formats
= pcm_format_to_bits(pcm_format
);
420 fp
->formats
= parse_audio_format_i_type(chip
, fp
, format
, _fmt
);
425 /* gather possible sample rates */
426 /* audio class v1 reports possible sample rates as part of the
427 * proprietary class specific descriptor.
428 * audio class v2 uses class specific EP0 range requests for that.
430 switch (fp
->protocol
) {
432 case UAC_VERSION_1
: {
433 struct uac_format_type_i_continuous_descriptor
*fmt
= _fmt
;
435 fp
->channels
= fmt
->bNrChannels
;
436 ret
= parse_audio_format_rates_v1(chip
, fp
, (unsigned char *) fmt
, 7);
440 case UAC_VERSION_3
: {
441 /* fp->channels is already set in this case */
442 ret
= parse_audio_format_rates_v2v3(chip
, fp
);
447 if (fp
->channels
< 1) {
449 "%u:%d : invalid channels %d\n",
450 fp
->iface
, fp
->altsetting
, fp
->channels
);
458 * parse the format type II descriptor
460 static int parse_audio_format_ii(struct snd_usb_audio
*chip
,
461 struct audioformat
*fp
,
462 u64 format
, void *_fmt
)
464 int brate
, framesize
, ret
;
467 case UAC_FORMAT_TYPE_II_AC3
:
468 /* FIXME: there is no AC3 format defined yet */
469 // fp->formats = SNDRV_PCM_FMTBIT_AC3;
470 fp
->formats
= SNDRV_PCM_FMTBIT_U8
; /* temporary hack to receive byte streams */
472 case UAC_FORMAT_TYPE_II_MPEG
:
473 fp
->formats
= SNDRV_PCM_FMTBIT_MPEG
;
477 "%u:%d : unknown format tag %#llx is detected. processed as MPEG.\n",
478 fp
->iface
, fp
->altsetting
, format
);
479 fp
->formats
= SNDRV_PCM_FMTBIT_MPEG
;
485 switch (fp
->protocol
) {
487 case UAC_VERSION_1
: {
488 struct uac_format_type_ii_discrete_descriptor
*fmt
= _fmt
;
489 brate
= le16_to_cpu(fmt
->wMaxBitRate
);
490 framesize
= le16_to_cpu(fmt
->wSamplesPerFrame
);
491 usb_audio_info(chip
, "found format II with max.bitrate = %d, frame size=%d\n", brate
, framesize
);
492 fp
->frame_size
= framesize
;
493 ret
= parse_audio_format_rates_v1(chip
, fp
, _fmt
, 8); /* fmt[8..] sample rates */
496 case UAC_VERSION_2
: {
497 struct uac_format_type_ii_ext_descriptor
*fmt
= _fmt
;
498 brate
= le16_to_cpu(fmt
->wMaxBitRate
);
499 framesize
= le16_to_cpu(fmt
->wSamplesPerFrame
);
500 usb_audio_info(chip
, "found format II with max.bitrate = %d, frame size=%d\n", brate
, framesize
);
501 fp
->frame_size
= framesize
;
502 ret
= parse_audio_format_rates_v2v3(chip
, fp
);
510 int snd_usb_parse_audio_format(struct snd_usb_audio
*chip
,
511 struct audioformat
*fp
, u64 format
,
512 struct uac_format_type_i_continuous_descriptor
*fmt
,
517 switch (fmt
->bFormatType
) {
518 case UAC_FORMAT_TYPE_I
:
519 case UAC_FORMAT_TYPE_III
:
520 err
= parse_audio_format_i(chip
, fp
, format
, fmt
);
522 case UAC_FORMAT_TYPE_II
:
523 err
= parse_audio_format_ii(chip
, fp
, format
, fmt
);
527 "%u:%d : format type %d is not supported yet\n",
528 fp
->iface
, fp
->altsetting
,
532 fp
->fmt_type
= fmt
->bFormatType
;
536 /* FIXME: temporary hack for extigy/audigy 2 nx/zs */
537 /* extigy apparently supports sample rates other than 48k
538 * but not in ordinary way. so we enable only 48k atm.
540 if (chip
->usb_id
== USB_ID(0x041e, 0x3000) ||
541 chip
->usb_id
== USB_ID(0x041e, 0x3020) ||
542 chip
->usb_id
== USB_ID(0x041e, 0x3061)) {
543 if (fmt
->bFormatType
== UAC_FORMAT_TYPE_I
&&
544 fp
->rates
!= SNDRV_PCM_RATE_48000
&&
545 fp
->rates
!= SNDRV_PCM_RATE_96000
)
552 int snd_usb_parse_audio_format_v3(struct snd_usb_audio
*chip
,
553 struct audioformat
*fp
,
554 struct uac3_as_header_descriptor
*as
,
557 u64 format
= le64_to_cpu(as
->bmFormats
);
561 * Type I format bits are D0..D6
562 * This test works because type IV is not supported
565 fp
->fmt_type
= UAC_FORMAT_TYPE_I
;
567 fp
->fmt_type
= UAC_FORMAT_TYPE_III
;
569 err
= parse_audio_format_i(chip
, fp
, format
, as
);