1 /*
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.
6 *
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.
11 *
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
15 *
16 */
17
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
24 #include <sound/core.h>
25 #include <sound/pcm.h>
26
27 #include "usbaudio.h"
28 #include "card.h"
29 #include "quirks.h"
30 #include "helper.h"
31 #include "debug.h"
32 #include "clock.h"
33
34 /*
35 * parse the audio format type I descriptor
36 * and returns the corresponding pcm format
37 *
38 * @dev: usb device
39 * @fp: audioformat record
40 * @format: the format tag (wFormatTag)
41 * @fmt: the format type descriptor
42 */
parse_audio_format_i_type(struct snd_usb_audio * chip,struct audioformat * fp,int format,void * _fmt,int protocol)43 static u64 parse_audio_format_i_type(struct snd_usb_audio *chip,
44 struct audioformat *fp,
45 int format, void *_fmt,
46 int protocol)
47 {
48 int sample_width, sample_bytes;
49 u64 pcm_formats;
50
51 switch (protocol) {
52 case UAC_VERSION_1:
53 default: {
54 struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
55 sample_width = fmt->bBitResolution;
56 sample_bytes = fmt->bSubframeSize;
57 format = 1 << format;
58 break;
59 }
60
61 case UAC_VERSION_2: {
62 struct uac_format_type_i_ext_descriptor *fmt = _fmt;
63 sample_width = fmt->bBitResolution;
64 sample_bytes = fmt->bSubslotSize;
65 format <<= 1;
66 break;
67 }
68 }
69
70 pcm_formats = 0;
71
72 if (format == 0 || format == (1 << UAC_FORMAT_TYPE_I_UNDEFINED)) {
73 /* some devices don't define this correctly... */
74 snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n",
75 chip->dev->devnum, fp->iface, fp->altsetting);
76 format = 1 << UAC_FORMAT_TYPE_I_PCM;
77 }
78 if (format & (1 << UAC_FORMAT_TYPE_I_PCM)) {
79 if (chip->usb_id == USB_ID(0x0582, 0x0016) /* Edirol SD-90 */ &&
80 sample_width == 24 && sample_bytes == 2)
81 sample_bytes = 3;
82 else if (sample_width > sample_bytes * 8) {
83 snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",
84 chip->dev->devnum, fp->iface, fp->altsetting,
85 sample_width, sample_bytes);
86 }
87 /* check the format byte size */
88 switch (sample_bytes) {
89 case 1:
90 pcm_formats |= SNDRV_PCM_FMTBIT_S8;
91 break;
92 case 2:
93 if (snd_usb_is_big_endian_format(chip, fp))
94 pcm_formats |= SNDRV_PCM_FMTBIT_S16_BE; /* grrr, big endian!! */
95 else
96 pcm_formats |= SNDRV_PCM_FMTBIT_S16_LE;
97 break;
98 case 3:
99 if (snd_usb_is_big_endian_format(chip, fp))
100 pcm_formats |= SNDRV_PCM_FMTBIT_S24_3BE; /* grrr, big endian!! */
101 else
102 pcm_formats |= SNDRV_PCM_FMTBIT_S24_3LE;
103 break;
104 case 4:
105 pcm_formats |= SNDRV_PCM_FMTBIT_S32_LE;
106 break;
107 default:
108 snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
109 chip->dev->devnum, fp->iface, fp->altsetting,
110 sample_width, sample_bytes);
111 break;
112 }
113 }
114 if (format & (1 << UAC_FORMAT_TYPE_I_PCM8)) {
115 /* Dallas DS4201 workaround: it advertises U8 format, but really
116 supports S8. */
117 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
118 pcm_formats |= SNDRV_PCM_FMTBIT_S8;
119 else
120 pcm_formats |= SNDRV_PCM_FMTBIT_U8;
121 }
122 if (format & (1 << UAC_FORMAT_TYPE_I_IEEE_FLOAT)) {
123 pcm_formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
124 }
125 if (format & (1 << UAC_FORMAT_TYPE_I_ALAW)) {
126 pcm_formats |= SNDRV_PCM_FMTBIT_A_LAW;
127 }
128 if (format & (1 << UAC_FORMAT_TYPE_I_MULAW)) {
129 pcm_formats |= SNDRV_PCM_FMTBIT_MU_LAW;
130 }
131 if (format & ~0x3f) {
132 snd_printk(KERN_INFO "%d:%u:%d : unsupported format bits %#x\n",
133 chip->dev->devnum, fp->iface, fp->altsetting, format);
134 }
135 return pcm_formats;
136 }
137
138
139 /*
140 * parse the format descriptor and stores the possible sample rates
141 * on the audioformat table (audio class v1).
142 *
143 * @dev: usb device
144 * @fp: audioformat record
145 * @fmt: the format descriptor
146 * @offset: the start offset of descriptor pointing the rate type
147 * (7 for type I and II, 8 for type II)
148 */
parse_audio_format_rates_v1(struct snd_usb_audio * chip,struct audioformat * fp,unsigned char * fmt,int offset)149 static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audioformat *fp,
150 unsigned char *fmt, int offset)
151 {
152 int nr_rates = fmt[offset];
153
154 if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
155 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
156 chip->dev->devnum, fp->iface, fp->altsetting);
157 return -1;
158 }
159
160 if (nr_rates) {
161 /*
162 * build the rate table and bitmap flags
163 */
164 int r, idx;
165
166 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
167 if (fp->rate_table == NULL) {
168 snd_printk(KERN_ERR "cannot malloc\n");
169 return -1;
170 }
171
172 fp->nr_rates = 0;
173 fp->rate_min = fp->rate_max = 0;
174 for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) {
175 unsigned int rate = combine_triple(&fmt[idx]);
176 if (!rate)
177 continue;
178 /* C-Media CM6501 mislabels its 96 kHz altsetting */
179 /* Terratec Aureon 7.1 USB C-Media 6206, too */
180 if (rate == 48000 && nr_rates == 1 &&
181 (chip->usb_id == USB_ID(0x0d8c, 0x0201) ||
182 chip->usb_id == USB_ID(0x0d8c, 0x0102) ||
183 chip->usb_id == USB_ID(0x0ccd, 0x00b1)) &&
184 fp->altsetting == 5 && fp->maxpacksize == 392)
185 rate = 96000;
186 /* Creative VF0470 Live Cam reports 16 kHz instead of 8kHz */
187 if (rate == 16000 && chip->usb_id == USB_ID(0x041e, 0x4068))
188 rate = 8000;
189
190 fp->rate_table[fp->nr_rates] = rate;
191 if (!fp->rate_min || rate < fp->rate_min)
192 fp->rate_min = rate;
193 if (!fp->rate_max || rate > fp->rate_max)
194 fp->rate_max = rate;
195 fp->rates |= snd_pcm_rate_to_rate_bit(rate);
196 fp->nr_rates++;
197 }
198 if (!fp->nr_rates) {
199 hwc_debug("All rates were zero. Skipping format!\n");
200 return -1;
201 }
202 } else {
203 /* continuous rates */
204 fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
205 fp->rate_min = combine_triple(&fmt[offset + 1]);
206 fp->rate_max = combine_triple(&fmt[offset + 4]);
207 }
208 return 0;
209 }
210
211 /*
212 * Helper function to walk the array of sample rate triplets reported by
213 * the device. The problem is that we need to parse whole array first to
214 * get to know how many sample rates we have to expect.
215 * Then fp->rate_table can be allocated and filled.
216 */
parse_uac2_sample_rate_range(struct audioformat * fp,int nr_triplets,const unsigned char * data)217 static int parse_uac2_sample_rate_range(struct audioformat *fp, int nr_triplets,
218 const unsigned char *data)
219 {
220 int i, nr_rates = 0;
221
222 fp->rates = fp->rate_min = fp->rate_max = 0;
223
224 for (i = 0; i < nr_triplets; i++) {
225 int min = combine_quad(&data[2 + 12 * i]);
226 int max = combine_quad(&data[6 + 12 * i]);
227 int res = combine_quad(&data[10 + 12 * i]);
228 int rate;
229
230 if ((max < 0) || (min < 0) || (res < 0) || (max < min))
231 continue;
232
233 /*
234 * for ranges with res == 1, we announce a continuous sample
235 * rate range, and this function should return 0 for no further
236 * parsing.
237 */
238 if (res == 1) {
239 fp->rate_min = min;
240 fp->rate_max = max;
241 fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
242 return 0;
243 }
244
245 for (rate = min; rate <= max; rate += res) {
246 if (fp->rate_table)
247 fp->rate_table[nr_rates] = rate;
248 if (!fp->rate_min || rate < fp->rate_min)
249 fp->rate_min = rate;
250 if (!fp->rate_max || rate > fp->rate_max)
251 fp->rate_max = rate;
252 fp->rates |= snd_pcm_rate_to_rate_bit(rate);
253
254 nr_rates++;
255
256 /* avoid endless loop */
257 if (res == 0)
258 break;
259 }
260 }
261
262 return nr_rates;
263 }
264
265 /*
266 * parse the format descriptor and stores the possible sample rates
267 * on the audioformat table (audio class v2).
268 */
parse_audio_format_rates_v2(struct snd_usb_audio * chip,struct audioformat * fp)269 static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
270 struct audioformat *fp)
271 {
272 struct usb_device *dev = chip->dev;
273 unsigned char tmp[2], *data;
274 int nr_triplets, data_size, ret = 0;
275 int clock = snd_usb_clock_find_source(chip, fp->clock);
276
277 if (clock < 0) {
278 snd_printk(KERN_ERR "%s(): unable to find clock source (clock %d)\n",
279 __func__, clock);
280 goto err;
281 }
282
283 /* get the number of sample rates first by only fetching 2 bytes */
284 ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
285 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
286 UAC2_CS_CONTROL_SAM_FREQ << 8,
287 snd_usb_ctrl_intf(chip) | (clock << 8),
288 tmp, sizeof(tmp), 1000);
289
290 if (ret < 0) {
291 snd_printk(KERN_ERR "%s(): unable to retrieve number of sample rates (clock %d)\n",
292 __func__, clock);
293 goto err;
294 }
295
296 nr_triplets = (tmp[1] << 8) | tmp[0];
297 data_size = 2 + 12 * nr_triplets;
298 data = kzalloc(data_size, GFP_KERNEL);
299 if (!data) {
300 ret = -ENOMEM;
301 goto err;
302 }
303
304 /* now get the full information */
305 ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
306 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
307 UAC2_CS_CONTROL_SAM_FREQ << 8,
308 snd_usb_ctrl_intf(chip) | (clock << 8),
309 data, data_size, 1000);
310
311 if (ret < 0) {
312 snd_printk(KERN_ERR "%s(): unable to retrieve sample rate range (clock %d)\n",
313 __func__, clock);
314 ret = -EINVAL;
315 goto err_free;
316 }
317
318 /* Call the triplet parser, and make sure fp->rate_table is NULL.
319 * We just use the return value to know how many sample rates we
320 * will have to deal with. */
321 kfree(fp->rate_table);
322 fp->rate_table = NULL;
323 fp->nr_rates = parse_uac2_sample_rate_range(fp, nr_triplets, data);
324
325 if (fp->nr_rates == 0) {
326 /* SNDRV_PCM_RATE_CONTINUOUS */
327 ret = 0;
328 goto err_free;
329 }
330
331 fp->rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL);
332 if (!fp->rate_table) {
333 ret = -ENOMEM;
334 goto err_free;
335 }
336
337 /* Call the triplet parser again, but this time, fp->rate_table is
338 * allocated, so the rates will be stored */
339 parse_uac2_sample_rate_range(fp, nr_triplets, data);
340
341 err_free:
342 kfree(data);
343 err:
344 return ret;
345 }
346
347 /*
348 * parse the format type I and III descriptors
349 */
parse_audio_format_i(struct snd_usb_audio * chip,struct audioformat * fp,int format,struct uac_format_type_i_continuous_descriptor * fmt,struct usb_host_interface * iface)350 static int parse_audio_format_i(struct snd_usb_audio *chip,
351 struct audioformat *fp, int format,
352 struct uac_format_type_i_continuous_descriptor *fmt,
353 struct usb_host_interface *iface)
354 {
355 struct usb_interface_descriptor *altsd = get_iface_desc(iface);
356 int protocol = altsd->bInterfaceProtocol;
357 int pcm_format, ret;
358
359 if (fmt->bFormatType == UAC_FORMAT_TYPE_III) {
360 /* FIXME: the format type is really IECxxx
361 * but we give normal PCM format to get the existing
362 * apps working...
363 */
364 switch (chip->usb_id) {
365
366 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
367 if (chip->setup == 0x00 &&
368 fp->altsetting == 6)
369 pcm_format = SNDRV_PCM_FORMAT_S16_BE;
370 else
371 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
372 break;
373 default:
374 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
375 }
376 fp->formats = 1uLL << pcm_format;
377 } else {
378 fp->formats = parse_audio_format_i_type(chip, fp, format,
379 fmt, protocol);
380 if (!fp->formats)
381 return -1;
382 }
383
384 /* gather possible sample rates */
385 /* audio class v1 reports possible sample rates as part of the
386 * proprietary class specific descriptor.
387 * audio class v2 uses class specific EP0 range requests for that.
388 */
389 switch (protocol) {
390 default:
391 snd_printdd(KERN_WARNING "%d:%u:%d : invalid protocol version %d, assuming v1\n",
392 chip->dev->devnum, fp->iface, fp->altsetting, protocol);
393 /* fall through */
394 case UAC_VERSION_1:
395 fp->channels = fmt->bNrChannels;
396 ret = parse_audio_format_rates_v1(chip, fp, (unsigned char *) fmt, 7);
397 break;
398 case UAC_VERSION_2:
399 /* fp->channels is already set in this case */
400 ret = parse_audio_format_rates_v2(chip, fp);
401 break;
402 }
403
404 if (fp->channels < 1) {
405 snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
406 chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);
407 return -1;
408 }
409
410 return ret;
411 }
412
413 /*
414 * parse the format type II descriptor
415 */
parse_audio_format_ii(struct snd_usb_audio * chip,struct audioformat * fp,int format,void * _fmt,struct usb_host_interface * iface)416 static int parse_audio_format_ii(struct snd_usb_audio *chip,
417 struct audioformat *fp,
418 int format, void *_fmt,
419 struct usb_host_interface *iface)
420 {
421 int brate, framesize, ret;
422 struct usb_interface_descriptor *altsd = get_iface_desc(iface);
423 int protocol = altsd->bInterfaceProtocol;
424
425 switch (format) {
426 case UAC_FORMAT_TYPE_II_AC3:
427 /* FIXME: there is no AC3 format defined yet */
428 // fp->formats = SNDRV_PCM_FMTBIT_AC3;
429 fp->formats = SNDRV_PCM_FMTBIT_U8; /* temporary hack to receive byte streams */
430 break;
431 case UAC_FORMAT_TYPE_II_MPEG:
432 fp->formats = SNDRV_PCM_FMTBIT_MPEG;
433 break;
434 default:
435 snd_printd(KERN_INFO "%d:%u:%d : unknown format tag %#x is detected. processed as MPEG.\n",
436 chip->dev->devnum, fp->iface, fp->altsetting, format);
437 fp->formats = SNDRV_PCM_FMTBIT_MPEG;
438 break;
439 }
440
441 fp->channels = 1;
442
443 switch (protocol) {
444 default:
445 snd_printdd(KERN_WARNING "%d:%u:%d : invalid protocol version %d, assuming v1\n",
446 chip->dev->devnum, fp->iface, fp->altsetting, protocol);
447 /* fall through */
448 case UAC_VERSION_1: {
449 struct uac_format_type_ii_discrete_descriptor *fmt = _fmt;
450 brate = le16_to_cpu(fmt->wMaxBitRate);
451 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
452 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
453 fp->frame_size = framesize;
454 ret = parse_audio_format_rates_v1(chip, fp, _fmt, 8); /* fmt[8..] sample rates */
455 break;
456 }
457 case UAC_VERSION_2: {
458 struct uac_format_type_ii_ext_descriptor *fmt = _fmt;
459 brate = le16_to_cpu(fmt->wMaxBitRate);
460 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
461 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
462 fp->frame_size = framesize;
463 ret = parse_audio_format_rates_v2(chip, fp);
464 break;
465 }
466 }
467
468 return ret;
469 }
470
snd_usb_parse_audio_format(struct snd_usb_audio * chip,struct audioformat * fp,int format,struct uac_format_type_i_continuous_descriptor * fmt,int stream,struct usb_host_interface * iface)471 int snd_usb_parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp,
472 int format, struct uac_format_type_i_continuous_descriptor *fmt,
473 int stream, struct usb_host_interface *iface)
474 {
475 int err;
476
477 switch (fmt->bFormatType) {
478 case UAC_FORMAT_TYPE_I:
479 case UAC_FORMAT_TYPE_III:
480 err = parse_audio_format_i(chip, fp, format, fmt, iface);
481 break;
482 case UAC_FORMAT_TYPE_II:
483 err = parse_audio_format_ii(chip, fp, format, fmt, iface);
484 break;
485 default:
486 snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
487 chip->dev->devnum, fp->iface, fp->altsetting,
488 fmt->bFormatType);
489 return -ENOTSUPP;
490 }
491 fp->fmt_type = fmt->bFormatType;
492 if (err < 0)
493 return err;
494 #if 1
495 /* FIXME: temporary hack for extigy/audigy 2 nx/zs */
496 /* extigy apparently supports sample rates other than 48k
497 * but not in ordinary way. so we enable only 48k atm.
498 */
499 if (chip->usb_id == USB_ID(0x041e, 0x3000) ||
500 chip->usb_id == USB_ID(0x041e, 0x3020) ||
501 chip->usb_id == USB_ID(0x041e, 0x3061)) {
502 if (fmt->bFormatType == UAC_FORMAT_TYPE_I &&
503 fp->rates != SNDRV_PCM_RATE_48000 &&
504 fp->rates != SNDRV_PCM_RATE_96000)
505 return -ENOTSUPP;
506 }
507 #endif
508 return 0;
509 }
510
511