Linux Audio

Check our new training course

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