fcadedd94543da4bbfcff08fa45d55fd05d9f3da
[linux-2.6.git] / sound / usb / format.c
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/usb.h>
20 #include <linux/usb/audio.h>
21 #include <linux/usb/audio-v2.h>
22
23 #include <sound/core.h>
24 #include <sound/pcm.h>
25
26 #include "usbaudio.h"
27 #include "card.h"
28 #include "quirks.h"
29 #include "helper.h"
30 #include "debug.h"
31
32 /*
33  * parse the audio format type I descriptor
34  * and returns the corresponding pcm format
35  *
36  * @dev: usb device
37  * @fp: audioformat record
38  * @format: the format tag (wFormatTag)
39  * @fmt: the format type descriptor
40  */
41 static u64 parse_audio_format_i_type(struct snd_usb_audio *chip,
42                                      struct audioformat *fp,
43                                      int format, void *_fmt,
44                                      int protocol)
45 {
46         int sample_width, sample_bytes;
47         u64 pcm_formats;
48
49         switch (protocol) {
50         case UAC_VERSION_1: {
51                 struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
52                 sample_width = fmt->bBitResolution;
53                 sample_bytes = fmt->bSubframeSize;
54                 format = 1 << format;
55                 break;
56         }
57
58         case UAC_VERSION_2: {
59                 struct uac_format_type_i_ext_descriptor *fmt = _fmt;
60                 sample_width = fmt->bBitResolution;
61                 sample_bytes = fmt->bSubslotSize;
62                 format <<= 1;
63                 break;
64         }
65
66         default:
67                 return -EINVAL;
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 (sample_width > sample_bytes * 8) {
80                         snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",
81                                    chip->dev->devnum, fp->iface, fp->altsetting,
82                                    sample_width, sample_bytes);
83                 }
84                 /* check the format byte size */
85                 switch (sample_bytes) {
86                 case 1:
87                         pcm_formats |= SNDRV_PCM_FMTBIT_S8;
88                         break;
89                 case 2:
90                         if (snd_usb_is_big_endian_format(chip, fp))
91                                 pcm_formats |= SNDRV_PCM_FMTBIT_S16_BE; /* grrr, big endian!! */
92                         else
93                                 pcm_formats |= SNDRV_PCM_FMTBIT_S16_LE;
94                         break;
95                 case 3:
96                         if (snd_usb_is_big_endian_format(chip, fp))
97                                 pcm_formats |= SNDRV_PCM_FMTBIT_S24_3BE; /* grrr, big endian!! */
98                         else
99                                 pcm_formats |= SNDRV_PCM_FMTBIT_S24_3LE;
100                         break;
101                 case 4:
102                         pcm_formats |= SNDRV_PCM_FMTBIT_S32_LE;
103                         break;
104                 default:
105                         snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
106                                    chip->dev->devnum, fp->iface, fp->altsetting,
107                                    sample_width, sample_bytes);
108                         break;
109                 }
110         }
111         if (format & (1 << UAC_FORMAT_TYPE_I_PCM8)) {
112                 /* Dallas DS4201 workaround: it advertises U8 format, but really
113                    supports S8. */
114                 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
115                         pcm_formats |= SNDRV_PCM_FMTBIT_S8;
116                 else
117                         pcm_formats |= SNDRV_PCM_FMTBIT_U8;
118         }
119         if (format & (1 << UAC_FORMAT_TYPE_I_IEEE_FLOAT)) {
120                 pcm_formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;
121         }
122         if (format & (1 << UAC_FORMAT_TYPE_I_ALAW)) {
123                 pcm_formats |= SNDRV_PCM_FMTBIT_A_LAW;
124         }
125         if (format & (1 << UAC_FORMAT_TYPE_I_MULAW)) {
126                 pcm_formats |= SNDRV_PCM_FMTBIT_MU_LAW;
127         }
128         if (format & ~0x3f) {
129                 snd_printk(KERN_INFO "%d:%u:%d : unsupported format bits %#x\n",
130                            chip->dev->devnum, fp->iface, fp->altsetting, format);
131         }
132         return pcm_formats;
133 }
134
135
136 /*
137  * parse the format descriptor and stores the possible sample rates
138  * on the audioformat table (audio class v1).
139  *
140  * @dev: usb device
141  * @fp: audioformat record
142  * @fmt: the format descriptor
143  * @offset: the start offset of descriptor pointing the rate type
144  *          (7 for type I and II, 8 for type II)
145  */
146 static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audioformat *fp,
147                                        unsigned char *fmt, int offset)
148 {
149         int nr_rates = fmt[offset];
150
151         if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
152                 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
153                                    chip->dev->devnum, fp->iface, fp->altsetting);
154                 return -1;
155         }
156
157         if (nr_rates) {
158                 /*
159                  * build the rate table and bitmap flags
160                  */
161                 int r, idx;
162
163                 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
164                 if (fp->rate_table == NULL) {
165                         snd_printk(KERN_ERR "cannot malloc\n");
166                         return -1;
167                 }
168
169                 fp->nr_rates = 0;
170                 fp->rate_min = fp->rate_max = 0;
171                 for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) {
172                         unsigned int rate = combine_triple(&fmt[idx]);
173                         if (!rate)
174                                 continue;
175                         /* C-Media CM6501 mislabels its 96 kHz altsetting */
176                         if (rate == 48000 && nr_rates == 1 &&
177                             (chip->usb_id == USB_ID(0x0d8c, 0x0201) ||
178                              chip->usb_id == USB_ID(0x0d8c, 0x0102)) &&
179                             fp->altsetting == 5 && fp->maxpacksize == 392)
180                                 rate = 96000;
181                         /* Creative VF0470 Live Cam reports 16 kHz instead of 8kHz */
182                         if (rate == 16000 && chip->usb_id == USB_ID(0x041e, 0x4068))
183                                 rate = 8000;
184
185                         fp->rate_table[fp->nr_rates] = rate;
186                         if (!fp->rate_min || rate < fp->rate_min)
187                                 fp->rate_min = rate;
188                         if (!fp->rate_max || rate > fp->rate_max)
189                                 fp->rate_max = rate;
190                         fp->rates |= snd_pcm_rate_to_rate_bit(rate);
191                         fp->nr_rates++;
192                 }
193                 if (!fp->nr_rates) {
194                         hwc_debug("All rates were zero. Skipping format!\n");
195                         return -1;
196                 }
197         } else {
198                 /* continuous rates */
199                 fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
200                 fp->rate_min = combine_triple(&fmt[offset + 1]);
201                 fp->rate_max = combine_triple(&fmt[offset + 4]);
202         }
203         return 0;
204 }
205
206 /*
207  * parse the format descriptor and stores the possible sample rates
208  * on the audioformat table (audio class v2).
209  */
210 static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
211                                        struct audioformat *fp,
212                                        struct usb_host_interface *iface)
213 {
214         struct usb_device *dev = chip->dev;
215         unsigned char tmp[2], *data;
216         int i, nr_rates, data_size, ret = 0;
217
218         /* get the number of sample rates first by only fetching 2 bytes */
219         ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
220                               USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
221                               UAC2_CS_CONTROL_SAM_FREQ << 8, chip->clock_id << 8,
222                               tmp, sizeof(tmp), 1000);
223
224         if (ret < 0) {
225                 snd_printk(KERN_ERR "unable to retrieve number of sample rates\n");
226                 goto err;
227         }
228
229         nr_rates = (tmp[1] << 8) | tmp[0];
230         data_size = 2 + 12 * nr_rates;
231         data = kzalloc(data_size, GFP_KERNEL);
232         if (!data) {
233                 ret = -ENOMEM;
234                 goto err;
235         }
236
237         /* now get the full information */
238         ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
239                                USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
240                                UAC2_CS_CONTROL_SAM_FREQ << 8, chip->clock_id << 8,
241                                data, data_size, 1000);
242
243         if (ret < 0) {
244                 snd_printk(KERN_ERR "unable to retrieve sample rate range\n");
245                 ret = -EINVAL;
246                 goto err_free;
247         }
248
249         fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
250         if (!fp->rate_table) {
251                 ret = -ENOMEM;
252                 goto err_free;
253         }
254
255         fp->nr_rates = 0;
256         fp->rate_min = fp->rate_max = 0;
257
258         for (i = 0; i < nr_rates; i++) {
259                 int rate = combine_quad(&data[2 + 12 * i]);
260
261                 fp->rate_table[fp->nr_rates] = rate;
262                 if (!fp->rate_min || rate < fp->rate_min)
263                         fp->rate_min = rate;
264                 if (!fp->rate_max || rate > fp->rate_max)
265                         fp->rate_max = rate;
266                 fp->rates |= snd_pcm_rate_to_rate_bit(rate);
267                 fp->nr_rates++;
268         }
269
270 err_free:
271         kfree(data);
272 err:
273         return ret;
274 }
275
276 /*
277  * parse the format type I and III descriptors
278  */
279 static int parse_audio_format_i(struct snd_usb_audio *chip,
280                                 struct audioformat *fp,
281                                 int format, void *_fmt,
282                                 struct usb_host_interface *iface)
283 {
284         struct usb_interface_descriptor *altsd = get_iface_desc(iface);
285         struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
286         int protocol = altsd->bInterfaceProtocol;
287         int pcm_format, ret;
288
289         if (fmt->bFormatType == UAC_FORMAT_TYPE_III) {
290                 /* FIXME: the format type is really IECxxx
291                  *        but we give normal PCM format to get the existing
292                  *        apps working...
293                  */
294                 switch (chip->usb_id) {
295
296                 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
297                         if (chip->setup == 0x00 && 
298                             fp->altsetting == 6)
299                                 pcm_format = SNDRV_PCM_FORMAT_S16_BE;
300                         else
301                                 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
302                         break;
303                 default:
304                         pcm_format = SNDRV_PCM_FORMAT_S16_LE;
305                 }
306                 fp->formats = 1uLL << pcm_format;
307         } else {
308                 fp->formats = parse_audio_format_i_type(chip, fp, format,
309                                                         fmt, protocol);
310                 if (!fp->formats)
311                         return -1;
312         }
313
314         /* gather possible sample rates */
315         /* audio class v1 reports possible sample rates as part of the
316          * proprietary class specific descriptor.
317          * audio class v2 uses class specific EP0 range requests for that.
318          */
319         switch (protocol) {
320         case UAC_VERSION_1:
321                 fp->channels = fmt->bNrChannels;
322                 ret = parse_audio_format_rates_v1(chip, fp, _fmt, 7);
323                 break;
324         case UAC_VERSION_2:
325                 /* fp->channels is already set in this case */
326                 ret = parse_audio_format_rates_v2(chip, fp, iface);
327                 break;
328         }
329
330         if (fp->channels < 1) {
331                 snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
332                            chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);
333                 return -1;
334         }
335
336         return ret;
337 }
338
339 /*
340  * parse the format type II descriptor
341  */
342 static int parse_audio_format_ii(struct snd_usb_audio *chip,
343                                  struct audioformat *fp,
344                                  int format, void *_fmt,
345                                  struct usb_host_interface *iface)
346 {
347         int brate, framesize, ret;
348         struct usb_interface_descriptor *altsd = get_iface_desc(iface);
349         int protocol = altsd->bInterfaceProtocol;
350
351         switch (format) {
352         case UAC_FORMAT_TYPE_II_AC3:
353                 /* FIXME: there is no AC3 format defined yet */
354                 // fp->formats = SNDRV_PCM_FMTBIT_AC3;
355                 fp->formats = SNDRV_PCM_FMTBIT_U8; /* temporary hack to receive byte streams */
356                 break;
357         case UAC_FORMAT_TYPE_II_MPEG:
358                 fp->formats = SNDRV_PCM_FMTBIT_MPEG;
359                 break;
360         default:
361                 snd_printd(KERN_INFO "%d:%u:%d : unknown format tag %#x is detected.  processed as MPEG.\n",
362                            chip->dev->devnum, fp->iface, fp->altsetting, format);
363                 fp->formats = SNDRV_PCM_FMTBIT_MPEG;
364                 break;
365         }
366
367         fp->channels = 1;
368
369         switch (protocol) {
370         case UAC_VERSION_1: {
371                 struct uac_format_type_ii_discrete_descriptor *fmt = _fmt;
372                 brate = le16_to_cpu(fmt->wMaxBitRate);
373                 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
374                 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
375                 fp->frame_size = framesize;
376                 ret = parse_audio_format_rates_v1(chip, fp, _fmt, 8); /* fmt[8..] sample rates */
377                 break;
378         }
379         case UAC_VERSION_2: {
380                 struct uac_format_type_ii_ext_descriptor *fmt = _fmt;
381                 brate = le16_to_cpu(fmt->wMaxBitRate);
382                 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
383                 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
384                 fp->frame_size = framesize;
385                 ret = parse_audio_format_rates_v2(chip, fp, iface);
386                 break;
387         }
388         }
389
390         return ret;
391 }
392
393 int snd_usb_parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp,
394                        int format, unsigned char *fmt, int stream,
395                        struct usb_host_interface *iface)
396 {
397         int err;
398
399         switch (fmt[3]) {
400         case UAC_FORMAT_TYPE_I:
401         case UAC_FORMAT_TYPE_III:
402                 err = parse_audio_format_i(chip, fp, format, fmt, iface);
403                 break;
404         case UAC_FORMAT_TYPE_II:
405                 err = parse_audio_format_ii(chip, fp, format, fmt, iface);
406                 break;
407         default:
408                 snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
409                            chip->dev->devnum, fp->iface, fp->altsetting, fmt[3]);
410                 return -1;
411         }
412         fp->fmt_type = fmt[3];
413         if (err < 0)
414                 return err;
415 #if 1
416         /* FIXME: temporary hack for extigy/audigy 2 nx/zs */
417         /* extigy apparently supports sample rates other than 48k
418          * but not in ordinary way.  so we enable only 48k atm.
419          */
420         if (chip->usb_id == USB_ID(0x041e, 0x3000) ||
421             chip->usb_id == USB_ID(0x041e, 0x3020) ||
422             chip->usb_id == USB_ID(0x041e, 0x3061)) {
423                 if (fmt[3] == UAC_FORMAT_TYPE_I &&
424                     fp->rates != SNDRV_PCM_RATE_48000 &&
425                     fp->rates != SNDRV_PCM_RATE_96000)
426                         return -1;
427         }
428 #endif
429         return 0;
430 }
431