[net-next-2.6.git] / sound / usb / endpoint.c

/*
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */

#include <linux/init.h>
#include <linux/slab.h>
#include <linux/usb.h>
#include <linux/usb/audio.h>
#include <linux/usb/audio-v2.h>

#include <sound/core.h>
#include <sound/pcm.h>

#include "usbaudio.h"
#include "card.h"
#include "proc.h"
#include "quirks.h"
#include "endpoint.h"
#include "urb.h"
#include "pcm.h"
#include "helper.h"
#include "format.h"
#include "clock.h"

/*
 * free a substream
 */
static void free_substream(struct snd_usb_substream *subs)
{
	struct list_head *p, *n;

	if (!subs->num_formats)
		return; /* not initialized */
	list_for_each_safe(p, n, &subs->fmt_list) {
		struct audioformat *fp = list_entry(p, struct audioformat, list);
		kfree(fp->rate_table);
		kfree(fp);
	}
	kfree(subs->rate_list.list);
}


/*
 * free a usb stream instance
 */
static void snd_usb_audio_stream_free(struct snd_usb_stream *stream)
{
	free_substream(&stream->substream[0]);
	free_substream(&stream->substream[1]);
	list_del(&stream->list);
	kfree(stream);
}

static void snd_usb_audio_pcm_free(struct snd_pcm *pcm)
{
	struct snd_usb_stream *stream = pcm->private_data;
	if (stream) {
		stream->pcm = NULL;
		snd_usb_audio_stream_free(stream);
	}
}


/*
 * add this endpoint to the chip instance.
 * if a stream with the same endpoint already exists, append to it.
 * if not, create a new pcm stream.
 */
int snd_usb_add_audio_endpoint(struct snd_usb_audio *chip, int stream, struct audioformat *fp)
{
	struct list_head *p;
	struct snd_usb_stream *as;
	struct snd_usb_substream *subs;
	struct snd_pcm *pcm;
	int err;

	list_for_each(p, &chip->pcm_list) {
		as = list_entry(p, struct snd_usb_stream, list);
		if (as->fmt_type != fp->fmt_type)
			continue;
		subs = &as->substream[stream];
		if (!subs->endpoint)
			continue;
		if (subs->endpoint == fp->endpoint) {
			list_add_tail(&fp->list, &subs->fmt_list);
			subs->num_formats++;
			subs->formats |= fp->formats;
			return 0;
		}
	}
	/* look for an empty stream */
	list_for_each(p, &chip->pcm_list) {
		as = list_entry(p, struct snd_usb_stream, list);
		if (as->fmt_type != fp->fmt_type)
			continue;
		subs = &as->substream[stream];
		if (subs->endpoint)
			continue;
		err = snd_pcm_new_stream(as->pcm, stream, 1);
		if (err < 0)
			return err;
		snd_usb_init_substream(as, stream, fp);
		return 0;
	}

	/* create a new pcm */
	as = kzalloc(sizeof(*as), GFP_KERNEL);
	if (!as)
		return -ENOMEM;
	as->pcm_index = chip->pcm_devs;
	as->chip = chip;
	as->fmt_type = fp->fmt_type;
	err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs,
			  stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0,
			  stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1,
			  &pcm);
	if (err < 0) {
		kfree(as);
		return err;
	}
	as->pcm = pcm;
	pcm->private_data = as;
	pcm->private_free = snd_usb_audio_pcm_free;
	pcm->info_flags = 0;
	if (chip->pcm_devs > 0)
		sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs);
	else
		strcpy(pcm->name, "USB Audio");

	snd_usb_init_substream(as, stream, fp);

	list_add(&as->list, &chip->pcm_list);
	chip->pcm_devs++;

	snd_usb_proc_pcm_format_add(as);

	return 0;
}

static int parse_uac_endpoint_attributes(struct snd_usb_audio *chip,
					 struct usb_host_interface *alts,
					 int protocol, int iface_no)
{
	/* parsed with a v1 header here. that's ok as we only look at the
	 * header first which is the same for both versions */
	struct uac_iso_endpoint_descriptor *csep;
	struct usb_interface_descriptor *altsd = get_iface_desc(alts);
	int attributes = 0;

	csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT);

	/* Creamware Noah has this descriptor after the 2nd endpoint */
	if (!csep && altsd->bNumEndpoints >= 2)
		csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);

	if (!csep || csep->bLength < 7 ||
	    csep->bDescriptorSubtype != UAC_EP_GENERAL) {
		snd_printk(KERN_WARNING "%d:%u:%d : no or invalid"
			   " class specific endpoint descriptor\n",
			   chip->dev->devnum, iface_no,
			   altsd->bAlternateSetting);
		return 0;
	}

	if (protocol == UAC_VERSION_1) {
		attributes = csep->bmAttributes;
	} else {
		struct uac2_iso_endpoint_descriptor *csep2 =
			(struct uac2_iso_endpoint_descriptor *) csep;

		attributes = csep->bmAttributes & UAC_EP_CS_ATTR_FILL_MAX;

		/* emulate the endpoint attributes of a v1 device */
		if (csep2->bmControls & UAC2_CONTROL_PITCH)
			attributes |= UAC_EP_CS_ATTR_PITCH_CONTROL;
	}

	return attributes;
}

static struct uac2_input_terminal_descriptor *
	snd_usb_find_input_terminal_descriptor(struct usb_host_interface *ctrl_iface,
					       int terminal_id)
{
	struct uac2_input_terminal_descriptor *term = NULL;

	while ((term = snd_usb_find_csint_desc(ctrl_iface->extra,
					       ctrl_iface->extralen,
					       term, UAC_INPUT_TERMINAL))) {
		if (term->bTerminalID == terminal_id)
			return term;
	}

	return NULL;
}

static struct uac2_output_terminal_descriptor *
	snd_usb_find_output_terminal_descriptor(struct usb_host_interface *ctrl_iface,
						int terminal_id)
{
	struct uac2_output_terminal_descriptor *term = NULL;

	while ((term = snd_usb_find_csint_desc(ctrl_iface->extra,
					       ctrl_iface->extralen,
					       term, UAC_OUTPUT_TERMINAL))) {
		if (term->bTerminalID == terminal_id)
			return term;
	}

	return NULL;
}

int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
{
	struct usb_device *dev;
	struct usb_interface *iface;
	struct usb_host_interface *alts;
	struct usb_interface_descriptor *altsd;
	int i, altno, err, stream;
	int format = 0, num_channels = 0;
	struct audioformat *fp = NULL;
	int num, protocol, clock = 0;
	struct uac_format_type_i_continuous_descriptor *fmt;

	dev = chip->dev;

	/* parse the interface's altsettings */
	iface = usb_ifnum_to_if(dev, iface_no);

	num = iface->num_altsetting;

	/*
	 * Dallas DS4201 workaround: It presents 5 altsettings, but the last
	 * one misses syncpipe, and does not produce any sound.
	 */
	if (chip->usb_id == USB_ID(0x04fa, 0x4201))
		num = 4;

	for (i = 0; i < num; i++) {
		alts = &iface->altsetting[i];
		altsd = get_iface_desc(alts);
		protocol = altsd->bInterfaceProtocol;
		/* skip invalid one */
		if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
		     altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
		    (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING &&
		     altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) ||
		    altsd->bNumEndpoints < 1 ||
		    le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
			continue;
		/* must be isochronous */
		if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
		    USB_ENDPOINT_XFER_ISOC)
			continue;
		/* check direction */
		stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ?
			SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
		altno = altsd->bAlternateSetting;

		if (snd_usb_apply_interface_quirk(chip, iface_no, altno))
			continue;

		/* get audio formats */
		switch (protocol) {
		default:
			snd_printdd(KERN_WARNING "%d:%u:%d: unknown interface protocol %#02x, assuming v1\n",
				    dev->devnum, iface_no, altno, protocol);
			protocol = UAC_VERSION_1;
			/* fall through */

		case UAC_VERSION_1: {
			struct uac1_as_header_descriptor *as =
				snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);

			if (!as) {
				snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
					   dev->devnum, iface_no, altno);
				continue;
			}

			if (as->bLength < sizeof(*as)) {
				snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
					   dev->devnum, iface_no, altno);
				continue;
			}

			format = le16_to_cpu(as->wFormatTag); /* remember the format value */
			break;
		}

		case UAC_VERSION_2: {
			struct uac2_input_terminal_descriptor *input_term;
			struct uac2_output_terminal_descriptor *output_term;
			struct uac2_as_header_descriptor *as =
				snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);

			if (!as) {
				snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
					   dev->devnum, iface_no, altno);
				continue;
			}

			if (as->bLength < sizeof(*as)) {
				snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
					   dev->devnum, iface_no, altno);
				continue;
			}

			num_channels = as->bNrChannels;
			format = le32_to_cpu(as->bmFormats);

			/* lookup the terminal associated to this interface
			 * to extract the clock */
			input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf,
									    as->bTerminalLink);
			if (input_term) {
				clock = input_term->bCSourceID;
				break;
			}

			output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf,
									      as->bTerminalLink);
			if (output_term) {
				clock = output_term->bCSourceID;
				break;
			}

			snd_printk(KERN_ERR "%d:%u:%d : bogus bTerminalLink %d\n",
				   dev->devnum, iface_no, altno, as->bTerminalLink);
			continue;
		}
		}

		/* get format type */
		fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE);
		if (!fmt) {
			snd_printk(KERN_ERR "%d:%u:%d : no UAC_FORMAT_TYPE desc\n",
				   dev->devnum, iface_no, altno);
			continue;
		}
		if (((protocol == UAC_VERSION_1) && (fmt->bLength < 8)) ||
		    ((protocol == UAC_VERSION_2) && (fmt->bLength != 6))) {
			snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
				   dev->devnum, iface_no, altno);
			continue;
		}

		/*
		 * Blue Microphones workaround: The last altsetting is identical
		 * with the previous one, except for a larger packet size, but
		 * is actually a mislabeled two-channel setting; ignore it.
		 */
		if (fmt->bNrChannels == 1 &&
		    fmt->bSubframeSize == 2 &&
		    altno == 2 && num == 3 &&
		    fp && fp->altsetting == 1 && fp->channels == 1 &&
		    fp->formats == SNDRV_PCM_FMTBIT_S16_LE &&
		    protocol == UAC_VERSION_1 &&
		    le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) ==
							fp->maxpacksize * 2)
			continue;

		fp = kzalloc(sizeof(*fp), GFP_KERNEL);
		if (! fp) {
			snd_printk(KERN_ERR "cannot malloc\n");
			return -ENOMEM;
		}

		fp->iface = iface_no;
		fp->altsetting = altno;
		fp->altset_idx = i;
		fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
		fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
		fp->datainterval = snd_usb_parse_datainterval(chip, alts);
		fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
		/* num_channels is only set for v2 interfaces */
		fp->channels = num_channels;
		if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
			fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
					* (fp->maxpacksize & 0x7ff);
		fp->attributes = parse_uac_endpoint_attributes(chip, alts, protocol, iface_no);
		fp->clock = clock;

		/* some quirks for attributes here */

		switch (chip->usb_id) {
		case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
			/* Optoplay sets the sample rate attribute although
			 * it seems not supporting it in fact.
			 */
			fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE;
			break;
		case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
		case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
		case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra 8 */
		case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
			/* doesn't set the sample rate attribute, but supports it */
			fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE;
			break;
		case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
		case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
						an older model 77d:223) */
		/*
		 * plantronics headset and Griffin iMic have set adaptive-in
		 * although it's really not...
		 */
			fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE;
			if (stream == SNDRV_PCM_STREAM_PLAYBACK)
				fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE;
			else
				fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC;
			break;
		}

		/* ok, let's parse further... */
		if (snd_usb_parse_audio_format(chip, fp, format, fmt, stream, alts) < 0) {
			kfree(fp->rate_table);
			kfree(fp);
			fp = NULL;
			continue;
		}

		snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint %#x\n", dev->devnum, iface_no, altno, fp->endpoint);
		err = snd_usb_add_audio_endpoint(chip, stream, fp);
		if (err < 0) {
			kfree(fp->rate_table);
			kfree(fp);
			return err;
		}
		/* try to set the interface... */
		usb_set_interface(chip->dev, iface_no, altno);
		snd_usb_init_pitch(chip, iface_no, alts, fp);
		snd_usb_init_sample_rate(chip, iface_no, alts, fp, fp->rate_max);
	}
	return 0;
}
Commit	Line	Data
e5779998 DM	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>
36db0456	19	#include <linux/slab.h>
e5779998 DM	20	#include <linux/usb.h>
e5779998 DM	21	#include <linux/usb/audio.h>
7e847894	22	#include <linux/usb/audio-v2.h>
e5779998 DM	23
	24	#include <sound/core.h>
	25	#include <sound/pcm.h>
	26
	27	#include "usbaudio.h"
	28	#include "card.h"
	29	#include "proc.h"
	30	#include "quirks.h"
	31	#include "endpoint.h"
	32	#include "urb.h"
	33	#include "pcm.h"
	34	#include "helper.h"
	35	#include "format.h"
3d8d4dcf	36	#include "clock.h"
e5779998 DM	37
	38	/*
	39	* free a substream
	40	*/
	41	static void free_substream(struct snd_usb_substream *subs)
	42	{
	43	struct list_head p, n;
	44
	45	if (!subs->num_formats)
	46	return; /* not initialized */
	47	list_for_each_safe(p, n, &subs->fmt_list) {
	48	struct audioformat *fp = list_entry(p, struct audioformat, list);
	49	kfree(fp->rate_table);
	50	kfree(fp);
	51	}
	52	kfree(subs->rate_list.list);
	53	}
	54
	55
	56	/*
	57	* free a usb stream instance
	58	*/
	59	static 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
	67	static 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	/*
	78	* add this endpoint to the chip instance.
	79	* if a stream with the same endpoint already exists, append to it.
	80	* if not, create a new pcm stream.
	81	*/
	82	int snd_usb_add_audio_endpoint(struct snd_usb_audio chip, int stream, struct audioformat fp)
	83	{
	84	struct list_head *p;
	85	struct snd_usb_stream *as;
	86	struct snd_usb_substream *subs;
	87	struct snd_pcm *pcm;
	88	int err;
	89
	90	list_for_each(p, &chip->pcm_list) {
	91	as = list_entry(p, struct snd_usb_stream, list);
	92	if (as->fmt_type != fp->fmt_type)
	93	continue;
	94	subs = &as->substream[stream];
	95	if (!subs->endpoint)
	96	continue;
	97	if (subs->endpoint == fp->endpoint) {
	98	list_add_tail(&fp->list, &subs->fmt_list);
	99	subs->num_formats++;
015eb0b0	100	subs->formats \|= fp->formats;
e5779998 DM	101	return 0;
	102	}
	103	}
	104	/* look for an empty stream */
	105	list_for_each(p, &chip->pcm_list) {
	106	as = list_entry(p, struct snd_usb_stream, list);
	107	if (as->fmt_type != fp->fmt_type)
	108	continue;
	109	subs = &as->substream[stream];
	110	if (subs->endpoint)
	111	continue;
	112	err = snd_pcm_new_stream(as->pcm, stream, 1);
	113	if (err < 0)
	114	return err;
	115	snd_usb_init_substream(as, stream, fp);
	116	return 0;
	117	}
	118
	119	/* create a new pcm */
	120	as = kzalloc(sizeof(*as), GFP_KERNEL);
	121	if (!as)
	122	return -ENOMEM;
	123	as->pcm_index = chip->pcm_devs;
	124	as->chip = chip;
	125	as->fmt_type = fp->fmt_type;
	126	err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs,
	127	stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0,
	128	stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1,
	129	&pcm);
	130	if (err < 0) {
	131	kfree(as);
	132	return err;
	133	}
	134	as->pcm = pcm;
	135	pcm->private_data = as;
	136	pcm->private_free = snd_usb_audio_pcm_free;
	137	pcm->info_flags = 0;
	138	if (chip->pcm_devs > 0)
	139	sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs);
	140	else
	141	strcpy(pcm->name, "USB Audio");
	142
	143	snd_usb_init_substream(as, stream, fp);
	144
	145	list_add(&as->list, &chip->pcm_list);
	146	chip->pcm_devs++;
	147
	148	snd_usb_proc_pcm_format_add(as);
	149
	150	return 0;
	151	}
	152
43b8e3bc DM	153	static int parse_uac_endpoint_attributes(struct snd_usb_audio *chip,
	154	struct usb_host_interface *alts,
	155	int protocol, int iface_no)
	156	{
	157	/* parsed with a v1 header here. that's ok as we only look at the
	158	* header first which is the same for both versions */
	159	struct uac_iso_endpoint_descriptor *csep;
	160	struct usb_interface_descriptor *altsd = get_iface_desc(alts);
	161	int attributes = 0;
	162
	163	csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT);
	164
	165	/* Creamware Noah has this descriptor after the 2nd endpoint */
	166	if (!csep && altsd->bNumEndpoints >= 2)
	167	csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
	168
	169	if (!csep \|\| csep->bLength < 7 \|\|
	170	csep->bDescriptorSubtype != UAC_EP_GENERAL) {
	171	snd_printk(KERN_WARNING "%d:%u:%d : no or invalid"
	172	" class specific endpoint descriptor\n",
	173	chip->dev->devnum, iface_no,
	174	altsd->bAlternateSetting);
	175	return 0;
	176	}
	177
	178	if (protocol == UAC_VERSION_1) {
	179	attributes = csep->bmAttributes;
	180	} else {
	181	struct uac2_iso_endpoint_descriptor *csep2 =
	182	(struct uac2_iso_endpoint_descriptor *) csep;
	183
	184	attributes = csep->bmAttributes & UAC_EP_CS_ATTR_FILL_MAX;
	185
	186	/* emulate the endpoint attributes of a v1 device */
	187	if (csep2->bmControls & UAC2_CONTROL_PITCH)
	188	attributes \|= UAC_EP_CS_ATTR_PITCH_CONTROL;
	189	}
	190
	191	return attributes;
	192	}
	193
79f920fb DM	194	static struct uac2_input_terminal_descriptor *
	195	snd_usb_find_input_terminal_descriptor(struct usb_host_interface *ctrl_iface,
	196	int terminal_id)
	197	{
	198	struct uac2_input_terminal_descriptor *term = NULL;
	199
	200	while ((term = snd_usb_find_csint_desc(ctrl_iface->extra,
	201	ctrl_iface->extralen,
	202	term, UAC_INPUT_TERMINAL))) {
	203	if (term->bTerminalID == terminal_id)
	204	return term;
	205	}
	206
	207	return NULL;
	208	}
	209
	210	static struct uac2_output_terminal_descriptor *
	211	snd_usb_find_output_terminal_descriptor(struct usb_host_interface *ctrl_iface,
	212	int terminal_id)
	213	{
	214	struct uac2_output_terminal_descriptor *term = NULL;
	215
	216	while ((term = snd_usb_find_csint_desc(ctrl_iface->extra,
	217	ctrl_iface->extralen,
	218	term, UAC_OUTPUT_TERMINAL))) {
	219	if (term->bTerminalID == terminal_id)
	220	return term;
	221	}
	222
	223	return NULL;
	224	}
	225
e5779998 DM	226	int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
	227	{
	228	struct usb_device *dev;
	229	struct usb_interface *iface;
	230	struct usb_host_interface *alts;
	231	struct usb_interface_descriptor *altsd;
	232	int i, altno, err, stream;
	233	int format = 0, num_channels = 0;
	234	struct audioformat *fp = NULL;
79f920fb	235	int num, protocol, clock = 0;
74754f97	236	struct uac_format_type_i_continuous_descriptor *fmt;
e5779998 DM	237
	238	dev = chip->dev;
	239
	240	/* parse the interface's altsettings */
	241	iface = usb_ifnum_to_if(dev, iface_no);
	242
	243	num = iface->num_altsetting;
	244
	245	/*
	246	* Dallas DS4201 workaround: It presents 5 altsettings, but the last
	247	* one misses syncpipe, and does not produce any sound.
	248	*/
	249	if (chip->usb_id == USB_ID(0x04fa, 0x4201))
	250	num = 4;
	251
	252	for (i = 0; i < num; i++) {
	253	alts = &iface->altsetting[i];
	254	altsd = get_iface_desc(alts);
	255	protocol = altsd->bInterfaceProtocol;
	256	/* skip invalid one */
	257	if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
	258	altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) \|\|
	259	(altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING &&
	260	altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) \|\|
	261	altsd->bNumEndpoints < 1 \|\|
	262	le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
	263	continue;
	264	/* must be isochronous */
	265	if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
	266	USB_ENDPOINT_XFER_ISOC)
	267	continue;
	268	/* check direction */
	269	stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ?
	270	SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
	271	altno = altsd->bAlternateSetting;
	272
	273	if (snd_usb_apply_interface_quirk(chip, iface_no, altno))
	274	continue;
	275
	276	/* get audio formats */
	277	switch (protocol) {
a2acad82 CL	278	default:
	279	snd_printdd(KERN_WARNING "%d:%u:%d: unknown interface protocol %#02x, assuming v1\n",
	280	dev->devnum, iface_no, altno, protocol);
	281	protocol = UAC_VERSION_1;
	282	/* fall through */
	283
e5779998	284	case UAC_VERSION_1: {
69da9bcb	285	struct uac1_as_header_descriptor *as =
e5779998 DM	286	snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
	287
	288	if (!as) {
	289	snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
	290	dev->devnum, iface_no, altno);
	291	continue;
	292	}
	293
	294	if (as->bLength < sizeof(*as)) {
	295	snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
	296	dev->devnum, iface_no, altno);
	297	continue;
	298	}
	299
	300	format = le16_to_cpu(as->wFormatTag); /* remember the format value */
	301	break;
	302	}
	303
	304	case UAC_VERSION_2: {
79f920fb DM	305	struct uac2_input_terminal_descriptor *input_term;
79f920fb DM	306	struct uac2_output_terminal_descriptor *output_term;
69da9bcb	307	struct uac2_as_header_descriptor *as =
e5779998 DM	308	snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
	309
	310	if (!as) {
	311	snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
	312	dev->devnum, iface_no, altno);
	313	continue;
	314	}
	315
	316	if (as->bLength < sizeof(*as)) {
	317	snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
	318	dev->devnum, iface_no, altno);
	319	continue;
	320	}
	321
	322	num_channels = as->bNrChannels;
	323	format = le32_to_cpu(as->bmFormats);
	324
79f920fb DM	325	/* lookup the terminal associated to this interface
	326	* to extract the clock */
	327	input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf,
	328	as->bTerminalLink);
	329	if (input_term) {
	330	clock = input_term->bCSourceID;
	331	break;
	332	}
	333
	334	output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf,
	335	as->bTerminalLink);
	336	if (output_term) {
	337	clock = output_term->bCSourceID;
	338	break;
	339	}
	340
	341	snd_printk(KERN_ERR "%d:%u:%d : bogus bTerminalLink %d\n",
	342	dev->devnum, iface_no, altno, as->bTerminalLink);
	343	continue;
e5779998	344	}
e5779998 DM	345	}
	346
	347	/* get format type */
	348	fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE);
	349	if (!fmt) {
	350	snd_printk(KERN_ERR "%d:%u:%d : no UAC_FORMAT_TYPE desc\n",
	351	dev->devnum, iface_no, altno);
	352	continue;
	353	}
74754f97 DM	354	if (((protocol == UAC_VERSION_1) && (fmt->bLength < 8)) \|\|
74754f97 DM	355	((protocol == UAC_VERSION_2) && (fmt->bLength != 6))) {
e5779998 DM	356	snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
	357	dev->devnum, iface_no, altno);
	358	continue;
	359	}
	360
	361	/*
	362	* Blue Microphones workaround: The last altsetting is identical
	363	* with the previous one, except for a larger packet size, but
	364	* is actually a mislabeled two-channel setting; ignore it.
	365	*/
74754f97 DM	366	if (fmt->bNrChannels == 1 &&
	367	fmt->bSubframeSize == 2 &&
	368	altno == 2 && num == 3 &&
e5779998	369	fp && fp->altsetting == 1 && fp->channels == 1 &&
015eb0b0	370	fp->formats == SNDRV_PCM_FMTBIT_S16_LE &&
e5779998 DM	371	protocol == UAC_VERSION_1 &&
	372	le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) ==
	373	fp->maxpacksize * 2)
	374	continue;
	375
e5779998 DM	376	fp = kzalloc(sizeof(*fp), GFP_KERNEL);
	377	if (! fp) {
	378	snd_printk(KERN_ERR "cannot malloc\n");
	379	return -ENOMEM;
	380	}
	381
	382	fp->iface = iface_no;
	383	fp->altsetting = altno;
	384	fp->altset_idx = i;
	385	fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
	386	fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
	387	fp->datainterval = snd_usb_parse_datainterval(chip, alts);
	388	fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
	389	/* num_channels is only set for v2 interfaces */
	390	fp->channels = num_channels;
	391	if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
	392	fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
	393	* (fp->maxpacksize & 0x7ff);
43b8e3bc	394	fp->attributes = parse_uac_endpoint_attributes(chip, alts, protocol, iface_no);
79f920fb	395	fp->clock = clock;
e5779998 DM	396
	397	/* some quirks for attributes here */
	398
	399	switch (chip->usb_id) {
	400	case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
	401	/* Optoplay sets the sample rate attribute although
	402	* it seems not supporting it in fact.
	403	*/
	404	fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE;
	405	break;
	406	case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
	407	case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
fca5bca4 FH	408	case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra 8 */
fca5bca4 FH	409	case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
e5779998 DM	410	/* doesn't set the sample rate attribute, but supports it */
	411	fp->attributes \|= UAC_EP_CS_ATTR_SAMPLE_RATE;
	412	break;
	413	case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
	414	case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
	415	an older model 77d:223) */
	416	/*
	417	* plantronics headset and Griffin iMic have set adaptive-in
	418	* although it's really not...
	419	*/
	420	fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE;
	421	if (stream == SNDRV_PCM_STREAM_PLAYBACK)
	422	fp->ep_attr \|= USB_ENDPOINT_SYNC_ADAPTIVE;
	423	else
	424	fp->ep_attr \|= USB_ENDPOINT_SYNC_SYNC;
	425	break;
	426	}
	427
	428	/* ok, let's parse further... */
	429	if (snd_usb_parse_audio_format(chip, fp, format, fmt, stream, alts) < 0) {
	430	kfree(fp->rate_table);
	431	kfree(fp);
272cbc98	432	fp = NULL;
e5779998 DM	433	continue;
	434	}
	435
	436	snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint %#x\n", dev->devnum, iface_no, altno, fp->endpoint);
	437	err = snd_usb_add_audio_endpoint(chip, stream, fp);
	438	if (err < 0) {
	439	kfree(fp->rate_table);
	440	kfree(fp);
	441	return err;
	442	}
	443	/* try to set the interface... */
	444	usb_set_interface(chip->dev, iface_no, altno);
767d75ad DM	445	snd_usb_init_pitch(chip, iface_no, alts, fp);
767d75ad DM	446	snd_usb_init_sample_rate(chip, iface_no, alts, fp, fp->rate_max);
e5779998 DM	447	}
	448	return 0;
	449	}
	450