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