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