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