Linux Audio

Check our new training course

Linux BSP upgrade and security maintenance

Need help to get security updates for your Linux BSP?
Loading...
v3.15
 
  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#include <sound/control.h>
 27#include <sound/tlv.h>
 28
 29#include "usbaudio.h"
 30#include "card.h"
 31#include "proc.h"
 32#include "quirks.h"
 33#include "endpoint.h"
 34#include "pcm.h"
 35#include "helper.h"
 36#include "format.h"
 37#include "clock.h"
 38#include "stream.h"
 
 
 
 
 
 
 
 
 
 
 39
 40/*
 41 * free a substream
 42 */
 43static void free_substream(struct snd_usb_substream *subs)
 44{
 45	struct audioformat *fp, *n;
 46
 47	if (!subs->num_formats)
 48		return; /* not initialized */
 49	list_for_each_entry_safe(fp, n, &subs->fmt_list, list) {
 50		kfree(fp->rate_table);
 51		kfree(fp->chmap);
 52		kfree(fp);
 53	}
 54	kfree(subs->rate_list.list);
 
 
 55}
 56
 57
 58/*
 59 * free a usb stream instance
 60 */
 61static void snd_usb_audio_stream_free(struct snd_usb_stream *stream)
 62{
 63	free_substream(&stream->substream[0]);
 64	free_substream(&stream->substream[1]);
 65	list_del(&stream->list);
 66	kfree(stream);
 67}
 68
 69static void snd_usb_audio_pcm_free(struct snd_pcm *pcm)
 70{
 71	struct snd_usb_stream *stream = pcm->private_data;
 72	if (stream) {
 73		stream->pcm = NULL;
 74		snd_usb_audio_stream_free(stream);
 75	}
 76}
 77
 78/*
 79 * initialize the substream instance.
 80 */
 81
 82static void snd_usb_init_substream(struct snd_usb_stream *as,
 83				   int stream,
 84				   struct audioformat *fp)
 
 85{
 86	struct snd_usb_substream *subs = &as->substream[stream];
 87
 88	INIT_LIST_HEAD(&subs->fmt_list);
 89	spin_lock_init(&subs->lock);
 90
 91	subs->stream = as;
 92	subs->direction = stream;
 93	subs->dev = as->chip->dev;
 94	subs->txfr_quirk = as->chip->txfr_quirk;
 
 95	subs->speed = snd_usb_get_speed(subs->dev);
 96	subs->pkt_offset_adj = 0;
 97
 98	snd_usb_set_pcm_ops(as->pcm, stream);
 99
100	list_add_tail(&fp->list, &subs->fmt_list);
101	subs->formats |= fp->formats;
102	subs->num_formats++;
103	subs->fmt_type = fp->fmt_type;
104	subs->ep_num = fp->endpoint;
105	if (fp->channels > subs->channels_max)
106		subs->channels_max = fp->channels;
 
 
 
 
 
 
 
 
 
107}
108
109/* kctl callbacks for usb-audio channel maps */
110static int usb_chmap_ctl_info(struct snd_kcontrol *kcontrol,
111			      struct snd_ctl_elem_info *uinfo)
112{
113	struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
114	struct snd_usb_substream *subs = info->private_data;
115
116	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
117	uinfo->count = subs->channels_max;
118	uinfo->value.integer.min = 0;
119	uinfo->value.integer.max = SNDRV_CHMAP_LAST;
120	return 0;
121}
122
123/* check whether a duplicated entry exists in the audiofmt list */
124static bool have_dup_chmap(struct snd_usb_substream *subs,
125			   struct audioformat *fp)
126{
127	struct list_head *p;
128
129	for (p = fp->list.prev; p != &subs->fmt_list; p = p->prev) {
130		struct audioformat *prev;
131		prev = list_entry(p, struct audioformat, list);
132		if (prev->chmap &&
133		    !memcmp(prev->chmap, fp->chmap, sizeof(*fp->chmap)))
134			return true;
135	}
136	return false;
137}
138
139static int usb_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag,
140			     unsigned int size, unsigned int __user *tlv)
141{
142	struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
143	struct snd_usb_substream *subs = info->private_data;
144	struct audioformat *fp;
145	unsigned int __user *dst;
146	int count = 0;
147
148	if (size < 8)
149		return -ENOMEM;
150	if (put_user(SNDRV_CTL_TLVT_CONTAINER, tlv))
151		return -EFAULT;
152	size -= 8;
153	dst = tlv + 2;
154	list_for_each_entry(fp, &subs->fmt_list, list) {
155		int i, ch_bytes;
156
157		if (!fp->chmap)
158			continue;
159		if (have_dup_chmap(subs, fp))
160			continue;
161		/* copy the entry */
162		ch_bytes = fp->chmap->channels * 4;
163		if (size < 8 + ch_bytes)
164			return -ENOMEM;
165		if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED, dst) ||
166		    put_user(ch_bytes, dst + 1))
167			return -EFAULT;
168		dst += 2;
169		for (i = 0; i < fp->chmap->channels; i++, dst++) {
170			if (put_user(fp->chmap->map[i], dst))
171				return -EFAULT;
172		}
173
174		count += 8 + ch_bytes;
175		size -= 8 + ch_bytes;
176	}
177	if (put_user(count, tlv + 1))
178		return -EFAULT;
179	return 0;
180}
181
182static int usb_chmap_ctl_get(struct snd_kcontrol *kcontrol,
183			     struct snd_ctl_elem_value *ucontrol)
184{
185	struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
186	struct snd_usb_substream *subs = info->private_data;
187	struct snd_pcm_chmap_elem *chmap = NULL;
188	int i;
189
190	memset(ucontrol->value.integer.value, 0,
191	       sizeof(ucontrol->value.integer.value));
192	if (subs->cur_audiofmt)
193		chmap = subs->cur_audiofmt->chmap;
194	if (chmap) {
195		for (i = 0; i < chmap->channels; i++)
196			ucontrol->value.integer.value[i] = chmap->map[i];
197	}
198	return 0;
199}
200
201/* create a chmap kctl assigned to the given USB substream */
202static int add_chmap(struct snd_pcm *pcm, int stream,
203		     struct snd_usb_substream *subs)
204{
205	struct audioformat *fp;
206	struct snd_pcm_chmap *chmap;
207	struct snd_kcontrol *kctl;
208	int err;
209
210	list_for_each_entry(fp, &subs->fmt_list, list)
211		if (fp->chmap)
212			goto ok;
213	/* no chmap is found */
214	return 0;
215
216 ok:
217	err = snd_pcm_add_chmap_ctls(pcm, stream, NULL, 0, 0, &chmap);
218	if (err < 0)
219		return err;
220
221	/* override handlers */
222	chmap->private_data = subs;
223	kctl = chmap->kctl;
224	kctl->info = usb_chmap_ctl_info;
225	kctl->get = usb_chmap_ctl_get;
226	kctl->tlv.c = usb_chmap_ctl_tlv;
227
228	return 0;
229}
230
231/* convert from USB ChannelConfig bits to ALSA chmap element */
232static struct snd_pcm_chmap_elem *convert_chmap(int channels, unsigned int bits,
233						int protocol)
234{
235	static unsigned int uac1_maps[] = {
236		SNDRV_CHMAP_FL,		/* left front */
237		SNDRV_CHMAP_FR,		/* right front */
238		SNDRV_CHMAP_FC,		/* center front */
239		SNDRV_CHMAP_LFE,	/* LFE */
240		SNDRV_CHMAP_SL,		/* left surround */
241		SNDRV_CHMAP_SR,		/* right surround */
242		SNDRV_CHMAP_FLC,	/* left of center */
243		SNDRV_CHMAP_FRC,	/* right of center */
244		SNDRV_CHMAP_RC,		/* surround */
245		SNDRV_CHMAP_SL,		/* side left */
246		SNDRV_CHMAP_SR,		/* side right */
247		SNDRV_CHMAP_TC,		/* top */
248		0 /* terminator */
249	};
250	static unsigned int uac2_maps[] = {
251		SNDRV_CHMAP_FL,		/* front left */
252		SNDRV_CHMAP_FR,		/* front right */
253		SNDRV_CHMAP_FC,		/* front center */
254		SNDRV_CHMAP_LFE,	/* LFE */
255		SNDRV_CHMAP_RL,		/* back left */
256		SNDRV_CHMAP_RR,		/* back right */
257		SNDRV_CHMAP_FLC,	/* front left of center */
258		SNDRV_CHMAP_FRC,	/* front right of center */
259		SNDRV_CHMAP_RC,		/* back center */
260		SNDRV_CHMAP_SL,		/* side left */
261		SNDRV_CHMAP_SR,		/* side right */
262		SNDRV_CHMAP_TC,		/* top center */
263		SNDRV_CHMAP_TFL,	/* top front left */
264		SNDRV_CHMAP_TFC,	/* top front center */
265		SNDRV_CHMAP_TFR,	/* top front right */
266		SNDRV_CHMAP_TRL,	/* top back left */
267		SNDRV_CHMAP_TRC,	/* top back center */
268		SNDRV_CHMAP_TRR,	/* top back right */
269		SNDRV_CHMAP_TFLC,	/* top front left of center */
270		SNDRV_CHMAP_TFRC,	/* top front right of center */
271		SNDRV_CHMAP_LLFE,	/* left LFE */
272		SNDRV_CHMAP_RLFE,	/* right LFE */
273		SNDRV_CHMAP_TSL,	/* top side left */
274		SNDRV_CHMAP_TSR,	/* top side right */
275		SNDRV_CHMAP_BC,		/* bottom center */
276		SNDRV_CHMAP_RLC,	/* back left of center */
277		SNDRV_CHMAP_RRC,	/* back right of center */
278		0 /* terminator */
279	};
280	struct snd_pcm_chmap_elem *chmap;
281	const unsigned int *maps;
282	int c;
283
284	if (channels > ARRAY_SIZE(chmap->map))
285		return NULL;
286
287	chmap = kzalloc(sizeof(*chmap), GFP_KERNEL);
288	if (!chmap)
289		return NULL;
290
291	maps = protocol == UAC_VERSION_2 ? uac2_maps : uac1_maps;
292	chmap->channels = channels;
293	c = 0;
294
295	if (bits) {
296		for (; bits && *maps; maps++, bits >>= 1)
297			if (bits & 1)
298				chmap->map[c++] = *maps;
299	} else {
300		/* If we're missing wChannelConfig, then guess something
301		    to make sure the channel map is not skipped entirely */
302		if (channels == 1)
303			chmap->map[c++] = SNDRV_CHMAP_MONO;
304		else
305			for (; c < channels && *maps; maps++)
306				chmap->map[c++] = *maps;
307	}
308
309	for (; c < channels; c++)
310		chmap->map[c] = SNDRV_CHMAP_UNKNOWN;
311
312	return chmap;
313}
314
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
315/*
316 * add this endpoint to the chip instance.
317 * if a stream with the same endpoint already exists, append to it.
318 * if not, create a new pcm stream.
 
 
319 */
320int snd_usb_add_audio_stream(struct snd_usb_audio *chip,
321			     int stream,
322			     struct audioformat *fp)
 
 
323{
324	struct snd_usb_stream *as;
325	struct snd_usb_substream *subs;
326	struct snd_pcm *pcm;
327	int err;
328
329	list_for_each_entry(as, &chip->pcm_list, list) {
330		if (as->fmt_type != fp->fmt_type)
331			continue;
332		subs = &as->substream[stream];
333		if (subs->ep_num == fp->endpoint) {
334			list_add_tail(&fp->list, &subs->fmt_list);
335			subs->num_formats++;
336			subs->formats |= fp->formats;
337			return 0;
338		}
339	}
340	/* look for an empty stream */
341	list_for_each_entry(as, &chip->pcm_list, list) {
342		if (as->fmt_type != fp->fmt_type)
343			continue;
344		subs = &as->substream[stream];
345		if (subs->ep_num)
346			continue;
347		err = snd_pcm_new_stream(as->pcm, stream, 1);
348		if (err < 0)
349			return err;
350		snd_usb_init_substream(as, stream, fp);
351		return add_chmap(as->pcm, stream, subs);
352	}
353
354	/* create a new pcm */
355	as = kzalloc(sizeof(*as), GFP_KERNEL);
356	if (!as)
357		return -ENOMEM;
358	as->pcm_index = chip->pcm_devs;
359	as->chip = chip;
360	as->fmt_type = fp->fmt_type;
361	err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs,
362			  stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0,
363			  stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1,
364			  &pcm);
365	if (err < 0) {
366		kfree(as);
367		return err;
368	}
369	as->pcm = pcm;
370	pcm->private_data = as;
371	pcm->private_free = snd_usb_audio_pcm_free;
372	pcm->info_flags = 0;
373	if (chip->pcm_devs > 0)
374		sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs);
375	else
376		strcpy(pcm->name, "USB Audio");
377
378	snd_usb_init_substream(as, stream, fp);
 
 
 
 
 
 
 
 
 
379
380	list_add(&as->list, &chip->pcm_list);
381	chip->pcm_devs++;
382
383	snd_usb_proc_pcm_format_add(as);
384
385	return add_chmap(pcm, stream, &as->substream[stream]);
386}
387
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
388static int parse_uac_endpoint_attributes(struct snd_usb_audio *chip,
389					 struct usb_host_interface *alts,
390					 int protocol, int iface_no)
391{
392	/* parsed with a v1 header here. that's ok as we only look at the
393	 * header first which is the same for both versions */
394	struct uac_iso_endpoint_descriptor *csep;
395	struct usb_interface_descriptor *altsd = get_iface_desc(alts);
396	int attributes = 0;
397
398	csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT);
399
400	/* Creamware Noah has this descriptor after the 2nd endpoint */
401	if (!csep && altsd->bNumEndpoints >= 2)
402		csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
403
404	/*
405	 * If we can't locate the USB_DT_CS_ENDPOINT descriptor in the extra
406	 * bytes after the first endpoint, go search the entire interface.
407	 * Some devices have it directly *before* the standard endpoint.
408	 */
409	if (!csep)
410		csep = snd_usb_find_desc(alts->extra, alts->extralen, NULL, USB_DT_CS_ENDPOINT);
411
412	if (!csep || csep->bLength < 7 ||
413	    csep->bDescriptorSubtype != UAC_EP_GENERAL) {
414		usb_audio_warn(chip,
415			       "%u:%d : no or invalid class specific endpoint descriptor\n",
416			       iface_no, altsd->bAlternateSetting);
417		return 0;
418	}
419
420	if (protocol == UAC_VERSION_1) {
421		attributes = csep->bmAttributes;
422	} else {
423		struct uac2_iso_endpoint_descriptor *csep2 =
424			(struct uac2_iso_endpoint_descriptor *) csep;
425
 
 
426		attributes = csep->bmAttributes & UAC_EP_CS_ATTR_FILL_MAX;
427
428		/* emulate the endpoint attributes of a v1 device */
429		if (csep2->bmControls & UAC2_CONTROL_PITCH)
430			attributes |= UAC_EP_CS_ATTR_PITCH_CONTROL;
 
 
 
 
 
 
 
 
 
431	}
432
433	return attributes;
 
 
 
 
 
 
434}
435
436/* find an input terminal descriptor (either UAC1 or UAC2) with the given
437 * terminal id
438 */
439static void *
440snd_usb_find_input_terminal_descriptor(struct usb_host_interface *ctrl_iface,
441					       int terminal_id)
442{
443	struct uac2_input_terminal_descriptor *term = NULL;
444
445	while ((term = snd_usb_find_csint_desc(ctrl_iface->extra,
446					       ctrl_iface->extralen,
447					       term, UAC_INPUT_TERMINAL))) {
 
 
448		if (term->bTerminalID == terminal_id)
449			return term;
450	}
451
452	return NULL;
453}
454
455static struct uac2_output_terminal_descriptor *
456	snd_usb_find_output_terminal_descriptor(struct usb_host_interface *ctrl_iface,
457						int terminal_id)
458{
 
459	struct uac2_output_terminal_descriptor *term = NULL;
460
461	while ((term = snd_usb_find_csint_desc(ctrl_iface->extra,
462					       ctrl_iface->extralen,
463					       term, UAC_OUTPUT_TERMINAL))) {
 
 
464		if (term->bTerminalID == terminal_id)
465			return term;
466	}
467
468	return NULL;
469}
470
471int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
472{
473	struct usb_device *dev;
474	struct usb_interface *iface;
475	struct usb_host_interface *alts;
476	struct usb_interface_descriptor *altsd;
477	int i, altno, err, stream;
478	unsigned int format = 0, num_channels = 0;
479	struct audioformat *fp = NULL;
480	int num, protocol, clock = 0;
481	struct uac_format_type_i_continuous_descriptor *fmt;
482	unsigned int chconfig;
483
484	dev = chip->dev;
485
486	/* parse the interface's altsettings */
487	iface = usb_ifnum_to_if(dev, iface_no);
488
489	num = iface->num_altsetting;
490
491	/*
492	 * Dallas DS4201 workaround: It presents 5 altsettings, but the last
493	 * one misses syncpipe, and does not produce any sound.
494	 */
495	if (chip->usb_id == USB_ID(0x04fa, 0x4201))
496		num = 4;
497
498	for (i = 0; i < num; i++) {
499		alts = &iface->altsetting[i];
500		altsd = get_iface_desc(alts);
501		protocol = altsd->bInterfaceProtocol;
502		/* skip invalid one */
503		if (((altsd->bInterfaceClass != USB_CLASS_AUDIO ||
504		      (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING &&
505		       altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC)) &&
506		     altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
507		    altsd->bNumEndpoints < 1 ||
508		    le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
509			continue;
510		/* must be isochronous */
511		if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
512		    USB_ENDPOINT_XFER_ISOC)
513			continue;
514		/* check direction */
515		stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ?
516			SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
517		altno = altsd->bAlternateSetting;
518
519		if (snd_usb_apply_interface_quirk(chip, iface_no, altno))
520			continue;
521
522		/*
523		 * Roland audio streaming interfaces are marked with protocols
524		 * 0/1/2, but are UAC 1 compatible.
525		 */
526		if (USB_ID_VENDOR(chip->usb_id) == 0x0582 &&
527		    altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC &&
528		    protocol <= 2)
529			protocol = UAC_VERSION_1;
530
531		chconfig = 0;
532		/* get audio formats */
533		switch (protocol) {
534		default:
535			dev_dbg(&dev->dev, "%u:%d: unknown interface protocol %#02x, assuming v1\n",
536				iface_no, altno, protocol);
537			protocol = UAC_VERSION_1;
538			/* fall through */
539
540		case UAC_VERSION_1: {
541			struct uac1_as_header_descriptor *as =
542				snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
543			struct uac_input_terminal_descriptor *iterm;
544
545			if (!as) {
546				dev_err(&dev->dev,
547					"%u:%d : UAC_AS_GENERAL descriptor not found\n",
548					iface_no, altno);
549				continue;
550			}
551
552			if (as->bLength < sizeof(*as)) {
553				dev_err(&dev->dev,
554					"%u:%d : invalid UAC_AS_GENERAL desc\n",
555					iface_no, altno);
556				continue;
557			}
558
559			format = le16_to_cpu(as->wFormatTag); /* remember the format value */
560
561			iterm = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf,
562								       as->bTerminalLink);
563			if (iterm) {
564				num_channels = iterm->bNrChannels;
565				chconfig = le16_to_cpu(iterm->wChannelConfig);
566			}
567
568			break;
569		}
570
571		case UAC_VERSION_2: {
572			struct uac2_input_terminal_descriptor *input_term;
573			struct uac2_output_terminal_descriptor *output_term;
574			struct uac2_as_header_descriptor *as =
575				snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
576
577			if (!as) {
578				dev_err(&dev->dev,
579					"%u:%d : UAC_AS_GENERAL descriptor not found\n",
580					iface_no, altno);
581				continue;
582			}
583
584			if (as->bLength < sizeof(*as)) {
585				dev_err(&dev->dev,
586					"%u:%d : invalid UAC_AS_GENERAL desc\n",
587					iface_no, altno);
588				continue;
589			}
590
591			num_channels = as->bNrChannels;
592			format = le32_to_cpu(as->bmFormats);
593			chconfig = le32_to_cpu(as->bmChannelConfig);
594
595			/* lookup the terminal associated to this interface
596			 * to extract the clock */
597			input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf,
598									    as->bTerminalLink);
599			if (input_term) {
600				clock = input_term->bCSourceID;
601				if (!chconfig && (num_channels == input_term->bNrChannels))
602					chconfig = le32_to_cpu(input_term->bmChannelConfig);
603				break;
604			}
605
606			output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf,
607									      as->bTerminalLink);
608			if (output_term) {
609				clock = output_term->bCSourceID;
610				break;
611			}
612
613			dev_err(&dev->dev,
614				"%u:%d : bogus bTerminalLink %d\n",
615				iface_no, altno, as->bTerminalLink);
616			continue;
617		}
618		}
619
620		/* get format type */
621		fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE);
622		if (!fmt) {
623			dev_err(&dev->dev,
624				"%u:%d : no UAC_FORMAT_TYPE desc\n",
625				iface_no, altno);
626			continue;
627		}
628		if (((protocol == UAC_VERSION_1) && (fmt->bLength < 8)) ||
629		    ((protocol == UAC_VERSION_2) && (fmt->bLength < 6))) {
630			dev_err(&dev->dev,
631				"%u:%d : invalid UAC_FORMAT_TYPE desc\n",
632				iface_no, altno);
633			continue;
634		}
635
636		/*
637		 * Blue Microphones workaround: The last altsetting is identical
638		 * with the previous one, except for a larger packet size, but
639		 * is actually a mislabeled two-channel setting; ignore it.
640		 */
641		if (fmt->bNrChannels == 1 &&
642		    fmt->bSubframeSize == 2 &&
643		    altno == 2 && num == 3 &&
644		    fp && fp->altsetting == 1 && fp->channels == 1 &&
645		    fp->formats == SNDRV_PCM_FMTBIT_S16_LE &&
646		    protocol == UAC_VERSION_1 &&
647		    le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) ==
648							fp->maxpacksize * 2)
649			continue;
650
651		fp = kzalloc(sizeof(*fp), GFP_KERNEL);
652		if (! fp) {
653			dev_err(&dev->dev, "cannot malloc\n");
654			return -ENOMEM;
655		}
656
657		fp->iface = iface_no;
658		fp->altsetting = altno;
659		fp->altset_idx = i;
660		fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
661		fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
662		fp->datainterval = snd_usb_parse_datainterval(chip, alts);
663		fp->protocol = protocol;
664		fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
665		fp->channels = num_channels;
666		if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
667			fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
668					* (fp->maxpacksize & 0x7ff);
669		fp->attributes = parse_uac_endpoint_attributes(chip, alts, protocol, iface_no);
670		fp->clock = clock;
671
672		/* some quirks for attributes here */
673
674		switch (chip->usb_id) {
675		case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
676			/* Optoplay sets the sample rate attribute although
677			 * it seems not supporting it in fact.
678			 */
679			fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE;
680			break;
681		case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
682		case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
683			/* doesn't set the sample rate attribute, but supports it */
684			fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE;
685			break;
686		case USB_ID(0x0763, 0x2001):  /* M-Audio Quattro USB */
687		case USB_ID(0x0763, 0x2012):  /* M-Audio Fast Track Pro USB */
688		case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
689		case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
690						an older model 77d:223) */
691		/*
692		 * plantronics headset and Griffin iMic have set adaptive-in
693		 * although it's really not...
694		 */
695			fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE;
696			if (stream == SNDRV_PCM_STREAM_PLAYBACK)
697				fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE;
698			else
699				fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC;
700			break;
701		}
702
703		/* ok, let's parse further... */
704		if (snd_usb_parse_audio_format(chip, fp, format, fmt, stream) < 0) {
705			kfree(fp->rate_table);
706			kfree(fp);
 
 
 
 
 
 
707			fp = NULL;
 
708			continue;
709		}
710
711		/* Create chmap */
712		if (fp->channels != num_channels)
713			chconfig = 0;
714		fp->chmap = convert_chmap(fp->channels, chconfig, protocol);
715
716		dev_dbg(&dev->dev, "%u:%d: add audio endpoint %#x\n", iface_no, altno, fp->endpoint);
717		err = snd_usb_add_audio_stream(chip, stream, fp);
 
 
 
 
718		if (err < 0) {
719			kfree(fp->rate_table);
720			kfree(fp->chmap);
721			kfree(fp);
722			return err;
723		}
724		/* try to set the interface... */
725		usb_set_interface(chip->dev, iface_no, altno);
726		snd_usb_init_pitch(chip, iface_no, alts, fp);
727		snd_usb_init_sample_rate(chip, iface_no, alts, fp, fp->rate_max);
728	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
729	return 0;
730}
731
v5.4
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
 
 
 
 
 
 
 
 
 
 
 
 
 
   3 */
   4
   5
   6#include <linux/init.h>
   7#include <linux/slab.h>
   8#include <linux/usb.h>
   9#include <linux/usb/audio.h>
  10#include <linux/usb/audio-v2.h>
  11#include <linux/usb/audio-v3.h>
  12
  13#include <sound/core.h>
  14#include <sound/pcm.h>
  15#include <sound/control.h>
  16#include <sound/tlv.h>
  17
  18#include "usbaudio.h"
  19#include "card.h"
  20#include "proc.h"
  21#include "quirks.h"
  22#include "endpoint.h"
  23#include "pcm.h"
  24#include "helper.h"
  25#include "format.h"
  26#include "clock.h"
  27#include "stream.h"
  28#include "power.h"
  29#include "media.h"
  30
  31static void audioformat_free(struct audioformat *fp)
  32{
  33	list_del(&fp->list); /* unlink for avoiding double-free */
  34	kfree(fp->rate_table);
  35	kfree(fp->chmap);
  36	kfree(fp);
  37}
  38
  39/*
  40 * free a substream
  41 */
  42static void free_substream(struct snd_usb_substream *subs)
  43{
  44	struct audioformat *fp, *n;
  45
  46	if (!subs->num_formats)
  47		return; /* not initialized */
  48	list_for_each_entry_safe(fp, n, &subs->fmt_list, list)
  49		audioformat_free(fp);
 
 
 
  50	kfree(subs->rate_list.list);
  51	kfree(subs->str_pd);
  52	snd_media_stream_delete(subs);
  53}
  54
  55
  56/*
  57 * free a usb stream instance
  58 */
  59static void snd_usb_audio_stream_free(struct snd_usb_stream *stream)
  60{
  61	free_substream(&stream->substream[0]);
  62	free_substream(&stream->substream[1]);
  63	list_del(&stream->list);
  64	kfree(stream);
  65}
  66
  67static void snd_usb_audio_pcm_free(struct snd_pcm *pcm)
  68{
  69	struct snd_usb_stream *stream = pcm->private_data;
  70	if (stream) {
  71		stream->pcm = NULL;
  72		snd_usb_audio_stream_free(stream);
  73	}
  74}
  75
  76/*
  77 * initialize the substream instance.
  78 */
  79
  80static void snd_usb_init_substream(struct snd_usb_stream *as,
  81				   int stream,
  82				   struct audioformat *fp,
  83				   struct snd_usb_power_domain *pd)
  84{
  85	struct snd_usb_substream *subs = &as->substream[stream];
  86
  87	INIT_LIST_HEAD(&subs->fmt_list);
  88	spin_lock_init(&subs->lock);
  89
  90	subs->stream = as;
  91	subs->direction = stream;
  92	subs->dev = as->chip->dev;
  93	subs->txfr_quirk = as->chip->txfr_quirk;
  94	subs->tx_length_quirk = as->chip->tx_length_quirk;
  95	subs->speed = snd_usb_get_speed(subs->dev);
  96	subs->pkt_offset_adj = 0;
  97
  98	snd_usb_set_pcm_ops(as->pcm, stream);
  99
 100	list_add_tail(&fp->list, &subs->fmt_list);
 101	subs->formats |= fp->formats;
 102	subs->num_formats++;
 103	subs->fmt_type = fp->fmt_type;
 104	subs->ep_num = fp->endpoint;
 105	if (fp->channels > subs->channels_max)
 106		subs->channels_max = fp->channels;
 107
 108	if (pd) {
 109		subs->str_pd = pd;
 110		/* Initialize Power Domain to idle status D1 */
 111		snd_usb_power_domain_set(subs->stream->chip, pd,
 112					 UAC3_PD_STATE_D1);
 113	}
 114
 115	snd_usb_preallocate_buffer(subs);
 116}
 117
 118/* kctl callbacks for usb-audio channel maps */
 119static int usb_chmap_ctl_info(struct snd_kcontrol *kcontrol,
 120			      struct snd_ctl_elem_info *uinfo)
 121{
 122	struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
 123	struct snd_usb_substream *subs = info->private_data;
 124
 125	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 126	uinfo->count = subs->channels_max;
 127	uinfo->value.integer.min = 0;
 128	uinfo->value.integer.max = SNDRV_CHMAP_LAST;
 129	return 0;
 130}
 131
 132/* check whether a duplicated entry exists in the audiofmt list */
 133static bool have_dup_chmap(struct snd_usb_substream *subs,
 134			   struct audioformat *fp)
 135{
 136	struct audioformat *prev = fp;
 137
 138	list_for_each_entry_continue_reverse(prev, &subs->fmt_list, list) {
 
 
 139		if (prev->chmap &&
 140		    !memcmp(prev->chmap, fp->chmap, sizeof(*fp->chmap)))
 141			return true;
 142	}
 143	return false;
 144}
 145
 146static int usb_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag,
 147			     unsigned int size, unsigned int __user *tlv)
 148{
 149	struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
 150	struct snd_usb_substream *subs = info->private_data;
 151	struct audioformat *fp;
 152	unsigned int __user *dst;
 153	int count = 0;
 154
 155	if (size < 8)
 156		return -ENOMEM;
 157	if (put_user(SNDRV_CTL_TLVT_CONTAINER, tlv))
 158		return -EFAULT;
 159	size -= 8;
 160	dst = tlv + 2;
 161	list_for_each_entry(fp, &subs->fmt_list, list) {
 162		int i, ch_bytes;
 163
 164		if (!fp->chmap)
 165			continue;
 166		if (have_dup_chmap(subs, fp))
 167			continue;
 168		/* copy the entry */
 169		ch_bytes = fp->chmap->channels * 4;
 170		if (size < 8 + ch_bytes)
 171			return -ENOMEM;
 172		if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED, dst) ||
 173		    put_user(ch_bytes, dst + 1))
 174			return -EFAULT;
 175		dst += 2;
 176		for (i = 0; i < fp->chmap->channels; i++, dst++) {
 177			if (put_user(fp->chmap->map[i], dst))
 178				return -EFAULT;
 179		}
 180
 181		count += 8 + ch_bytes;
 182		size -= 8 + ch_bytes;
 183	}
 184	if (put_user(count, tlv + 1))
 185		return -EFAULT;
 186	return 0;
 187}
 188
 189static int usb_chmap_ctl_get(struct snd_kcontrol *kcontrol,
 190			     struct snd_ctl_elem_value *ucontrol)
 191{
 192	struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
 193	struct snd_usb_substream *subs = info->private_data;
 194	struct snd_pcm_chmap_elem *chmap = NULL;
 195	int i;
 196
 197	memset(ucontrol->value.integer.value, 0,
 198	       sizeof(ucontrol->value.integer.value));
 199	if (subs->cur_audiofmt)
 200		chmap = subs->cur_audiofmt->chmap;
 201	if (chmap) {
 202		for (i = 0; i < chmap->channels; i++)
 203			ucontrol->value.integer.value[i] = chmap->map[i];
 204	}
 205	return 0;
 206}
 207
 208/* create a chmap kctl assigned to the given USB substream */
 209static int add_chmap(struct snd_pcm *pcm, int stream,
 210		     struct snd_usb_substream *subs)
 211{
 212	struct audioformat *fp;
 213	struct snd_pcm_chmap *chmap;
 214	struct snd_kcontrol *kctl;
 215	int err;
 216
 217	list_for_each_entry(fp, &subs->fmt_list, list)
 218		if (fp->chmap)
 219			goto ok;
 220	/* no chmap is found */
 221	return 0;
 222
 223 ok:
 224	err = snd_pcm_add_chmap_ctls(pcm, stream, NULL, 0, 0, &chmap);
 225	if (err < 0)
 226		return err;
 227
 228	/* override handlers */
 229	chmap->private_data = subs;
 230	kctl = chmap->kctl;
 231	kctl->info = usb_chmap_ctl_info;
 232	kctl->get = usb_chmap_ctl_get;
 233	kctl->tlv.c = usb_chmap_ctl_tlv;
 234
 235	return 0;
 236}
 237
 238/* convert from USB ChannelConfig bits to ALSA chmap element */
 239static struct snd_pcm_chmap_elem *convert_chmap(int channels, unsigned int bits,
 240						int protocol)
 241{
 242	static unsigned int uac1_maps[] = {
 243		SNDRV_CHMAP_FL,		/* left front */
 244		SNDRV_CHMAP_FR,		/* right front */
 245		SNDRV_CHMAP_FC,		/* center front */
 246		SNDRV_CHMAP_LFE,	/* LFE */
 247		SNDRV_CHMAP_SL,		/* left surround */
 248		SNDRV_CHMAP_SR,		/* right surround */
 249		SNDRV_CHMAP_FLC,	/* left of center */
 250		SNDRV_CHMAP_FRC,	/* right of center */
 251		SNDRV_CHMAP_RC,		/* surround */
 252		SNDRV_CHMAP_SL,		/* side left */
 253		SNDRV_CHMAP_SR,		/* side right */
 254		SNDRV_CHMAP_TC,		/* top */
 255		0 /* terminator */
 256	};
 257	static unsigned int uac2_maps[] = {
 258		SNDRV_CHMAP_FL,		/* front left */
 259		SNDRV_CHMAP_FR,		/* front right */
 260		SNDRV_CHMAP_FC,		/* front center */
 261		SNDRV_CHMAP_LFE,	/* LFE */
 262		SNDRV_CHMAP_RL,		/* back left */
 263		SNDRV_CHMAP_RR,		/* back right */
 264		SNDRV_CHMAP_FLC,	/* front left of center */
 265		SNDRV_CHMAP_FRC,	/* front right of center */
 266		SNDRV_CHMAP_RC,		/* back center */
 267		SNDRV_CHMAP_SL,		/* side left */
 268		SNDRV_CHMAP_SR,		/* side right */
 269		SNDRV_CHMAP_TC,		/* top center */
 270		SNDRV_CHMAP_TFL,	/* top front left */
 271		SNDRV_CHMAP_TFC,	/* top front center */
 272		SNDRV_CHMAP_TFR,	/* top front right */
 273		SNDRV_CHMAP_TRL,	/* top back left */
 274		SNDRV_CHMAP_TRC,	/* top back center */
 275		SNDRV_CHMAP_TRR,	/* top back right */
 276		SNDRV_CHMAP_TFLC,	/* top front left of center */
 277		SNDRV_CHMAP_TFRC,	/* top front right of center */
 278		SNDRV_CHMAP_LLFE,	/* left LFE */
 279		SNDRV_CHMAP_RLFE,	/* right LFE */
 280		SNDRV_CHMAP_TSL,	/* top side left */
 281		SNDRV_CHMAP_TSR,	/* top side right */
 282		SNDRV_CHMAP_BC,		/* bottom center */
 283		SNDRV_CHMAP_RLC,	/* back left of center */
 284		SNDRV_CHMAP_RRC,	/* back right of center */
 285		0 /* terminator */
 286	};
 287	struct snd_pcm_chmap_elem *chmap;
 288	const unsigned int *maps;
 289	int c;
 290
 291	if (channels > ARRAY_SIZE(chmap->map))
 292		return NULL;
 293
 294	chmap = kzalloc(sizeof(*chmap), GFP_KERNEL);
 295	if (!chmap)
 296		return NULL;
 297
 298	maps = protocol == UAC_VERSION_2 ? uac2_maps : uac1_maps;
 299	chmap->channels = channels;
 300	c = 0;
 301
 302	if (bits) {
 303		for (; bits && *maps; maps++, bits >>= 1)
 304			if (bits & 1)
 305				chmap->map[c++] = *maps;
 306	} else {
 307		/* If we're missing wChannelConfig, then guess something
 308		    to make sure the channel map is not skipped entirely */
 309		if (channels == 1)
 310			chmap->map[c++] = SNDRV_CHMAP_MONO;
 311		else
 312			for (; c < channels && *maps; maps++)
 313				chmap->map[c++] = *maps;
 314	}
 315
 316	for (; c < channels; c++)
 317		chmap->map[c] = SNDRV_CHMAP_UNKNOWN;
 318
 319	return chmap;
 320}
 321
 322/* UAC3 device stores channels information in Cluster Descriptors */
 323static struct
 324snd_pcm_chmap_elem *convert_chmap_v3(struct uac3_cluster_header_descriptor
 325								*cluster)
 326{
 327	unsigned int channels = cluster->bNrChannels;
 328	struct snd_pcm_chmap_elem *chmap;
 329	void *p = cluster;
 330	int len, c;
 331
 332	if (channels > ARRAY_SIZE(chmap->map))
 333		return NULL;
 334
 335	chmap = kzalloc(sizeof(*chmap), GFP_KERNEL);
 336	if (!chmap)
 337		return NULL;
 338
 339	len = le16_to_cpu(cluster->wLength);
 340	c = 0;
 341	p += sizeof(struct uac3_cluster_header_descriptor);
 342
 343	while (((p - (void *)cluster) < len) && (c < channels)) {
 344		struct uac3_cluster_segment_descriptor *cs_desc = p;
 345		u16 cs_len;
 346		u8 cs_type;
 347
 348		cs_len = le16_to_cpu(cs_desc->wLength);
 349		cs_type = cs_desc->bSegmentType;
 350
 351		if (cs_type == UAC3_CHANNEL_INFORMATION) {
 352			struct uac3_cluster_information_segment_descriptor *is = p;
 353			unsigned char map;
 354
 355			/*
 356			 * TODO: this conversion is not complete, update it
 357			 * after adding UAC3 values to asound.h
 358			 */
 359			switch (is->bChRelationship) {
 360			case UAC3_CH_MONO:
 361				map = SNDRV_CHMAP_MONO;
 362				break;
 363			case UAC3_CH_LEFT:
 364			case UAC3_CH_FRONT_LEFT:
 365			case UAC3_CH_HEADPHONE_LEFT:
 366				map = SNDRV_CHMAP_FL;
 367				break;
 368			case UAC3_CH_RIGHT:
 369			case UAC3_CH_FRONT_RIGHT:
 370			case UAC3_CH_HEADPHONE_RIGHT:
 371				map = SNDRV_CHMAP_FR;
 372				break;
 373			case UAC3_CH_FRONT_CENTER:
 374				map = SNDRV_CHMAP_FC;
 375				break;
 376			case UAC3_CH_FRONT_LEFT_OF_CENTER:
 377				map = SNDRV_CHMAP_FLC;
 378				break;
 379			case UAC3_CH_FRONT_RIGHT_OF_CENTER:
 380				map = SNDRV_CHMAP_FRC;
 381				break;
 382			case UAC3_CH_SIDE_LEFT:
 383				map = SNDRV_CHMAP_SL;
 384				break;
 385			case UAC3_CH_SIDE_RIGHT:
 386				map = SNDRV_CHMAP_SR;
 387				break;
 388			case UAC3_CH_BACK_LEFT:
 389				map = SNDRV_CHMAP_RL;
 390				break;
 391			case UAC3_CH_BACK_RIGHT:
 392				map = SNDRV_CHMAP_RR;
 393				break;
 394			case UAC3_CH_BACK_CENTER:
 395				map = SNDRV_CHMAP_RC;
 396				break;
 397			case UAC3_CH_BACK_LEFT_OF_CENTER:
 398				map = SNDRV_CHMAP_RLC;
 399				break;
 400			case UAC3_CH_BACK_RIGHT_OF_CENTER:
 401				map = SNDRV_CHMAP_RRC;
 402				break;
 403			case UAC3_CH_TOP_CENTER:
 404				map = SNDRV_CHMAP_TC;
 405				break;
 406			case UAC3_CH_TOP_FRONT_LEFT:
 407				map = SNDRV_CHMAP_TFL;
 408				break;
 409			case UAC3_CH_TOP_FRONT_RIGHT:
 410				map = SNDRV_CHMAP_TFR;
 411				break;
 412			case UAC3_CH_TOP_FRONT_CENTER:
 413				map = SNDRV_CHMAP_TFC;
 414				break;
 415			case UAC3_CH_TOP_FRONT_LOC:
 416				map = SNDRV_CHMAP_TFLC;
 417				break;
 418			case UAC3_CH_TOP_FRONT_ROC:
 419				map = SNDRV_CHMAP_TFRC;
 420				break;
 421			case UAC3_CH_TOP_SIDE_LEFT:
 422				map = SNDRV_CHMAP_TSL;
 423				break;
 424			case UAC3_CH_TOP_SIDE_RIGHT:
 425				map = SNDRV_CHMAP_TSR;
 426				break;
 427			case UAC3_CH_TOP_BACK_LEFT:
 428				map = SNDRV_CHMAP_TRL;
 429				break;
 430			case UAC3_CH_TOP_BACK_RIGHT:
 431				map = SNDRV_CHMAP_TRR;
 432				break;
 433			case UAC3_CH_TOP_BACK_CENTER:
 434				map = SNDRV_CHMAP_TRC;
 435				break;
 436			case UAC3_CH_BOTTOM_CENTER:
 437				map = SNDRV_CHMAP_BC;
 438				break;
 439			case UAC3_CH_LOW_FREQUENCY_EFFECTS:
 440				map = SNDRV_CHMAP_LFE;
 441				break;
 442			case UAC3_CH_LFE_LEFT:
 443				map = SNDRV_CHMAP_LLFE;
 444				break;
 445			case UAC3_CH_LFE_RIGHT:
 446				map = SNDRV_CHMAP_RLFE;
 447				break;
 448			case UAC3_CH_RELATIONSHIP_UNDEFINED:
 449			default:
 450				map = SNDRV_CHMAP_UNKNOWN;
 451				break;
 452			}
 453			chmap->map[c++] = map;
 454		}
 455		p += cs_len;
 456	}
 457
 458	if (channels < c)
 459		pr_err("%s: channel number mismatch\n", __func__);
 460
 461	chmap->channels = channels;
 462
 463	for (; c < channels; c++)
 464		chmap->map[c] = SNDRV_CHMAP_UNKNOWN;
 465
 466	return chmap;
 467}
 468
 469/*
 470 * add this endpoint to the chip instance.
 471 * if a stream with the same endpoint already exists, append to it.
 472 * if not, create a new pcm stream. note, fp is added to the substream
 473 * fmt_list and will be freed on the chip instance release. do not free
 474 * fp or do remove it from the substream fmt_list to avoid double-free.
 475 */
 476static int __snd_usb_add_audio_stream(struct snd_usb_audio *chip,
 477				      int stream,
 478				      struct audioformat *fp,
 479				      struct snd_usb_power_domain *pd)
 480
 481{
 482	struct snd_usb_stream *as;
 483	struct snd_usb_substream *subs;
 484	struct snd_pcm *pcm;
 485	int err;
 486
 487	list_for_each_entry(as, &chip->pcm_list, list) {
 488		if (as->fmt_type != fp->fmt_type)
 489			continue;
 490		subs = &as->substream[stream];
 491		if (subs->ep_num == fp->endpoint) {
 492			list_add_tail(&fp->list, &subs->fmt_list);
 493			subs->num_formats++;
 494			subs->formats |= fp->formats;
 495			return 0;
 496		}
 497	}
 498	/* look for an empty stream */
 499	list_for_each_entry(as, &chip->pcm_list, list) {
 500		if (as->fmt_type != fp->fmt_type)
 501			continue;
 502		subs = &as->substream[stream];
 503		if (subs->ep_num)
 504			continue;
 505		err = snd_pcm_new_stream(as->pcm, stream, 1);
 506		if (err < 0)
 507			return err;
 508		snd_usb_init_substream(as, stream, fp, pd);
 509		return add_chmap(as->pcm, stream, subs);
 510	}
 511
 512	/* create a new pcm */
 513	as = kzalloc(sizeof(*as), GFP_KERNEL);
 514	if (!as)
 515		return -ENOMEM;
 516	as->pcm_index = chip->pcm_devs;
 517	as->chip = chip;
 518	as->fmt_type = fp->fmt_type;
 519	err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs,
 520			  stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0,
 521			  stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1,
 522			  &pcm);
 523	if (err < 0) {
 524		kfree(as);
 525		return err;
 526	}
 527	as->pcm = pcm;
 528	pcm->private_data = as;
 529	pcm->private_free = snd_usb_audio_pcm_free;
 530	pcm->info_flags = 0;
 531	if (chip->pcm_devs > 0)
 532		sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs);
 533	else
 534		strcpy(pcm->name, "USB Audio");
 535
 536	snd_usb_init_substream(as, stream, fp, pd);
 537
 538	/*
 539	 * Keep using head insertion for M-Audio Audiophile USB (tm) which has a
 540	 * fix to swap capture stream order in conf/cards/USB-audio.conf
 541	 */
 542	if (chip->usb_id == USB_ID(0x0763, 0x2003))
 543		list_add(&as->list, &chip->pcm_list);
 544	else
 545		list_add_tail(&as->list, &chip->pcm_list);
 546
 
 547	chip->pcm_devs++;
 548
 549	snd_usb_proc_pcm_format_add(as);
 550
 551	return add_chmap(pcm, stream, &as->substream[stream]);
 552}
 553
 554int snd_usb_add_audio_stream(struct snd_usb_audio *chip,
 555			     int stream,
 556			     struct audioformat *fp)
 557{
 558	return __snd_usb_add_audio_stream(chip, stream, fp, NULL);
 559}
 560
 561static int snd_usb_add_audio_stream_v3(struct snd_usb_audio *chip,
 562				       int stream,
 563				       struct audioformat *fp,
 564				       struct snd_usb_power_domain *pd)
 565{
 566	return __snd_usb_add_audio_stream(chip, stream, fp, pd);
 567}
 568
 569static int parse_uac_endpoint_attributes(struct snd_usb_audio *chip,
 570					 struct usb_host_interface *alts,
 571					 int protocol, int iface_no)
 572{
 573	/* parsed with a v1 header here. that's ok as we only look at the
 574	 * header first which is the same for both versions */
 575	struct uac_iso_endpoint_descriptor *csep;
 576	struct usb_interface_descriptor *altsd = get_iface_desc(alts);
 577	int attributes = 0;
 578
 579	csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT);
 580
 581	/* Creamware Noah has this descriptor after the 2nd endpoint */
 582	if (!csep && altsd->bNumEndpoints >= 2)
 583		csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
 584
 585	/*
 586	 * If we can't locate the USB_DT_CS_ENDPOINT descriptor in the extra
 587	 * bytes after the first endpoint, go search the entire interface.
 588	 * Some devices have it directly *before* the standard endpoint.
 589	 */
 590	if (!csep)
 591		csep = snd_usb_find_desc(alts->extra, alts->extralen, NULL, USB_DT_CS_ENDPOINT);
 592
 593	if (!csep || csep->bLength < 7 ||
 594	    csep->bDescriptorSubtype != UAC_EP_GENERAL)
 595		goto error;
 
 
 
 
 596
 597	if (protocol == UAC_VERSION_1) {
 598		attributes = csep->bmAttributes;
 599	} else if (protocol == UAC_VERSION_2) {
 600		struct uac2_iso_endpoint_descriptor *csep2 =
 601			(struct uac2_iso_endpoint_descriptor *) csep;
 602
 603		if (csep2->bLength < sizeof(*csep2))
 604			goto error;
 605		attributes = csep->bmAttributes & UAC_EP_CS_ATTR_FILL_MAX;
 606
 607		/* emulate the endpoint attributes of a v1 device */
 608		if (csep2->bmControls & UAC2_CONTROL_PITCH)
 609			attributes |= UAC_EP_CS_ATTR_PITCH_CONTROL;
 610	} else { /* UAC_VERSION_3 */
 611		struct uac3_iso_endpoint_descriptor *csep3 =
 612			(struct uac3_iso_endpoint_descriptor *) csep;
 613
 614		if (csep3->bLength < sizeof(*csep3))
 615			goto error;
 616		/* emulate the endpoint attributes of a v1 device */
 617		if (le32_to_cpu(csep3->bmControls) & UAC2_CONTROL_PITCH)
 618			attributes |= UAC_EP_CS_ATTR_PITCH_CONTROL;
 619	}
 620
 621	return attributes;
 622
 623 error:
 624	usb_audio_warn(chip,
 625		       "%u:%d : no or invalid class specific endpoint descriptor\n",
 626		       iface_no, altsd->bAlternateSetting);
 627	return 0;
 628}
 629
 630/* find an input terminal descriptor (either UAC1 or UAC2) with the given
 631 * terminal id
 632 */
 633static void *
 634snd_usb_find_input_terminal_descriptor(struct usb_host_interface *ctrl_iface,
 635				       int terminal_id, int protocol)
 636{
 637	struct uac2_input_terminal_descriptor *term = NULL;
 638
 639	while ((term = snd_usb_find_csint_desc(ctrl_iface->extra,
 640					       ctrl_iface->extralen,
 641					       term, UAC_INPUT_TERMINAL))) {
 642		if (!snd_usb_validate_audio_desc(term, protocol))
 643			continue;
 644		if (term->bTerminalID == terminal_id)
 645			return term;
 646	}
 647
 648	return NULL;
 649}
 650
 651static void *
 652snd_usb_find_output_terminal_descriptor(struct usb_host_interface *ctrl_iface,
 653					int terminal_id, int protocol)
 654{
 655	/* OK to use with both UAC2 and UAC3 */
 656	struct uac2_output_terminal_descriptor *term = NULL;
 657
 658	while ((term = snd_usb_find_csint_desc(ctrl_iface->extra,
 659					       ctrl_iface->extralen,
 660					       term, UAC_OUTPUT_TERMINAL))) {
 661		if (!snd_usb_validate_audio_desc(term, protocol))
 662			continue;
 663		if (term->bTerminalID == terminal_id)
 664			return term;
 665	}
 666
 667	return NULL;
 668}
 669
 670static struct audioformat *
 671audio_format_alloc_init(struct snd_usb_audio *chip,
 672		       struct usb_host_interface *alts,
 673		       int protocol, int iface_no, int altset_idx,
 674		       int altno, int num_channels, int clock)
 675{
 676	struct audioformat *fp;
 677
 678	fp = kzalloc(sizeof(*fp), GFP_KERNEL);
 679	if (!fp)
 680		return NULL;
 681
 682	fp->iface = iface_no;
 683	fp->altsetting = altno;
 684	fp->altset_idx = altset_idx;
 685	fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
 686	fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
 687	fp->datainterval = snd_usb_parse_datainterval(chip, alts);
 688	fp->protocol = protocol;
 689	fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
 690	fp->channels = num_channels;
 691	if (snd_usb_get_speed(chip->dev) == USB_SPEED_HIGH)
 692		fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
 693				* (fp->maxpacksize & 0x7ff);
 694	fp->clock = clock;
 695	INIT_LIST_HEAD(&fp->list);
 696
 697	return fp;
 698}
 699
 700static struct audioformat *
 701snd_usb_get_audioformat_uac12(struct snd_usb_audio *chip,
 702			      struct usb_host_interface *alts,
 703			      int protocol, int iface_no, int altset_idx,
 704			      int altno, int stream, int bm_quirk)
 705{
 706	struct usb_device *dev = chip->dev;
 707	struct uac_format_type_i_continuous_descriptor *fmt;
 708	unsigned int num_channels = 0, chconfig = 0;
 709	struct audioformat *fp;
 710	int clock = 0;
 711	u64 format;
 712
 713	/* get audio formats */
 714	if (protocol == UAC_VERSION_1) {
 715		struct uac1_as_header_descriptor *as =
 716			snd_usb_find_csint_desc(alts->extra, alts->extralen,
 717						NULL, UAC_AS_GENERAL);
 718		struct uac_input_terminal_descriptor *iterm;
 719
 720		if (!as) {
 721			dev_err(&dev->dev,
 722				"%u:%d : UAC_AS_GENERAL descriptor not found\n",
 723				iface_no, altno);
 724			return NULL;
 725		}
 726
 727		if (as->bLength < sizeof(*as)) {
 728			dev_err(&dev->dev,
 729				"%u:%d : invalid UAC_AS_GENERAL desc\n",
 730				iface_no, altno);
 731			return NULL;
 732		}
 733
 734		format = le16_to_cpu(as->wFormatTag); /* remember the format value */
 735
 736		iterm = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf,
 737							       as->bTerminalLink,
 738							       protocol);
 739		if (iterm) {
 740			num_channels = iterm->bNrChannels;
 741			chconfig = le16_to_cpu(iterm->wChannelConfig);
 742		}
 743	} else { /* UAC_VERSION_2 */
 744		struct uac2_input_terminal_descriptor *input_term;
 745		struct uac2_output_terminal_descriptor *output_term;
 746		struct uac2_as_header_descriptor *as =
 747			snd_usb_find_csint_desc(alts->extra, alts->extralen,
 748						NULL, UAC_AS_GENERAL);
 749
 750		if (!as) {
 751			dev_err(&dev->dev,
 752				"%u:%d : UAC_AS_GENERAL descriptor not found\n",
 753				iface_no, altno);
 754			return NULL;
 755		}
 756
 757		if (as->bLength < sizeof(*as)) {
 758			dev_err(&dev->dev,
 759				"%u:%d : invalid UAC_AS_GENERAL desc\n",
 760				iface_no, altno);
 761			return NULL;
 762		}
 763
 764		num_channels = as->bNrChannels;
 765		format = le32_to_cpu(as->bmFormats);
 766		chconfig = le32_to_cpu(as->bmChannelConfig);
 767
 768		/*
 769		 * lookup the terminal associated to this interface
 770		 * to extract the clock
 771		 */
 772		input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf,
 773								    as->bTerminalLink,
 774								    protocol);
 775		if (input_term) {
 776			clock = input_term->bCSourceID;
 777			if (!chconfig && (num_channels == input_term->bNrChannels))
 778				chconfig = le32_to_cpu(input_term->bmChannelConfig);
 779			goto found_clock;
 780		}
 781
 782		output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf,
 783								      as->bTerminalLink,
 784								      protocol);
 785		if (output_term) {
 786			clock = output_term->bCSourceID;
 787			goto found_clock;
 788		}
 789
 790		dev_err(&dev->dev,
 791			"%u:%d : bogus bTerminalLink %d\n",
 792			iface_no, altno, as->bTerminalLink);
 793		return NULL;
 794	}
 795
 796found_clock:
 797	/* get format type */
 798	fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen,
 799				      NULL, UAC_FORMAT_TYPE);
 800	if (!fmt) {
 801		dev_err(&dev->dev,
 802			"%u:%d : no UAC_FORMAT_TYPE desc\n",
 803			iface_no, altno);
 804		return NULL;
 805	}
 806	if (((protocol == UAC_VERSION_1) && (fmt->bLength < 8))
 807			|| ((protocol == UAC_VERSION_2) &&
 808					(fmt->bLength < 6))) {
 809		dev_err(&dev->dev,
 810			"%u:%d : invalid UAC_FORMAT_TYPE desc\n",
 811			iface_no, altno);
 812		return NULL;
 813	}
 814
 815	/*
 816	 * Blue Microphones workaround: The last altsetting is
 817	 * identical with the previous one, except for a larger
 818	 * packet size, but is actually a mislabeled two-channel
 819	 * setting; ignore it.
 820	 *
 821	 * Part 2: analyze quirk flag and format
 822	 */
 823	if (bm_quirk && fmt->bNrChannels == 1 && fmt->bSubframeSize == 2)
 824		return NULL;
 825
 826	fp = audio_format_alloc_init(chip, alts, protocol, iface_no,
 827				     altset_idx, altno, num_channels, clock);
 828	if (!fp)
 829		return ERR_PTR(-ENOMEM);
 830
 831	fp->attributes = parse_uac_endpoint_attributes(chip, alts, protocol,
 832						       iface_no);
 833
 834	/* some quirks for attributes here */
 835	snd_usb_audioformat_attributes_quirk(chip, fp, stream);
 836
 837	/* ok, let's parse further... */
 838	if (snd_usb_parse_audio_format(chip, fp, format,
 839					fmt, stream) < 0) {
 840		audioformat_free(fp);
 841		return NULL;
 842	}
 843
 844	/* Create chmap */
 845	if (fp->channels != num_channels)
 846		chconfig = 0;
 847
 848	fp->chmap = convert_chmap(fp->channels, chconfig, protocol);
 849
 850	return fp;
 851}
 852
 853static struct audioformat *
 854snd_usb_get_audioformat_uac3(struct snd_usb_audio *chip,
 855			     struct usb_host_interface *alts,
 856			     struct snd_usb_power_domain **pd_out,
 857			     int iface_no, int altset_idx,
 858			     int altno, int stream)
 859{
 860	struct usb_device *dev = chip->dev;
 861	struct uac3_input_terminal_descriptor *input_term;
 862	struct uac3_output_terminal_descriptor *output_term;
 863	struct uac3_cluster_header_descriptor *cluster;
 864	struct uac3_as_header_descriptor *as = NULL;
 865	struct uac3_hc_descriptor_header hc_header;
 866	struct snd_pcm_chmap_elem *chmap;
 867	struct snd_usb_power_domain *pd;
 868	unsigned char badd_profile;
 869	u64 badd_formats = 0;
 870	unsigned int num_channels;
 871	struct audioformat *fp;
 872	u16 cluster_id, wLength;
 873	int clock = 0;
 874	int err;
 875
 876	badd_profile = chip->badd_profile;
 877
 878	if (badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) {
 879		unsigned int maxpacksize =
 880			le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
 881
 882		switch (maxpacksize) {
 883		default:
 884			dev_err(&dev->dev,
 885				"%u:%d : incorrect wMaxPacketSize for BADD profile\n",
 886				iface_no, altno);
 887			return NULL;
 888		case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_16:
 889		case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_16:
 890			badd_formats = SNDRV_PCM_FMTBIT_S16_LE;
 891			num_channels = 1;
 892			break;
 893		case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_24:
 894		case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_24:
 895			badd_formats = SNDRV_PCM_FMTBIT_S24_3LE;
 896			num_channels = 1;
 897			break;
 898		case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_16:
 899		case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_16:
 900			badd_formats = SNDRV_PCM_FMTBIT_S16_LE;
 901			num_channels = 2;
 902			break;
 903		case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_24:
 904		case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_24:
 905			badd_formats = SNDRV_PCM_FMTBIT_S24_3LE;
 906			num_channels = 2;
 907			break;
 908		}
 909
 910		chmap = kzalloc(sizeof(*chmap), GFP_KERNEL);
 911		if (!chmap)
 912			return ERR_PTR(-ENOMEM);
 913
 914		if (num_channels == 1) {
 915			chmap->map[0] = SNDRV_CHMAP_MONO;
 916		} else {
 917			chmap->map[0] = SNDRV_CHMAP_FL;
 918			chmap->map[1] = SNDRV_CHMAP_FR;
 919		}
 920
 921		chmap->channels = num_channels;
 922		clock = UAC3_BADD_CS_ID9;
 923		goto found_clock;
 924	}
 925
 926	as = snd_usb_find_csint_desc(alts->extra, alts->extralen,
 927				     NULL, UAC_AS_GENERAL);
 928	if (!as) {
 929		dev_err(&dev->dev,
 930			"%u:%d : UAC_AS_GENERAL descriptor not found\n",
 931			iface_no, altno);
 932		return NULL;
 933	}
 934
 935	if (as->bLength < sizeof(*as)) {
 936		dev_err(&dev->dev,
 937			"%u:%d : invalid UAC_AS_GENERAL desc\n",
 938			iface_no, altno);
 939		return NULL;
 940	}
 941
 942	cluster_id = le16_to_cpu(as->wClusterDescrID);
 943	if (!cluster_id) {
 944		dev_err(&dev->dev,
 945			"%u:%d : no cluster descriptor\n",
 946			iface_no, altno);
 947		return NULL;
 948	}
 949
 950	/*
 951	 * Get number of channels and channel map through
 952	 * High Capability Cluster Descriptor
 953	 *
 954	 * First step: get High Capability header and
 955	 * read size of Cluster Descriptor
 956	 */
 957	err = snd_usb_ctl_msg(chip->dev,
 958			usb_rcvctrlpipe(chip->dev, 0),
 959			UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR,
 960			USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
 961			cluster_id,
 962			snd_usb_ctrl_intf(chip),
 963			&hc_header, sizeof(hc_header));
 964	if (err < 0)
 965		return ERR_PTR(err);
 966	else if (err != sizeof(hc_header)) {
 967		dev_err(&dev->dev,
 968			"%u:%d : can't get High Capability descriptor\n",
 969			iface_no, altno);
 970		return ERR_PTR(-EIO);
 971	}
 972
 973	/*
 974	 * Second step: allocate needed amount of memory
 975	 * and request Cluster Descriptor
 976	 */
 977	wLength = le16_to_cpu(hc_header.wLength);
 978	cluster = kzalloc(wLength, GFP_KERNEL);
 979	if (!cluster)
 980		return ERR_PTR(-ENOMEM);
 981	err = snd_usb_ctl_msg(chip->dev,
 982			usb_rcvctrlpipe(chip->dev, 0),
 983			UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR,
 984			USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
 985			cluster_id,
 986			snd_usb_ctrl_intf(chip),
 987			cluster, wLength);
 988	if (err < 0) {
 989		kfree(cluster);
 990		return ERR_PTR(err);
 991	} else if (err != wLength) {
 992		dev_err(&dev->dev,
 993			"%u:%d : can't get Cluster Descriptor\n",
 994			iface_no, altno);
 995		kfree(cluster);
 996		return ERR_PTR(-EIO);
 997	}
 998
 999	num_channels = cluster->bNrChannels;
1000	chmap = convert_chmap_v3(cluster);
1001	kfree(cluster);
1002
1003	/*
1004	 * lookup the terminal associated to this interface
1005	 * to extract the clock
1006	 */
1007	input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf,
1008							    as->bTerminalLink,
1009							    UAC_VERSION_3);
1010	if (input_term) {
1011		clock = input_term->bCSourceID;
1012		goto found_clock;
1013	}
1014
1015	output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf,
1016							      as->bTerminalLink,
1017							      UAC_VERSION_3);
1018	if (output_term) {
1019		clock = output_term->bCSourceID;
1020		goto found_clock;
1021	}
1022
1023	dev_err(&dev->dev, "%u:%d : bogus bTerminalLink %d\n",
1024			iface_no, altno, as->bTerminalLink);
1025	kfree(chmap);
1026	return NULL;
1027
1028found_clock:
1029	fp = audio_format_alloc_init(chip, alts, UAC_VERSION_3, iface_no,
1030				     altset_idx, altno, num_channels, clock);
1031	if (!fp) {
1032		kfree(chmap);
1033		return ERR_PTR(-ENOMEM);
1034	}
1035
1036	fp->chmap = chmap;
1037
1038	if (badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) {
1039		fp->attributes = 0; /* No attributes */
1040
1041		fp->fmt_type = UAC_FORMAT_TYPE_I;
1042		fp->formats = badd_formats;
1043
1044		fp->nr_rates = 0;	/* SNDRV_PCM_RATE_CONTINUOUS */
1045		fp->rate_min = UAC3_BADD_SAMPLING_RATE;
1046		fp->rate_max = UAC3_BADD_SAMPLING_RATE;
1047		fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
1048
1049		pd = kzalloc(sizeof(*pd), GFP_KERNEL);
1050		if (!pd) {
1051			audioformat_free(fp);
1052			return NULL;
1053		}
1054		pd->pd_id = (stream == SNDRV_PCM_STREAM_PLAYBACK) ?
1055					UAC3_BADD_PD_ID10 : UAC3_BADD_PD_ID11;
1056		pd->pd_d1d0_rec = UAC3_BADD_PD_RECOVER_D1D0;
1057		pd->pd_d2d0_rec = UAC3_BADD_PD_RECOVER_D2D0;
1058
1059	} else {
1060		fp->attributes = parse_uac_endpoint_attributes(chip, alts,
1061							       UAC_VERSION_3,
1062							       iface_no);
1063
1064		pd = snd_usb_find_power_domain(chip->ctrl_intf,
1065					       as->bTerminalLink);
1066
1067		/* ok, let's parse further... */
1068		if (snd_usb_parse_audio_format_v3(chip, fp, as, stream) < 0) {
1069			kfree(pd);
1070			audioformat_free(fp);
1071			return NULL;
1072		}
1073	}
1074
1075	if (pd)
1076		*pd_out = pd;
1077
1078	return fp;
1079}
1080
1081static int __snd_usb_parse_audio_interface(struct snd_usb_audio *chip,
1082					   int iface_no,
1083					   bool *has_non_pcm, bool non_pcm)
1084{
1085	struct usb_device *dev;
1086	struct usb_interface *iface;
1087	struct usb_host_interface *alts;
1088	struct usb_interface_descriptor *altsd;
1089	int i, altno, err, stream;
 
1090	struct audioformat *fp = NULL;
1091	struct snd_usb_power_domain *pd = NULL;
1092	int num, protocol;
 
1093
1094	dev = chip->dev;
1095
1096	/* parse the interface's altsettings */
1097	iface = usb_ifnum_to_if(dev, iface_no);
1098
1099	num = iface->num_altsetting;
1100
1101	/*
1102	 * Dallas DS4201 workaround: It presents 5 altsettings, but the last
1103	 * one misses syncpipe, and does not produce any sound.
1104	 */
1105	if (chip->usb_id == USB_ID(0x04fa, 0x4201))
1106		num = 4;
1107
1108	for (i = 0; i < num; i++) {
1109		alts = &iface->altsetting[i];
1110		altsd = get_iface_desc(alts);
1111		protocol = altsd->bInterfaceProtocol;
1112		/* skip invalid one */
1113		if (((altsd->bInterfaceClass != USB_CLASS_AUDIO ||
1114		      (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING &&
1115		       altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC)) &&
1116		     altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
1117		    altsd->bNumEndpoints < 1 ||
1118		    le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
1119			continue;
1120		/* must be isochronous */
1121		if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
1122		    USB_ENDPOINT_XFER_ISOC)
1123			continue;
1124		/* check direction */
1125		stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ?
1126			SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
1127		altno = altsd->bAlternateSetting;
1128
1129		if (snd_usb_apply_interface_quirk(chip, iface_no, altno))
1130			continue;
1131
1132		/*
1133		 * Roland audio streaming interfaces are marked with protocols
1134		 * 0/1/2, but are UAC 1 compatible.
1135		 */
1136		if (USB_ID_VENDOR(chip->usb_id) == 0x0582 &&
1137		    altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC &&
1138		    protocol <= 2)
1139			protocol = UAC_VERSION_1;
1140
 
 
1141		switch (protocol) {
1142		default:
1143			dev_dbg(&dev->dev, "%u:%d: unknown interface protocol %#02x, assuming v1\n",
1144				iface_no, altno, protocol);
1145			protocol = UAC_VERSION_1;
1146			/* fall through */
1147		case UAC_VERSION_1:
1148			/* fall through */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1149		case UAC_VERSION_2: {
1150			int bm_quirk = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1151
1152			/*
1153			 * Blue Microphones workaround: The last altsetting is
1154			 * identical with the previous one, except for a larger
1155			 * packet size, but is actually a mislabeled two-channel
1156			 * setting; ignore it.
1157			 *
1158			 * Part 1: prepare quirk flag
1159			 */
1160			if (altno == 2 && num == 3 &&
1161			    fp && fp->altsetting == 1 && fp->channels == 1 &&
1162			    fp->formats == SNDRV_PCM_FMTBIT_S16_LE &&
1163			    protocol == UAC_VERSION_1 &&
1164			    le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) ==
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1165							fp->maxpacksize * 2)
1166				bm_quirk = 1;
 
 
 
 
 
 
1167
1168			fp = snd_usb_get_audioformat_uac12(chip, alts, protocol,
1169							   iface_no, i, altno,
1170							   stream, bm_quirk);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1171			break;
1172		}
1173		case UAC_VERSION_3:
1174			fp = snd_usb_get_audioformat_uac3(chip, alts, &pd,
1175						iface_no, i, altno, stream);
 
 
 
 
 
 
 
 
 
 
1176			break;
1177		}
1178
1179		if (!fp)
1180			continue;
1181		else if (IS_ERR(fp))
1182			return PTR_ERR(fp);
1183
1184		if (fp->fmt_type != UAC_FORMAT_TYPE_I)
1185			*has_non_pcm = true;
1186		if ((fp->fmt_type == UAC_FORMAT_TYPE_I) == non_pcm) {
1187			audioformat_free(fp);
1188			kfree(pd);
1189			fp = NULL;
1190			pd = NULL;
1191			continue;
1192		}
1193
 
 
 
 
 
1194		dev_dbg(&dev->dev, "%u:%d: add audio endpoint %#x\n", iface_no, altno, fp->endpoint);
1195		if (protocol == UAC_VERSION_3)
1196			err = snd_usb_add_audio_stream_v3(chip, stream, fp, pd);
1197		else
1198			err = snd_usb_add_audio_stream(chip, stream, fp);
1199
1200		if (err < 0) {
1201			audioformat_free(fp);
1202			kfree(pd);
 
1203			return err;
1204		}
1205		/* try to set the interface... */
1206		usb_set_interface(chip->dev, iface_no, altno);
1207		snd_usb_init_pitch(chip, iface_no, alts, fp);
1208		snd_usb_init_sample_rate(chip, iface_no, alts, fp, fp->rate_max);
1209	}
1210	return 0;
1211}
1212
1213int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
1214{
1215	int err;
1216	bool has_non_pcm = false;
1217
1218	/* parse PCM formats */
1219	err = __snd_usb_parse_audio_interface(chip, iface_no, &has_non_pcm, false);
1220	if (err < 0)
1221		return err;
1222
1223	if (has_non_pcm) {
1224		/* parse non-PCM formats */
1225		err = __snd_usb_parse_audio_interface(chip, iface_no, &has_non_pcm, true);
1226		if (err < 0)
1227			return err;
1228	}
1229
1230	return 0;
1231}
1232