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>
37 * parse the audio format type I descriptor
38 * and returns the corresponding pcm format
41 * @fp: audioformat record
42 * @format: the format tag (wFormatTag)
43 * @fmt: the format type descriptor (v1/v2) or AudioStreaming descriptor (v3)
45 static u64
parse_audio_format_i_type(struct snd_usb_audio
*chip
,
46 struct audioformat
*fp
,
47 u64 format
, void *_fmt
)
49 int sample_width
, sample_bytes
;
52 switch (fp
->protocol
) {
55 struct uac_format_type_i_discrete_descriptor
*fmt
= _fmt
;
56 sample_width
= fmt
->bBitResolution
;
57 sample_bytes
= fmt
->bSubframeSize
;
58 format
= 1ULL << format
;
63 struct uac_format_type_i_ext_descriptor
*fmt
= _fmt
;
64 sample_width
= fmt
->bBitResolution
;
65 sample_bytes
= fmt
->bSubslotSize
;
67 if (format
& UAC2_FORMAT_TYPE_I_RAW_DATA
)
68 pcm_formats
|= SNDRV_PCM_FMTBIT_SPECIAL
;
74 struct uac3_as_header_descriptor
*as
= _fmt
;
76 sample_width
= as
->bBitResolution
;
77 sample_bytes
= as
->bSubslotSize
;
79 if (format
& UAC3_FORMAT_TYPE_I_RAW_DATA
)
80 pcm_formats
|= SNDRV_PCM_FMTBIT_SPECIAL
;
87 if ((pcm_formats
== 0) &&
88 (format
== 0 || format
== (1 << UAC_FORMAT_TYPE_I_UNDEFINED
))) {
89 /* some devices don't define this correctly... */
90 usb_audio_info(chip
, "%u:%d : format type 0 is detected, processed as PCM\n",
91 fp
->iface
, fp
->altsetting
);
92 format
= 1 << UAC_FORMAT_TYPE_I_PCM
;
94 if (format
& (1 << UAC_FORMAT_TYPE_I_PCM
)) {
95 if (((chip
->usb_id
== USB_ID(0x0582, 0x0016)) ||
97 (chip
->usb_id
== USB_ID(0x0582, 0x000c))) &&
99 sample_width
== 24 && sample_bytes
== 2)
101 else if (sample_width
> sample_bytes
* 8) {
102 usb_audio_info(chip
, "%u:%d : sample bitwidth %d in over sample bytes %d\n",
103 fp
->iface
, fp
->altsetting
,
104 sample_width
, sample_bytes
);
106 /* check the format byte size */
107 switch (sample_bytes
) {
109 pcm_formats
|= SNDRV_PCM_FMTBIT_S8
;
112 if (snd_usb_is_big_endian_format(chip
, fp
))
113 pcm_formats
|= SNDRV_PCM_FMTBIT_S16_BE
; /* grrr, big endian!! */
115 pcm_formats
|= SNDRV_PCM_FMTBIT_S16_LE
;
118 if (snd_usb_is_big_endian_format(chip
, fp
))
119 pcm_formats
|= SNDRV_PCM_FMTBIT_S24_3BE
; /* grrr, big endian!! */
121 pcm_formats
|= SNDRV_PCM_FMTBIT_S24_3LE
;
124 pcm_formats
|= SNDRV_PCM_FMTBIT_S32_LE
;
128 "%u:%d : unsupported sample bitwidth %d in %d bytes\n",
129 fp
->iface
, fp
->altsetting
,
130 sample_width
, sample_bytes
);
134 if (format
& (1 << UAC_FORMAT_TYPE_I_PCM8
)) {
135 /* Dallas DS4201 workaround: it advertises U8 format, but really
137 if (chip
->usb_id
== USB_ID(0x04fa, 0x4201))
138 pcm_formats
|= SNDRV_PCM_FMTBIT_S8
;
140 pcm_formats
|= SNDRV_PCM_FMTBIT_U8
;
142 if (format
& (1 << UAC_FORMAT_TYPE_I_IEEE_FLOAT
)) {
143 pcm_formats
|= SNDRV_PCM_FMTBIT_FLOAT_LE
;
145 if (format
& (1 << UAC_FORMAT_TYPE_I_ALAW
)) {
146 pcm_formats
|= SNDRV_PCM_FMTBIT_A_LAW
;
148 if (format
& (1 << UAC_FORMAT_TYPE_I_MULAW
)) {
149 pcm_formats
|= SNDRV_PCM_FMTBIT_MU_LAW
;
151 if (format
& ~0x3f) {
153 "%u:%d : unsupported format bits %#llx\n",
154 fp
->iface
, fp
->altsetting
, format
);
157 pcm_formats
|= snd_usb_interface_dsd_format_quirks(chip
, fp
, sample_bytes
);
164 * parse the format descriptor and stores the possible sample rates
165 * on the audioformat table (audio class v1).
168 * @fp: audioformat record
169 * @fmt: the format descriptor
170 * @offset: the start offset of descriptor pointing the rate type
171 * (7 for type I and II, 8 for type II)
173 static int parse_audio_format_rates_v1(struct snd_usb_audio
*chip
, struct audioformat
*fp
,
174 unsigned char *fmt
, int offset
)
176 int nr_rates
= fmt
[offset
];
178 if (fmt
[0] < offset
+ 1 + 3 * (nr_rates
? nr_rates
: 2)) {
180 "%u:%d : invalid UAC_FORMAT_TYPE desc\n",
181 fp
->iface
, fp
->altsetting
);
187 * build the rate table and bitmap flags
191 fp
->rate_table
= kmalloc_array(nr_rates
, sizeof(int),
193 if (fp
->rate_table
== NULL
)
197 fp
->rate_min
= fp
->rate_max
= 0;
198 for (r
= 0, idx
= offset
+ 1; r
< nr_rates
; r
++, idx
+= 3) {
199 unsigned int rate
= combine_triple(&fmt
[idx
]);
202 /* C-Media CM6501 mislabels its 96 kHz altsetting */
203 /* Terratec Aureon 7.1 USB C-Media 6206, too */
204 if (rate
== 48000 && nr_rates
== 1 &&
205 (chip
->usb_id
== USB_ID(0x0d8c, 0x0201) ||
206 chip
->usb_id
== USB_ID(0x0d8c, 0x0102) ||
207 chip
->usb_id
== USB_ID(0x0ccd, 0x00b1)) &&
208 fp
->altsetting
== 5 && fp
->maxpacksize
== 392)
210 /* Creative VF0420/VF0470 Live Cams report 16 kHz instead of 8kHz */
212 (chip
->usb_id
== USB_ID(0x041e, 0x4064) ||
213 chip
->usb_id
== USB_ID(0x041e, 0x4068)))
216 fp
->rate_table
[fp
->nr_rates
] = rate
;
217 if (!fp
->rate_min
|| rate
< fp
->rate_min
)
219 if (!fp
->rate_max
|| rate
> fp
->rate_max
)
221 fp
->rates
|= snd_pcm_rate_to_rate_bit(rate
);
225 hwc_debug("All rates were zero. Skipping format!\n");
229 /* continuous rates */
230 fp
->rates
= SNDRV_PCM_RATE_CONTINUOUS
;
231 fp
->rate_min
= combine_triple(&fmt
[offset
+ 1]);
232 fp
->rate_max
= combine_triple(&fmt
[offset
+ 4]);
238 * Helper function to walk the array of sample rate triplets reported by
239 * the device. The problem is that we need to parse whole array first to
240 * get to know how many sample rates we have to expect.
241 * Then fp->rate_table can be allocated and filled.
243 static int parse_uac2_sample_rate_range(struct snd_usb_audio
*chip
,
244 struct audioformat
*fp
, int nr_triplets
,
245 const unsigned char *data
)
249 fp
->rates
= fp
->rate_min
= fp
->rate_max
= 0;
251 for (i
= 0; i
< nr_triplets
; i
++) {
252 int min
= combine_quad(&data
[2 + 12 * i
]);
253 int max
= combine_quad(&data
[6 + 12 * i
]);
254 int res
= combine_quad(&data
[10 + 12 * i
]);
257 if ((max
< 0) || (min
< 0) || (res
< 0) || (max
< min
))
261 * for ranges with res == 1, we announce a continuous sample
262 * rate range, and this function should return 0 for no further
268 fp
->rates
= SNDRV_PCM_RATE_CONTINUOUS
;
272 for (rate
= min
; rate
<= max
; rate
+= res
) {
274 fp
->rate_table
[nr_rates
] = rate
;
275 if (!fp
->rate_min
|| rate
< fp
->rate_min
)
277 if (!fp
->rate_max
|| rate
> fp
->rate_max
)
279 fp
->rates
|= snd_pcm_rate_to_rate_bit(rate
);
282 if (nr_rates
>= MAX_NR_RATES
) {
283 usb_audio_err(chip
, "invalid uac2 rates\n");
287 /* avoid endless loop */
297 * parse the format descriptor and stores the possible sample rates
298 * on the audioformat table (audio class v2 and v3).
300 static int parse_audio_format_rates_v2v3(struct snd_usb_audio
*chip
,
301 struct audioformat
*fp
)
303 struct usb_device
*dev
= chip
->dev
;
304 unsigned char tmp
[2], *data
;
305 int nr_triplets
, data_size
, ret
= 0;
306 int clock
= snd_usb_clock_find_source(chip
, fp
->protocol
,
311 "%s(): unable to find clock source (clock %d)\n",
316 /* get the number of sample rates first by only fetching 2 bytes */
317 ret
= snd_usb_ctl_msg(dev
, usb_rcvctrlpipe(dev
, 0), UAC2_CS_RANGE
,
318 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
| USB_DIR_IN
,
319 UAC2_CS_CONTROL_SAM_FREQ
<< 8,
320 snd_usb_ctrl_intf(chip
) | (clock
<< 8),
325 "%s(): unable to retrieve number of sample rates (clock %d)\n",
330 nr_triplets
= (tmp
[1] << 8) | tmp
[0];
331 data_size
= 2 + 12 * nr_triplets
;
332 data
= kzalloc(data_size
, GFP_KERNEL
);
338 /* now get the full information */
339 ret
= snd_usb_ctl_msg(dev
, usb_rcvctrlpipe(dev
, 0), UAC2_CS_RANGE
,
340 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
| USB_DIR_IN
,
341 UAC2_CS_CONTROL_SAM_FREQ
<< 8,
342 snd_usb_ctrl_intf(chip
) | (clock
<< 8),
347 "%s(): unable to retrieve sample rate range (clock %d)\n",
353 /* Call the triplet parser, and make sure fp->rate_table is NULL.
354 * We just use the return value to know how many sample rates we
355 * will have to deal with. */
356 kfree(fp
->rate_table
);
357 fp
->rate_table
= NULL
;
358 fp
->nr_rates
= parse_uac2_sample_rate_range(chip
, fp
, nr_triplets
, data
);
360 if (fp
->nr_rates
== 0) {
361 /* SNDRV_PCM_RATE_CONTINUOUS */
366 fp
->rate_table
= kmalloc_array(fp
->nr_rates
, sizeof(int), GFP_KERNEL
);
367 if (!fp
->rate_table
) {
372 /* Call the triplet parser again, but this time, fp->rate_table is
373 * allocated, so the rates will be stored */
374 parse_uac2_sample_rate_range(chip
, fp
, nr_triplets
, data
);
383 * parse the format type I and III descriptors
385 static int parse_audio_format_i(struct snd_usb_audio
*chip
,
386 struct audioformat
*fp
, u64 format
,
389 snd_pcm_format_t pcm_format
;
390 unsigned int fmt_type
;
393 switch (fp
->protocol
) {
396 case UAC_VERSION_2
: {
397 struct uac_format_type_i_continuous_descriptor
*fmt
= _fmt
;
399 fmt_type
= fmt
->bFormatType
;
402 case UAC_VERSION_3
: {
403 /* fp->fmt_type is already set in this case */
404 fmt_type
= fp
->fmt_type
;
409 if (fmt_type
== UAC_FORMAT_TYPE_III
) {
410 /* FIXME: the format type is really IECxxx
411 * but we give normal PCM format to get the existing
414 switch (chip
->usb_id
) {
416 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
417 if (chip
->setup
== 0x00 &&
419 pcm_format
= SNDRV_PCM_FORMAT_S16_BE
;
421 pcm_format
= SNDRV_PCM_FORMAT_S16_LE
;
424 pcm_format
= SNDRV_PCM_FORMAT_S16_LE
;
426 fp
->formats
= pcm_format_to_bits(pcm_format
);
428 fp
->formats
= parse_audio_format_i_type(chip
, fp
, format
, _fmt
);
433 /* gather possible sample rates */
434 /* audio class v1 reports possible sample rates as part of the
435 * proprietary class specific descriptor.
436 * audio class v2 uses class specific EP0 range requests for that.
438 switch (fp
->protocol
) {
440 case UAC_VERSION_1
: {
441 struct uac_format_type_i_continuous_descriptor
*fmt
= _fmt
;
443 fp
->channels
= fmt
->bNrChannels
;
444 ret
= parse_audio_format_rates_v1(chip
, fp
, (unsigned char *) fmt
, 7);
448 case UAC_VERSION_3
: {
449 /* fp->channels is already set in this case */
450 ret
= parse_audio_format_rates_v2v3(chip
, fp
);
455 if (fp
->channels
< 1) {
457 "%u:%d : invalid channels %d\n",
458 fp
->iface
, fp
->altsetting
, fp
->channels
);
466 * parse the format type II descriptor
468 static int parse_audio_format_ii(struct snd_usb_audio
*chip
,
469 struct audioformat
*fp
,
470 u64 format
, void *_fmt
)
472 int brate
, framesize
, ret
;
475 case UAC_FORMAT_TYPE_II_AC3
:
476 /* FIXME: there is no AC3 format defined yet */
477 // fp->formats = SNDRV_PCM_FMTBIT_AC3;
478 fp
->formats
= SNDRV_PCM_FMTBIT_U8
; /* temporary hack to receive byte streams */
480 case UAC_FORMAT_TYPE_II_MPEG
:
481 fp
->formats
= SNDRV_PCM_FMTBIT_MPEG
;
485 "%u:%d : unknown format tag %#llx is detected. processed as MPEG.\n",
486 fp
->iface
, fp
->altsetting
, format
);
487 fp
->formats
= SNDRV_PCM_FMTBIT_MPEG
;
493 switch (fp
->protocol
) {
495 case UAC_VERSION_1
: {
496 struct uac_format_type_ii_discrete_descriptor
*fmt
= _fmt
;
497 brate
= le16_to_cpu(fmt
->wMaxBitRate
);
498 framesize
= le16_to_cpu(fmt
->wSamplesPerFrame
);
499 usb_audio_info(chip
, "found format II with max.bitrate = %d, frame size=%d\n", brate
, framesize
);
500 fp
->frame_size
= framesize
;
501 ret
= parse_audio_format_rates_v1(chip
, fp
, _fmt
, 8); /* fmt[8..] sample rates */
504 case UAC_VERSION_2
: {
505 struct uac_format_type_ii_ext_descriptor
*fmt
= _fmt
;
506 brate
= le16_to_cpu(fmt
->wMaxBitRate
);
507 framesize
= le16_to_cpu(fmt
->wSamplesPerFrame
);
508 usb_audio_info(chip
, "found format II with max.bitrate = %d, frame size=%d\n", brate
, framesize
);
509 fp
->frame_size
= framesize
;
510 ret
= parse_audio_format_rates_v2v3(chip
, fp
);
518 int snd_usb_parse_audio_format(struct snd_usb_audio
*chip
,
519 struct audioformat
*fp
, u64 format
,
520 struct uac_format_type_i_continuous_descriptor
*fmt
,
525 switch (fmt
->bFormatType
) {
526 case UAC_FORMAT_TYPE_I
:
527 case UAC_FORMAT_TYPE_III
:
528 err
= parse_audio_format_i(chip
, fp
, format
, fmt
);
530 case UAC_FORMAT_TYPE_II
:
531 err
= parse_audio_format_ii(chip
, fp
, format
, fmt
);
535 "%u:%d : format type %d is not supported yet\n",
536 fp
->iface
, fp
->altsetting
,
540 fp
->fmt_type
= fmt
->bFormatType
;
544 /* FIXME: temporary hack for extigy/audigy 2 nx/zs */
545 /* extigy apparently supports sample rates other than 48k
546 * but not in ordinary way. so we enable only 48k atm.
548 if (chip
->usb_id
== USB_ID(0x041e, 0x3000) ||
549 chip
->usb_id
== USB_ID(0x041e, 0x3020) ||
550 chip
->usb_id
== USB_ID(0x041e, 0x3061)) {
551 if (fmt
->bFormatType
== UAC_FORMAT_TYPE_I
&&
552 fp
->rates
!= SNDRV_PCM_RATE_48000
&&
553 fp
->rates
!= SNDRV_PCM_RATE_96000
)
560 int snd_usb_parse_audio_format_v3(struct snd_usb_audio
*chip
,
561 struct audioformat
*fp
,
562 struct uac3_as_header_descriptor
*as
,
565 u64 format
= le64_to_cpu(as
->bmFormats
);
569 * Type I format bits are D0..D6
570 * This test works because type IV is not supported
573 fp
->fmt_type
= UAC_FORMAT_TYPE_I
;
575 fp
->fmt_type
= UAC_FORMAT_TYPE_III
;
577 err
= parse_audio_format_i(chip
, fp
, format
, as
);