1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 */
   4
   5#include <linux/init.h>
   6#include <linux/slab.h>
   7#include <linux/usb.h>
   8#include <linux/usb/audio.h>
   9#include <linux/usb/midi.h>
  10#include <linux/bits.h>
  11
  12#include <sound/control.h>
  13#include <sound/core.h>
  14#include <sound/info.h>
  15#include <sound/pcm.h>
  16
  17#include "usbaudio.h"
  18#include "card.h"
  19#include "mixer.h"
  20#include "mixer_quirks.h"
  21#include "midi.h"
  22#include "quirks.h"
  23#include "helper.h"
  24#include "endpoint.h"
  25#include "pcm.h"
  26#include "clock.h"
  27#include "stream.h"
  28
  29/*
  30 * handle the quirks for the contained interfaces
  31 */
  32static int create_composite_quirk(struct snd_usb_audio *chip,
  33				  struct usb_interface *iface,
  34				  struct usb_driver *driver,
  35				  const struct snd_usb_audio_quirk *quirk_comp)
  36{
  37	int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
  38	const struct snd_usb_audio_quirk *quirk;
  39	int err;
  40
  41	for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) {
  42		iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
  43		if (!iface)
  44			continue;
  45		if (quirk->ifnum != probed_ifnum &&
  46		    usb_interface_claimed(iface))
  47			continue;
  48		err = snd_usb_create_quirk(chip, iface, driver, quirk);
  49		if (err < 0)
  50			return err;
  51	}
  52
  53	for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) {
  54		iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
  55		if (!iface)
  56			continue;
  57		if (quirk->ifnum != probed_ifnum &&
  58		    !usb_interface_claimed(iface))
  59			usb_driver_claim_interface(driver, iface, (void *)-1L);
 
 
 
 
  60	}
  61
  62	return 0;
  63}
  64
  65static int ignore_interface_quirk(struct snd_usb_audio *chip,
  66				  struct usb_interface *iface,
  67				  struct usb_driver *driver,
  68				  const struct snd_usb_audio_quirk *quirk)
  69{
  70	return 0;
  71}
  72
  73
  74/*
  75 * Allow alignment on audio sub-slot (channel samples) rather than
  76 * on audio slots (audio frames)
  77 */
  78static int create_align_transfer_quirk(struct snd_usb_audio *chip,
  79				       struct usb_interface *iface,
  80				       struct usb_driver *driver,
  81				       const struct snd_usb_audio_quirk *quirk)
  82{
  83	chip->txfr_quirk = 1;
  84	return 1;	/* Continue with creating streams and mixer */
  85}
  86
  87static int create_any_midi_quirk(struct snd_usb_audio *chip,
  88				 struct usb_interface *intf,
  89				 struct usb_driver *driver,
  90				 const struct snd_usb_audio_quirk *quirk)
  91{
  92	return snd_usbmidi_create(chip->card, intf, &chip->midi_list, quirk);
  93}
  94
  95/*
  96 * create a stream for an interface with proper descriptors
  97 */
  98static int create_standard_audio_quirk(struct snd_usb_audio *chip,
  99				       struct usb_interface *iface,
 100				       struct usb_driver *driver,
 101				       const struct snd_usb_audio_quirk *quirk)
 102{
 103	struct usb_host_interface *alts;
 104	struct usb_interface_descriptor *altsd;
 105	int err;
 106
 107	if (chip->usb_id == USB_ID(0x1686, 0x00dd)) /* Zoom R16/24 */
 108		chip->tx_length_quirk = 1;
 109
 110	alts = &iface->altsetting[0];
 111	altsd = get_iface_desc(alts);
 112	err = snd_usb_parse_audio_interface(chip, altsd->bInterfaceNumber);
 113	if (err < 0) {
 114		usb_audio_err(chip, "cannot setup if %d: error %d\n",
 115			   altsd->bInterfaceNumber, err);
 116		return err;
 117	}
 118	/* reset the current interface */
 119	usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0);
 120	return 0;
 121}
 122
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 123/*
 124 * create a stream for an endpoint/altsetting without proper descriptors
 125 */
 126static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
 127				     struct usb_interface *iface,
 128				     struct usb_driver *driver,
 129				     const struct snd_usb_audio_quirk *quirk)
 130{
 131	struct audioformat *fp;
 132	struct usb_host_interface *alts;
 133	struct usb_interface_descriptor *altsd;
 134	int stream, err;
 135	unsigned *rate_table = NULL;
 
 136
 137	fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
 138	if (!fp)
 139		return -ENOMEM;
 140
 141	INIT_LIST_HEAD(&fp->list);
 142	if (fp->nr_rates > MAX_NR_RATES) {
 143		kfree(fp);
 144		return -EINVAL;
 145	}
 146	if (fp->nr_rates > 0) {
 147		rate_table = kmemdup(fp->rate_table,
 148				     sizeof(int) * fp->nr_rates, GFP_KERNEL);
 149		if (!rate_table) {
 150			kfree(fp);
 151			return -ENOMEM;
 152		}
 153		fp->rate_table = rate_table;
 154	}
 155
 156	stream = (fp->endpoint & USB_DIR_IN)
 157		? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
 158	err = snd_usb_add_audio_stream(chip, stream, fp);
 159	if (err < 0)
 160		goto error;
 161	if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||
 162	    fp->altset_idx >= iface->num_altsetting) {
 163		err = -EINVAL;
 164		goto error;
 165	}
 166	alts = &iface->altsetting[fp->altset_idx];
 167	altsd = get_iface_desc(alts);
 168	if (altsd->bNumEndpoints < 1) {
 169		err = -EINVAL;
 170		goto error;
 171	}
 172
 173	fp->protocol = altsd->bInterfaceProtocol;
 174
 175	if (fp->datainterval == 0)
 176		fp->datainterval = snd_usb_parse_datainterval(chip, alts);
 177	if (fp->maxpacksize == 0)
 178		fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
 
 
 
 
 
 
 
 179	usb_set_interface(chip->dev, fp->iface, 0);
 180	snd_usb_init_pitch(chip, fp->iface, alts, fp);
 181	snd_usb_init_sample_rate(chip, fp->iface, alts, fp, fp->rate_max);
 182	return 0;
 183
 184 error:
 185	list_del(&fp->list); /* unlink for avoiding double-free */
 186	kfree(fp);
 187	kfree(rate_table);
 188	return err;
 189}
 190
 191static int create_auto_pcm_quirk(struct snd_usb_audio *chip,
 192				 struct usb_interface *iface,
 193				 struct usb_driver *driver)
 194{
 195	struct usb_host_interface *alts;
 196	struct usb_interface_descriptor *altsd;
 197	struct usb_endpoint_descriptor *epd;
 198	struct uac1_as_header_descriptor *ashd;
 199	struct uac_format_type_i_discrete_descriptor *fmtd;
 200
 201	/*
 202	 * Most Roland/Yamaha audio streaming interfaces have more or less
 203	 * standard descriptors, but older devices might lack descriptors, and
 204	 * future ones might change, so ensure that we fail silently if the
 205	 * interface doesn't look exactly right.
 206	 */
 207
 208	/* must have a non-zero altsetting for streaming */
 209	if (iface->num_altsetting < 2)
 210		return -ENODEV;
 211	alts = &iface->altsetting[1];
 212	altsd = get_iface_desc(alts);
 213
 214	/* must have an isochronous endpoint for streaming */
 215	if (altsd->bNumEndpoints < 1)
 216		return -ENODEV;
 217	epd = get_endpoint(alts, 0);
 218	if (!usb_endpoint_xfer_isoc(epd))
 219		return -ENODEV;
 220
 221	/* must have format descriptors */
 222	ashd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
 223				       UAC_AS_GENERAL);
 224	fmtd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
 225				       UAC_FORMAT_TYPE);
 226	if (!ashd || ashd->bLength < 7 ||
 227	    !fmtd || fmtd->bLength < 8)
 228		return -ENODEV;
 229
 230	return create_standard_audio_quirk(chip, iface, driver, NULL);
 231}
 232
 233static int create_yamaha_midi_quirk(struct snd_usb_audio *chip,
 234				    struct usb_interface *iface,
 235				    struct usb_driver *driver,
 236				    struct usb_host_interface *alts)
 237{
 238	static const struct snd_usb_audio_quirk yamaha_midi_quirk = {
 239		.type = QUIRK_MIDI_YAMAHA
 240	};
 241	struct usb_midi_in_jack_descriptor *injd;
 242	struct usb_midi_out_jack_descriptor *outjd;
 243
 244	/* must have some valid jack descriptors */
 245	injd = snd_usb_find_csint_desc(alts->extra, alts->extralen,
 246				       NULL, USB_MS_MIDI_IN_JACK);
 247	outjd = snd_usb_find_csint_desc(alts->extra, alts->extralen,
 248					NULL, USB_MS_MIDI_OUT_JACK);
 249	if (!injd && !outjd)
 250		return -ENODEV;
 251	if ((injd && !snd_usb_validate_midi_desc(injd)) ||
 252	    (outjd && !snd_usb_validate_midi_desc(outjd)))
 253		return -ENODEV;
 254	if (injd && (injd->bLength < 5 ||
 255		     (injd->bJackType != USB_MS_EMBEDDED &&
 256		      injd->bJackType != USB_MS_EXTERNAL)))
 257		return -ENODEV;
 258	if (outjd && (outjd->bLength < 6 ||
 259		      (outjd->bJackType != USB_MS_EMBEDDED &&
 260		       outjd->bJackType != USB_MS_EXTERNAL)))
 261		return -ENODEV;
 262	return create_any_midi_quirk(chip, iface, driver, &yamaha_midi_quirk);
 263}
 264
 265static int create_roland_midi_quirk(struct snd_usb_audio *chip,
 266				    struct usb_interface *iface,
 267				    struct usb_driver *driver,
 268				    struct usb_host_interface *alts)
 269{
 270	static const struct snd_usb_audio_quirk roland_midi_quirk = {
 271		.type = QUIRK_MIDI_ROLAND
 272	};
 273	u8 *roland_desc = NULL;
 274
 275	/* might have a vendor-specific descriptor <06 24 F1 02 ...> */
 276	for (;;) {
 277		roland_desc = snd_usb_find_csint_desc(alts->extra,
 278						      alts->extralen,
 279						      roland_desc, 0xf1);
 280		if (!roland_desc)
 281			return -ENODEV;
 282		if (roland_desc[0] < 6 || roland_desc[3] != 2)
 283			continue;
 284		return create_any_midi_quirk(chip, iface, driver,
 285					     &roland_midi_quirk);
 286	}
 287}
 288
 289static int create_std_midi_quirk(struct snd_usb_audio *chip,
 290				 struct usb_interface *iface,
 291				 struct usb_driver *driver,
 292				 struct usb_host_interface *alts)
 293{
 294	struct usb_ms_header_descriptor *mshd;
 295	struct usb_ms_endpoint_descriptor *msepd;
 296
 297	/* must have the MIDIStreaming interface header descriptor*/
 298	mshd = (struct usb_ms_header_descriptor *)alts->extra;
 299	if (alts->extralen < 7 ||
 300	    mshd->bLength < 7 ||
 301	    mshd->bDescriptorType != USB_DT_CS_INTERFACE ||
 302	    mshd->bDescriptorSubtype != USB_MS_HEADER)
 303		return -ENODEV;
 304	/* must have the MIDIStreaming endpoint descriptor*/
 305	msepd = (struct usb_ms_endpoint_descriptor *)alts->endpoint[0].extra;
 306	if (alts->endpoint[0].extralen < 4 ||
 307	    msepd->bLength < 4 ||
 308	    msepd->bDescriptorType != USB_DT_CS_ENDPOINT ||
 309	    msepd->bDescriptorSubtype != UAC_MS_GENERAL ||
 310	    msepd->bNumEmbMIDIJack < 1 ||
 311	    msepd->bNumEmbMIDIJack > 16)
 312		return -ENODEV;
 313
 314	return create_any_midi_quirk(chip, iface, driver, NULL);
 315}
 316
 317static int create_auto_midi_quirk(struct snd_usb_audio *chip,
 318				  struct usb_interface *iface,
 319				  struct usb_driver *driver)
 320{
 321	struct usb_host_interface *alts;
 322	struct usb_interface_descriptor *altsd;
 323	struct usb_endpoint_descriptor *epd;
 324	int err;
 325
 326	alts = &iface->altsetting[0];
 327	altsd = get_iface_desc(alts);
 328
 329	/* must have at least one bulk/interrupt endpoint for streaming */
 330	if (altsd->bNumEndpoints < 1)
 331		return -ENODEV;
 332	epd = get_endpoint(alts, 0);
 333	if (!usb_endpoint_xfer_bulk(epd) &&
 334	    !usb_endpoint_xfer_int(epd))
 335		return -ENODEV;
 336
 337	switch (USB_ID_VENDOR(chip->usb_id)) {
 338	case 0x0499: /* Yamaha */
 339		err = create_yamaha_midi_quirk(chip, iface, driver, alts);
 340		if (err != -ENODEV)
 341			return err;
 342		break;
 343	case 0x0582: /* Roland */
 344		err = create_roland_midi_quirk(chip, iface, driver, alts);
 345		if (err != -ENODEV)
 346			return err;
 347		break;
 348	}
 349
 350	return create_std_midi_quirk(chip, iface, driver, alts);
 351}
 352
 353static int create_autodetect_quirk(struct snd_usb_audio *chip,
 354				   struct usb_interface *iface,
 355				   struct usb_driver *driver)
 
 356{
 357	int err;
 358
 359	err = create_auto_pcm_quirk(chip, iface, driver);
 360	if (err == -ENODEV)
 361		err = create_auto_midi_quirk(chip, iface, driver);
 362	return err;
 363}
 364
 365static int create_autodetect_quirks(struct snd_usb_audio *chip,
 366				    struct usb_interface *iface,
 367				    struct usb_driver *driver,
 368				    const struct snd_usb_audio_quirk *quirk)
 369{
 370	int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
 371	int ifcount, ifnum, err;
 372
 373	err = create_autodetect_quirk(chip, iface, driver);
 374	if (err < 0)
 375		return err;
 376
 377	/*
 378	 * ALSA PCM playback/capture devices cannot be registered in two steps,
 379	 * so we have to claim the other corresponding interface here.
 380	 */
 381	ifcount = chip->dev->actconfig->desc.bNumInterfaces;
 382	for (ifnum = 0; ifnum < ifcount; ifnum++) {
 383		if (ifnum == probed_ifnum || quirk->ifnum >= 0)
 384			continue;
 385		iface = usb_ifnum_to_if(chip->dev, ifnum);
 386		if (!iface ||
 387		    usb_interface_claimed(iface) ||
 388		    get_iface_desc(iface->altsetting)->bInterfaceClass !=
 389							USB_CLASS_VENDOR_SPEC)
 390			continue;
 391
 392		err = create_autodetect_quirk(chip, iface, driver);
 393		if (err >= 0)
 394			usb_driver_claim_interface(driver, iface, (void *)-1L);
 395	}
 396
 397	return 0;
 398}
 399
 400/*
 401 * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface.  
 402 * The only way to detect the sample rate is by looking at wMaxPacketSize.
 403 */
 404static int create_uaxx_quirk(struct snd_usb_audio *chip,
 405			     struct usb_interface *iface,
 406			     struct usb_driver *driver,
 407			     const struct snd_usb_audio_quirk *quirk)
 408{
 409	static const struct audioformat ua_format = {
 410		.formats = SNDRV_PCM_FMTBIT_S24_3LE,
 411		.channels = 2,
 412		.fmt_type = UAC_FORMAT_TYPE_I,
 413		.altsetting = 1,
 414		.altset_idx = 1,
 415		.rates = SNDRV_PCM_RATE_CONTINUOUS,
 416	};
 417	struct usb_host_interface *alts;
 418	struct usb_interface_descriptor *altsd;
 419	struct audioformat *fp;
 420	int stream, err;
 421
 422	/* both PCM and MIDI interfaces have 2 or more altsettings */
 423	if (iface->num_altsetting < 2)
 424		return -ENXIO;
 425	alts = &iface->altsetting[1];
 426	altsd = get_iface_desc(alts);
 427
 428	if (altsd->bNumEndpoints == 2) {
 429		static const struct snd_usb_midi_endpoint_info ua700_ep = {
 430			.out_cables = 0x0003,
 431			.in_cables  = 0x0003
 432		};
 433		static const struct snd_usb_audio_quirk ua700_quirk = {
 434			.type = QUIRK_MIDI_FIXED_ENDPOINT,
 435			.data = &ua700_ep
 436		};
 437		static const struct snd_usb_midi_endpoint_info uaxx_ep = {
 438			.out_cables = 0x0001,
 439			.in_cables  = 0x0001
 440		};
 441		static const struct snd_usb_audio_quirk uaxx_quirk = {
 442			.type = QUIRK_MIDI_FIXED_ENDPOINT,
 443			.data = &uaxx_ep
 444		};
 445		const struct snd_usb_audio_quirk *quirk =
 446			chip->usb_id == USB_ID(0x0582, 0x002b)
 447			? &ua700_quirk : &uaxx_quirk;
 448		return __snd_usbmidi_create(chip->card, iface,
 449					  &chip->midi_list, quirk,
 450					  chip->usb_id);
 451	}
 452
 453	if (altsd->bNumEndpoints != 1)
 454		return -ENXIO;
 455
 456	fp = kmemdup(&ua_format, sizeof(*fp), GFP_KERNEL);
 457	if (!fp)
 458		return -ENOMEM;
 459
 460	fp->iface = altsd->bInterfaceNumber;
 461	fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
 462	fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
 463	fp->datainterval = 0;
 464	fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
 465	INIT_LIST_HEAD(&fp->list);
 466
 467	switch (fp->maxpacksize) {
 468	case 0x120:
 469		fp->rate_max = fp->rate_min = 44100;
 470		break;
 471	case 0x138:
 472	case 0x140:
 473		fp->rate_max = fp->rate_min = 48000;
 474		break;
 475	case 0x258:
 476	case 0x260:
 477		fp->rate_max = fp->rate_min = 96000;
 478		break;
 479	default:
 480		usb_audio_err(chip, "unknown sample rate\n");
 481		kfree(fp);
 482		return -ENXIO;
 483	}
 484
 485	stream = (fp->endpoint & USB_DIR_IN)
 486		? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
 487	err = snd_usb_add_audio_stream(chip, stream, fp);
 488	if (err < 0) {
 489		list_del(&fp->list); /* unlink for avoiding double-free */
 490		kfree(fp);
 491		return err;
 492	}
 493	usb_set_interface(chip->dev, fp->iface, 0);
 494	return 0;
 495}
 496
 497/*
 498 * Create a standard mixer for the specified interface.
 499 */
 500static int create_standard_mixer_quirk(struct snd_usb_audio *chip,
 501				       struct usb_interface *iface,
 502				       struct usb_driver *driver,
 503				       const struct snd_usb_audio_quirk *quirk)
 504{
 505	if (quirk->ifnum < 0)
 506		return 0;
 507
 508	return snd_usb_create_mixer(chip, quirk->ifnum, 0);
 509}
 510
 511
 512static int setup_fmt_after_resume_quirk(struct snd_usb_audio *chip,
 513				       struct usb_interface *iface,
 514				       struct usb_driver *driver,
 515				       const struct snd_usb_audio_quirk *quirk)
 516{
 517	chip->setup_fmt_after_resume_quirk = 1;
 518	return 1;	/* Continue with creating streams and mixer */
 519}
 520
 521static int setup_disable_autosuspend(struct snd_usb_audio *chip,
 522				       struct usb_interface *iface,
 523				       struct usb_driver *driver,
 524				       const struct snd_usb_audio_quirk *quirk)
 525{
 526	driver->supports_autosuspend = 0;
 527	return 1;	/* Continue with creating streams and mixer */
 528}
 529
 530/*
 531 * audio-interface quirks
 532 *
 533 * returns zero if no standard audio/MIDI parsing is needed.
 534 * returns a positive value if standard audio/midi interfaces are parsed
 535 * after this.
 536 * returns a negative value at error.
 537 */
 538int snd_usb_create_quirk(struct snd_usb_audio *chip,
 539			 struct usb_interface *iface,
 540			 struct usb_driver *driver,
 541			 const struct snd_usb_audio_quirk *quirk)
 542{
 543	typedef int (*quirk_func_t)(struct snd_usb_audio *,
 544				    struct usb_interface *,
 545				    struct usb_driver *,
 546				    const struct snd_usb_audio_quirk *);
 547	static const quirk_func_t quirk_funcs[] = {
 548		[QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
 549		[QUIRK_COMPOSITE] = create_composite_quirk,
 550		[QUIRK_AUTODETECT] = create_autodetect_quirks,
 551		[QUIRK_MIDI_STANDARD_INTERFACE] = create_any_midi_quirk,
 552		[QUIRK_MIDI_FIXED_ENDPOINT] = create_any_midi_quirk,
 553		[QUIRK_MIDI_YAMAHA] = create_any_midi_quirk,
 554		[QUIRK_MIDI_ROLAND] = create_any_midi_quirk,
 555		[QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk,
 556		[QUIRK_MIDI_NOVATION] = create_any_midi_quirk,
 557		[QUIRK_MIDI_RAW_BYTES] = create_any_midi_quirk,
 558		[QUIRK_MIDI_EMAGIC] = create_any_midi_quirk,
 559		[QUIRK_MIDI_CME] = create_any_midi_quirk,
 560		[QUIRK_MIDI_AKAI] = create_any_midi_quirk,
 561		[QUIRK_MIDI_FTDI] = create_any_midi_quirk,
 562		[QUIRK_MIDI_CH345] = create_any_midi_quirk,
 563		[QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
 564		[QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
 565		[QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk,
 566		[QUIRK_AUDIO_ALIGN_TRANSFER] = create_align_transfer_quirk,
 567		[QUIRK_AUDIO_STANDARD_MIXER] = create_standard_mixer_quirk,
 568		[QUIRK_SETUP_FMT_AFTER_RESUME] = setup_fmt_after_resume_quirk,
 569		[QUIRK_SETUP_DISABLE_AUTOSUSPEND] = setup_disable_autosuspend,
 570	};
 571
 572	if (quirk->type < QUIRK_TYPE_COUNT) {
 573		return quirk_funcs[quirk->type](chip, iface, driver, quirk);
 574	} else {
 575		usb_audio_err(chip, "invalid quirk type %d\n", quirk->type);
 576		return -ENXIO;
 577	}
 578}
 579
 580/*
 581 * boot quirks
 582 */
 583
 584#define EXTIGY_FIRMWARE_SIZE_OLD 794
 585#define EXTIGY_FIRMWARE_SIZE_NEW 483
 586
 587static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)
 588{
 589	struct usb_host_config *config = dev->actconfig;
 590	int err;
 591
 592	if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
 593	    le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
 594		dev_dbg(&dev->dev, "sending Extigy boot sequence...\n");
 595		/* Send message to force it to reconnect with full interface. */
 596		err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
 597				      0x10, 0x43, 0x0001, 0x000a, NULL, 0);
 598		if (err < 0)
 599			dev_dbg(&dev->dev, "error sending boot message: %d\n", err);
 600		err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
 601				&dev->descriptor, sizeof(dev->descriptor));
 602		config = dev->actconfig;
 603		if (err < 0)
 604			dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);
 605		err = usb_reset_configuration(dev);
 606		if (err < 0)
 607			dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);
 608		dev_dbg(&dev->dev, "extigy_boot: new boot length = %d\n",
 609			    le16_to_cpu(get_cfg_desc(config)->wTotalLength));
 610		return -ENODEV; /* quit this anyway */
 611	}
 612	return 0;
 613}
 614
 615static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
 616{
 617	u8 buf = 1;
 618
 619	snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,
 620			USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
 621			0, 0, &buf, 1);
 622	if (buf == 0) {
 623		snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,
 624				USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
 625				1, 2000, NULL, 0);
 626		return -ENODEV;
 627	}
 628	return 0;
 629}
 630
 631static int snd_usb_fasttrackpro_boot_quirk(struct usb_device *dev)
 632{
 633	int err;
 634
 635	if (dev->actconfig->desc.bConfigurationValue == 1) {
 636		dev_info(&dev->dev,
 637			   "Fast Track Pro switching to config #2\n");
 638		/* This function has to be available by the usb core module.
 639		 * if it is not avialable the boot quirk has to be left out
 640		 * and the configuration has to be set by udev or hotplug
 641		 * rules
 642		 */
 643		err = usb_driver_set_configuration(dev, 2);
 644		if (err < 0)
 645			dev_dbg(&dev->dev,
 646				"error usb_driver_set_configuration: %d\n",
 647				err);
 648		/* Always return an error, so that we stop creating a device
 649		   that will just be destroyed and recreated with a new
 650		   configuration */
 651		return -ENODEV;
 652	} else
 653		dev_info(&dev->dev, "Fast Track Pro config OK\n");
 654
 655	return 0;
 656}
 657
 658/*
 659 * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely
 660 * documented in the device's data sheet.
 661 */
 662static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value)
 663{
 664	u8 buf[4];
 665	buf[0] = 0x20;
 666	buf[1] = value & 0xff;
 667	buf[2] = (value >> 8) & 0xff;
 668	buf[3] = reg;
 669	return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION,
 670			       USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
 671			       0, 0, &buf, 4);
 672}
 673
 674static int snd_usb_cm106_boot_quirk(struct usb_device *dev)
 675{
 676	/*
 677	 * Enable line-out driver mode, set headphone source to front
 678	 * channels, enable stereo mic.
 679	 */
 680	return snd_usb_cm106_write_int_reg(dev, 2, 0x8004);
 681}
 682
 683/*
 684 * CM6206 registers from the CM6206 datasheet rev 2.1
 685 */
 686#define CM6206_REG0_DMA_MASTER BIT(15)
 687#define CM6206_REG0_SPDIFO_RATE_48K (2 << 12)
 688#define CM6206_REG0_SPDIFO_RATE_96K (7 << 12)
 689/* Bit 4 thru 11 is the S/PDIF category code */
 690#define CM6206_REG0_SPDIFO_CAT_CODE_GENERAL (0 << 4)
 691#define CM6206_REG0_SPDIFO_EMPHASIS_CD BIT(3)
 692#define CM6206_REG0_SPDIFO_COPYRIGHT_NA BIT(2)
 693#define CM6206_REG0_SPDIFO_NON_AUDIO BIT(1)
 694#define CM6206_REG0_SPDIFO_PRO_FORMAT BIT(0)
 695
 696#define CM6206_REG1_TEST_SEL_CLK BIT(14)
 697#define CM6206_REG1_PLLBIN_EN BIT(13)
 698#define CM6206_REG1_SOFT_MUTE_EN BIT(12)
 699#define CM6206_REG1_GPIO4_OUT BIT(11)
 700#define CM6206_REG1_GPIO4_OE BIT(10)
 701#define CM6206_REG1_GPIO3_OUT BIT(9)
 702#define CM6206_REG1_GPIO3_OE BIT(8)
 703#define CM6206_REG1_GPIO2_OUT BIT(7)
 704#define CM6206_REG1_GPIO2_OE BIT(6)
 705#define CM6206_REG1_GPIO1_OUT BIT(5)
 706#define CM6206_REG1_GPIO1_OE BIT(4)
 707#define CM6206_REG1_SPDIFO_INVALID BIT(3)
 708#define CM6206_REG1_SPDIF_LOOP_EN BIT(2)
 709#define CM6206_REG1_SPDIFO_DIS BIT(1)
 710#define CM6206_REG1_SPDIFI_MIX BIT(0)
 711
 712#define CM6206_REG2_DRIVER_ON BIT(15)
 713#define CM6206_REG2_HEADP_SEL_SIDE_CHANNELS (0 << 13)
 714#define CM6206_REG2_HEADP_SEL_SURROUND_CHANNELS (1 << 13)
 715#define CM6206_REG2_HEADP_SEL_CENTER_SUBW (2 << 13)
 716#define CM6206_REG2_HEADP_SEL_FRONT_CHANNELS (3 << 13)
 717#define CM6206_REG2_MUTE_HEADPHONE_RIGHT BIT(12)
 718#define CM6206_REG2_MUTE_HEADPHONE_LEFT BIT(11)
 719#define CM6206_REG2_MUTE_REAR_SURROUND_RIGHT BIT(10)
 720#define CM6206_REG2_MUTE_REAR_SURROUND_LEFT BIT(9)
 721#define CM6206_REG2_MUTE_SIDE_SURROUND_RIGHT BIT(8)
 722#define CM6206_REG2_MUTE_SIDE_SURROUND_LEFT BIT(7)
 723#define CM6206_REG2_MUTE_SUBWOOFER BIT(6)
 724#define CM6206_REG2_MUTE_CENTER BIT(5)
 725#define CM6206_REG2_MUTE_RIGHT_FRONT BIT(3)
 726#define CM6206_REG2_MUTE_LEFT_FRONT BIT(3)
 727#define CM6206_REG2_EN_BTL BIT(2)
 728#define CM6206_REG2_MCUCLKSEL_1_5_MHZ (0)
 729#define CM6206_REG2_MCUCLKSEL_3_MHZ (1)
 730#define CM6206_REG2_MCUCLKSEL_6_MHZ (2)
 731#define CM6206_REG2_MCUCLKSEL_12_MHZ (3)
 732
 733/* Bit 11..13 sets the sensitivity to FLY tuner volume control VP/VD signal */
 734#define CM6206_REG3_FLYSPEED_DEFAULT (2 << 11)
 735#define CM6206_REG3_VRAP25EN BIT(10)
 736#define CM6206_REG3_MSEL1 BIT(9)
 737#define CM6206_REG3_SPDIFI_RATE_44_1K BIT(0 << 7)
 738#define CM6206_REG3_SPDIFI_RATE_48K BIT(2 << 7)
 739#define CM6206_REG3_SPDIFI_RATE_32K BIT(3 << 7)
 740#define CM6206_REG3_PINSEL BIT(6)
 741#define CM6206_REG3_FOE BIT(5)
 742#define CM6206_REG3_ROE BIT(4)
 743#define CM6206_REG3_CBOE BIT(3)
 744#define CM6206_REG3_LOSE BIT(2)
 745#define CM6206_REG3_HPOE BIT(1)
 746#define CM6206_REG3_SPDIFI_CANREC BIT(0)
 747
 748#define CM6206_REG5_DA_RSTN BIT(13)
 749#define CM6206_REG5_AD_RSTN BIT(12)
 750#define CM6206_REG5_SPDIFO_AD2SPDO BIT(12)
 751#define CM6206_REG5_SPDIFO_SEL_FRONT (0 << 9)
 752#define CM6206_REG5_SPDIFO_SEL_SIDE_SUR (1 << 9)
 753#define CM6206_REG5_SPDIFO_SEL_CEN_LFE (2 << 9)
 754#define CM6206_REG5_SPDIFO_SEL_REAR_SUR (3 << 9)
 755#define CM6206_REG5_CODECM BIT(8)
 756#define CM6206_REG5_EN_HPF BIT(7)
 757#define CM6206_REG5_T_SEL_DSDA4 BIT(6)
 758#define CM6206_REG5_T_SEL_DSDA3 BIT(5)
 759#define CM6206_REG5_T_SEL_DSDA2 BIT(4)
 760#define CM6206_REG5_T_SEL_DSDA1 BIT(3)
 761#define CM6206_REG5_T_SEL_DSDAD_NORMAL 0
 762#define CM6206_REG5_T_SEL_DSDAD_FRONT 4
 763#define CM6206_REG5_T_SEL_DSDAD_S_SURROUND 5
 764#define CM6206_REG5_T_SEL_DSDAD_CEN_LFE 6
 765#define CM6206_REG5_T_SEL_DSDAD_R_SURROUND 7
 766
 767static int snd_usb_cm6206_boot_quirk(struct usb_device *dev)
 768{
 769	int err  = 0, reg;
 770	int val[] = {
 771		/*
 772		 * Values here are chosen based on sniffing USB traffic
 773		 * under Windows.
 774		 *
 775		 * REG0: DAC is master, sample rate 48kHz, no copyright
 776		 */
 777		CM6206_REG0_SPDIFO_RATE_48K |
 778		CM6206_REG0_SPDIFO_COPYRIGHT_NA,
 779		/*
 780		 * REG1: PLL binary search enable, soft mute enable.
 781		 */
 782		CM6206_REG1_PLLBIN_EN |
 783		CM6206_REG1_SOFT_MUTE_EN,
 784		/*
 785		 * REG2: enable output drivers,
 786		 * select front channels to the headphone output,
 787		 * then mute the headphone channels, run the MCU
 788		 * at 1.5 MHz.
 789		 */
 790		CM6206_REG2_DRIVER_ON |
 791		CM6206_REG2_HEADP_SEL_FRONT_CHANNELS |
 792		CM6206_REG2_MUTE_HEADPHONE_RIGHT |
 793		CM6206_REG2_MUTE_HEADPHONE_LEFT,
 794		/*
 795		 * REG3: default flyspeed, set 2.5V mic bias
 796		 * enable all line out ports and enable SPDIF
 797		 */
 798		CM6206_REG3_FLYSPEED_DEFAULT |
 799		CM6206_REG3_VRAP25EN |
 800		CM6206_REG3_FOE |
 801		CM6206_REG3_ROE |
 802		CM6206_REG3_CBOE |
 803		CM6206_REG3_LOSE |
 804		CM6206_REG3_HPOE |
 805		CM6206_REG3_SPDIFI_CANREC,
 806		/* REG4 is just a bunch of GPIO lines */
 807		0x0000,
 808		/* REG5: de-assert AD/DA reset signals */
 809		CM6206_REG5_DA_RSTN |
 810		CM6206_REG5_AD_RSTN };
 811
 812	for (reg = 0; reg < ARRAY_SIZE(val); reg++) {
 813		err = snd_usb_cm106_write_int_reg(dev, reg, val[reg]);
 814		if (err < 0)
 815			return err;
 816	}
 817
 818	return err;
 819}
 820
 821/* quirk for Plantronics GameCom 780 with CM6302 chip */
 822static int snd_usb_gamecon780_boot_quirk(struct usb_device *dev)
 823{
 824	/* set the initial volume and don't change; other values are either
 825	 * too loud or silent due to firmware bug (bko#65251)
 826	 */
 827	u8 buf[2] = { 0x74, 0xe3 };
 828	return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
 829			USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
 830			UAC_FU_VOLUME << 8, 9 << 8, buf, 2);
 831}
 832
 833/*
 834 * Novation Twitch DJ controller
 835 * Focusrite Novation Saffire 6 USB audio card
 836 */
 837static int snd_usb_novation_boot_quirk(struct usb_device *dev)
 838{
 839	/* preemptively set up the device because otherwise the
 840	 * raw MIDI endpoints are not active */
 841	usb_set_interface(dev, 0, 1);
 842	return 0;
 843}
 844
 845/*
 846 * This call will put the synth in "USB send" mode, i.e it will send MIDI
 847 * messages through USB (this is disabled at startup). The synth will
 848 * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB
 849 * sign on its LCD. Values here are chosen based on sniffing USB traffic
 850 * under Windows.
 851 */
 852static int snd_usb_accessmusic_boot_quirk(struct usb_device *dev)
 853{
 854	int err, actual_length;
 855	/* "midi send" enable */
 856	static const u8 seq[] = { 0x4e, 0x73, 0x52, 0x01 };
 857	void *buf;
 858
 859	if (snd_usb_pipe_sanity_check(dev, usb_sndintpipe(dev, 0x05)))
 860		return -EINVAL;
 861	buf = kmemdup(seq, ARRAY_SIZE(seq), GFP_KERNEL);
 862	if (!buf)
 863		return -ENOMEM;
 864	err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x05), buf,
 865			ARRAY_SIZE(seq), &actual_length, 1000);
 866	kfree(buf);
 867	if (err < 0)
 868		return err;
 869
 870	return 0;
 871}
 872
 873/*
 874 * Some sound cards from Native Instruments are in fact compliant to the USB
 875 * audio standard of version 2 and other approved USB standards, even though
 876 * they come up as vendor-specific device when first connected.
 877 *
 878 * However, they can be told to come up with a new set of descriptors
 879 * upon their next enumeration, and the interfaces announced by the new
 880 * descriptors will then be handled by the kernel's class drivers. As the
 881 * product ID will also change, no further checks are required.
 882 */
 883
 884static int snd_usb_nativeinstruments_boot_quirk(struct usb_device *dev)
 885{
 886	int ret;
 887
 888	if (snd_usb_pipe_sanity_check(dev, usb_sndctrlpipe(dev, 0)))
 889		return -EINVAL;
 890	ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 891				  0xaf, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 892				  1, 0, NULL, 0, 1000);
 893
 894	if (ret < 0)
 895		return ret;
 896
 897	usb_reset_device(dev);
 898
 899	/* return -EAGAIN, so the creation of an audio interface for this
 900	 * temporary device is aborted. The device will reconnect with a
 901	 * new product ID */
 902	return -EAGAIN;
 903}
 904
 905static void mbox2_setup_48_24_magic(struct usb_device *dev)
 906{
 907	u8 srate[3];
 908	u8 temp[12];
 909
 910	/* Choose 48000Hz permanently */
 911	srate[0] = 0x80;
 912	srate[1] = 0xbb;
 913	srate[2] = 0x00;
 914
 915	/* Send the magic! */
 916	snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
 917		0x01, 0x22, 0x0100, 0x0085, &temp, 0x0003);
 918	snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
 919		0x81, 0xa2, 0x0100, 0x0085, &srate, 0x0003);
 920	snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
 921		0x81, 0xa2, 0x0100, 0x0086, &srate, 0x0003);
 922	snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
 923		0x81, 0xa2, 0x0100, 0x0003, &srate, 0x0003);
 924	return;
 925}
 926
 927/* Digidesign Mbox 2 needs to load firmware onboard
 928 * and driver must wait a few seconds for initialisation.
 929 */
 930
 931#define MBOX2_FIRMWARE_SIZE    646
 932#define MBOX2_BOOT_LOADING     0x01 /* Hard coded into the device */
 933#define MBOX2_BOOT_READY       0x02 /* Hard coded into the device */
 934
 935static int snd_usb_mbox2_boot_quirk(struct usb_device *dev)
 936{
 937	struct usb_host_config *config = dev->actconfig;
 938	int err;
 939	u8 bootresponse[0x12];
 940	int fwsize;
 941	int count;
 942
 943	fwsize = le16_to_cpu(get_cfg_desc(config)->wTotalLength);
 944
 945	if (fwsize != MBOX2_FIRMWARE_SIZE) {
 946		dev_err(&dev->dev, "Invalid firmware size=%d.\n", fwsize);
 947		return -ENODEV;
 948	}
 949
 950	dev_dbg(&dev->dev, "Sending Digidesign Mbox 2 boot sequence...\n");
 951
 952	count = 0;
 953	bootresponse[0] = MBOX2_BOOT_LOADING;
 954	while ((bootresponse[0] == MBOX2_BOOT_LOADING) && (count < 10)) {
 955		msleep(500); /* 0.5 second delay */
 956		snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
 957			/* Control magic - load onboard firmware */
 958			0x85, 0xc0, 0x0001, 0x0000, &bootresponse, 0x0012);
 959		if (bootresponse[0] == MBOX2_BOOT_READY)
 960			break;
 961		dev_dbg(&dev->dev, "device not ready, resending boot sequence...\n");
 962		count++;
 963	}
 964
 965	if (bootresponse[0] != MBOX2_BOOT_READY) {
 966		dev_err(&dev->dev, "Unknown bootresponse=%d, or timed out, ignoring device.\n", bootresponse[0]);
 967		return -ENODEV;
 968	}
 969
 970	dev_dbg(&dev->dev, "device initialised!\n");
 971
 972	err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
 973		&dev->descriptor, sizeof(dev->descriptor));
 974	config = dev->actconfig;
 975	if (err < 0)
 976		dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);
 977
 978	err = usb_reset_configuration(dev);
 979	if (err < 0)
 980		dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);
 981	dev_dbg(&dev->dev, "mbox2_boot: new boot length = %d\n",
 982		le16_to_cpu(get_cfg_desc(config)->wTotalLength));
 983
 984	mbox2_setup_48_24_magic(dev);
 985
 986	dev_info(&dev->dev, "Digidesign Mbox 2: 24bit 48kHz");
 987
 988	return 0; /* Successful boot */
 989}
 990
 991static int snd_usb_axefx3_boot_quirk(struct usb_device *dev)
 992{
 993	int err;
 994
 995	dev_dbg(&dev->dev, "Waiting for Axe-Fx III to boot up...\n");
 996
 997	if (snd_usb_pipe_sanity_check(dev, usb_sndctrlpipe(dev, 0)))
 998		return -EINVAL;
 999	/* If the Axe-Fx III has not fully booted, it will timeout when trying
1000	 * to enable the audio streaming interface. A more generous timeout is
1001	 * used here to detect when the Axe-Fx III has finished booting as the
1002	 * set interface message will be acked once it has
1003	 */
1004	err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1005				USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
1006				1, 1, NULL, 0, 120000);
1007	if (err < 0) {
1008		dev_err(&dev->dev,
1009			"failed waiting for Axe-Fx III to boot: %d\n", err);
1010		return err;
1011	}
1012
1013	dev_dbg(&dev->dev, "Axe-Fx III is now ready\n");
1014
1015	err = usb_set_interface(dev, 1, 0);
1016	if (err < 0)
1017		dev_dbg(&dev->dev,
1018			"error stopping Axe-Fx III interface: %d\n", err);
1019
1020	return 0;
1021}
1022
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1023
1024#define MICROBOOK_BUF_SIZE 128
1025
1026static int snd_usb_motu_microbookii_communicate(struct usb_device *dev, u8 *buf,
1027						int buf_size, int *length)
1028{
1029	int err, actual_length;
1030
1031	if (snd_usb_pipe_sanity_check(dev, usb_sndintpipe(dev, 0x01)))
1032		return -EINVAL;
1033	err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x01), buf, *length,
1034				&actual_length, 1000);
1035	if (err < 0)
1036		return err;
1037
1038	print_hex_dump(KERN_DEBUG, "MicroBookII snd: ", DUMP_PREFIX_NONE, 16, 1,
1039		       buf, actual_length, false);
1040
1041	memset(buf, 0, buf_size);
1042
1043	if (snd_usb_pipe_sanity_check(dev, usb_rcvintpipe(dev, 0x82)))
1044		return -EINVAL;
1045	err = usb_interrupt_msg(dev, usb_rcvintpipe(dev, 0x82), buf, buf_size,
1046				&actual_length, 1000);
1047	if (err < 0)
1048		return err;
1049
1050	print_hex_dump(KERN_DEBUG, "MicroBookII rcv: ", DUMP_PREFIX_NONE, 16, 1,
1051		       buf, actual_length, false);
1052
1053	*length = actual_length;
1054	return 0;
1055}
1056
1057static int snd_usb_motu_microbookii_boot_quirk(struct usb_device *dev)
1058{
1059	int err, actual_length, poll_attempts = 0;
1060	static const u8 set_samplerate_seq[] = { 0x00, 0x00, 0x00, 0x00,
1061						 0x00, 0x00, 0x0b, 0x14,
1062						 0x00, 0x00, 0x00, 0x01 };
1063	static const u8 poll_ready_seq[] = { 0x00, 0x04, 0x00, 0x00,
1064					     0x00, 0x00, 0x0b, 0x18 };
1065	u8 *buf = kzalloc(MICROBOOK_BUF_SIZE, GFP_KERNEL);
1066
1067	if (!buf)
1068		return -ENOMEM;
1069
1070	dev_info(&dev->dev, "Waiting for MOTU Microbook II to boot up...\n");
1071
1072	/* First we tell the device which sample rate to use. */
1073	memcpy(buf, set_samplerate_seq, sizeof(set_samplerate_seq));
1074	actual_length = sizeof(set_samplerate_seq);
1075	err = snd_usb_motu_microbookii_communicate(dev, buf, MICROBOOK_BUF_SIZE,
1076						   &actual_length);
1077
1078	if (err < 0) {
1079		dev_err(&dev->dev,
1080			"failed setting the sample rate for Motu MicroBook II: %d\n",
1081			err);
1082		goto free_buf;
1083	}
1084
1085	/* Then we poll every 100 ms until the device informs of its readiness. */
1086	while (true) {
1087		if (++poll_attempts > 100) {
1088			dev_err(&dev->dev,
1089				"failed booting Motu MicroBook II: timeout\n");
1090			err = -ENODEV;
1091			goto free_buf;
1092		}
1093
1094		memset(buf, 0, MICROBOOK_BUF_SIZE);
1095		memcpy(buf, poll_ready_seq, sizeof(poll_ready_seq));
1096
1097		actual_length = sizeof(poll_ready_seq);
1098		err = snd_usb_motu_microbookii_communicate(
1099			dev, buf, MICROBOOK_BUF_SIZE, &actual_length);
1100		if (err < 0) {
1101			dev_err(&dev->dev,
1102				"failed booting Motu MicroBook II: communication error %d\n",
1103				err);
1104			goto free_buf;
1105		}
1106
1107		/* the device signals its readiness through a message of the
1108		 * form
1109		 *           XX 06 00 00 00 00 0b 18  00 00 00 01
1110		 * If the device is not yet ready to accept audio data, the
1111		 * last byte of that sequence is 00.
1112		 */
1113		if (actual_length == 12 && buf[actual_length - 1] == 1)
1114			break;
1115
1116		msleep(100);
1117	}
1118
1119	dev_info(&dev->dev, "MOTU MicroBook II ready\n");
1120
1121free_buf:
1122	kfree(buf);
1123	return err;
1124}
1125
1126static int snd_usb_motu_m_series_boot_quirk(struct usb_device *dev)
1127{
1128	int ret;
1129
1130	if (snd_usb_pipe_sanity_check(dev, usb_sndctrlpipe(dev, 0)))
1131		return -EINVAL;
1132	ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1133			      1, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1134			      0x0, 0, NULL, 0, 1000);
1135
1136	if (ret < 0)
1137		return ret;
1138
1139	msleep(2000);
1140
1141	ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1142			      1, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1143			      0x20, 0, NULL, 0, 1000);
1144
1145	if (ret < 0)
1146		return ret;
1147
1148	return 0;
1149}
1150
1151/*
1152 * Setup quirks
1153 */
1154#define MAUDIO_SET		0x01 /* parse device_setup */
1155#define MAUDIO_SET_COMPATIBLE	0x80 /* use only "win-compatible" interfaces */
1156#define MAUDIO_SET_DTS		0x02 /* enable DTS Digital Output */
1157#define MAUDIO_SET_96K		0x04 /* 48-96kHz rate if set, 8-48kHz otherwise */
1158#define MAUDIO_SET_24B		0x08 /* 24bits sample if set, 16bits otherwise */
1159#define MAUDIO_SET_DI		0x10 /* enable Digital Input */
1160#define MAUDIO_SET_MASK		0x1f /* bit mask for setup value */
1161#define MAUDIO_SET_24B_48K_DI	 0x19 /* 24bits+48kHz+Digital Input */
1162#define MAUDIO_SET_24B_48K_NOTDI 0x09 /* 24bits+48kHz+No Digital Input */
1163#define MAUDIO_SET_16B_48K_DI	 0x11 /* 16bits+48kHz+Digital Input */
1164#define MAUDIO_SET_16B_48K_NOTDI 0x01 /* 16bits+48kHz+No Digital Input */
1165
1166static int quattro_skip_setting_quirk(struct snd_usb_audio *chip,
1167				      int iface, int altno)
1168{
1169	/* Reset ALL ifaces to 0 altsetting.
1170	 * Call it for every possible altsetting of every interface.
1171	 */
1172	usb_set_interface(chip->dev, iface, 0);
1173	if (chip->setup & MAUDIO_SET) {
1174		if (chip->setup & MAUDIO_SET_COMPATIBLE) {
1175			if (iface != 1 && iface != 2)
1176				return 1; /* skip all interfaces but 1 and 2 */
1177		} else {
1178			unsigned int mask;
1179			if (iface == 1 || iface == 2)
1180				return 1; /* skip interfaces 1 and 2 */
1181			if ((chip->setup & MAUDIO_SET_96K) && altno != 1)
1182				return 1; /* skip this altsetting */
1183			mask = chip->setup & MAUDIO_SET_MASK;
1184			if (mask == MAUDIO_SET_24B_48K_DI && altno != 2)
1185				return 1; /* skip this altsetting */
1186			if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3)
1187				return 1; /* skip this altsetting */
1188			if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 4)
1189				return 1; /* skip this altsetting */
1190		}
1191	}
1192	usb_audio_dbg(chip,
1193		    "using altsetting %d for interface %d config %d\n",
1194		    altno, iface, chip->setup);
1195	return 0; /* keep this altsetting */
1196}
1197
1198static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
1199					 int iface,
1200					 int altno)
1201{
1202	/* Reset ALL ifaces to 0 altsetting.
1203	 * Call it for every possible altsetting of every interface.
1204	 */
1205	usb_set_interface(chip->dev, iface, 0);
1206
1207	if (chip->setup & MAUDIO_SET) {
1208		unsigned int mask;
1209		if ((chip->setup & MAUDIO_SET_DTS) && altno != 6)
1210			return 1; /* skip this altsetting */
1211		if ((chip->setup & MAUDIO_SET_96K) && altno != 1)
1212			return 1; /* skip this altsetting */
1213		mask = chip->setup & MAUDIO_SET_MASK;
1214		if (mask == MAUDIO_SET_24B_48K_DI && altno != 2)
1215			return 1; /* skip this altsetting */
1216		if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3)
1217			return 1; /* skip this altsetting */
1218		if (mask == MAUDIO_SET_16B_48K_DI && altno != 4)
1219			return 1; /* skip this altsetting */
1220		if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 5)
1221			return 1; /* skip this altsetting */
1222	}
1223
1224	return 0; /* keep this altsetting */
1225}
1226
1227static int fasttrackpro_skip_setting_quirk(struct snd_usb_audio *chip,
1228					   int iface, int altno)
1229{
1230	/* Reset ALL ifaces to 0 altsetting.
1231	 * Call it for every possible altsetting of every interface.
1232	 */
1233	usb_set_interface(chip->dev, iface, 0);
1234
1235	/* possible configuration where both inputs and only one output is
1236	 *used is not supported by the current setup
1237	 */
1238	if (chip->setup & (MAUDIO_SET | MAUDIO_SET_24B)) {
1239		if (chip->setup & MAUDIO_SET_96K) {
1240			if (altno != 3 && altno != 6)
1241				return 1;
1242		} else if (chip->setup & MAUDIO_SET_DI) {
1243			if (iface == 4)
1244				return 1; /* no analog input */
1245			if (altno != 2 && altno != 5)
1246				return 1; /* enable only altsets 2 and 5 */
1247		} else {
1248			if (iface == 5)
1249				return 1; /* disable digialt input */
1250			if (altno != 2 && altno != 5)
1251				return 1; /* enalbe only altsets 2 and 5 */
1252		}
1253	} else {
1254		/* keep only 16-Bit mode */
1255		if (altno != 1)
1256			return 1;
1257	}
1258
1259	usb_audio_dbg(chip,
1260		    "using altsetting %d for interface %d config %d\n",
1261		    altno, iface, chip->setup);
1262	return 0; /* keep this altsetting */
1263}
1264
1265static int s1810c_skip_setting_quirk(struct snd_usb_audio *chip,
1266					   int iface, int altno)
1267{
1268	/*
1269	 * Altno settings:
1270	 *
1271	 * Playback (Interface 1):
1272	 * 1: 6 Analog + 2 S/PDIF
1273	 * 2: 6 Analog + 2 S/PDIF
1274	 * 3: 6 Analog
1275	 *
1276	 * Capture (Interface 2):
1277	 * 1: 8 Analog + 2 S/PDIF + 8 ADAT
1278	 * 2: 8 Analog + 2 S/PDIF + 4 ADAT
1279	 * 3: 8 Analog
1280	 */
1281
1282	/*
1283	 * I'll leave 2 as the default one and
1284	 * use device_setup to switch to the
1285	 * other two.
1286	 */
1287	if ((chip->setup == 0 || chip->setup > 2) && altno != 2)
1288		return 1;
1289	else if (chip->setup == 1 && altno != 1)
1290		return 1;
1291	else if (chip->setup == 2 && altno != 3)
1292		return 1;
1293
1294	return 0;
1295}
1296
1297int snd_usb_apply_interface_quirk(struct snd_usb_audio *chip,
1298				  int iface,
1299				  int altno)
1300{
1301	/* audiophile usb: skip altsets incompatible with device_setup */
1302	if (chip->usb_id == USB_ID(0x0763, 0x2003))
1303		return audiophile_skip_setting_quirk(chip, iface, altno);
1304	/* quattro usb: skip altsets incompatible with device_setup */
1305	if (chip->usb_id == USB_ID(0x0763, 0x2001))
1306		return quattro_skip_setting_quirk(chip, iface, altno);
1307	/* fasttrackpro usb: skip altsets incompatible with device_setup */
1308	if (chip->usb_id == USB_ID(0x0763, 0x2012))
1309		return fasttrackpro_skip_setting_quirk(chip, iface, altno);
1310	/* presonus studio 1810c: skip altsets incompatible with device_setup */
1311	if (chip->usb_id == USB_ID(0x0194f, 0x010c))
1312		return s1810c_skip_setting_quirk(chip, iface, altno);
1313
1314
1315	return 0;
1316}
1317
1318int snd_usb_apply_boot_quirk(struct usb_device *dev,
1319			     struct usb_interface *intf,
1320			     const struct snd_usb_audio_quirk *quirk,
1321			     unsigned int id)
1322{
1323	switch (id) {
1324	case USB_ID(0x041e, 0x3000):
1325		/* SB Extigy needs special boot-up sequence */
1326		/* if more models come, this will go to the quirk list. */
1327		return snd_usb_extigy_boot_quirk(dev, intf);
1328
1329	case USB_ID(0x041e, 0x3020):
1330		/* SB Audigy 2 NX needs its own boot-up magic, too */
1331		return snd_usb_audigy2nx_boot_quirk(dev);
1332
1333	case USB_ID(0x10f5, 0x0200):
1334		/* C-Media CM106 / Turtle Beach Audio Advantage Roadie */
1335		return snd_usb_cm106_boot_quirk(dev);
1336
1337	case USB_ID(0x0d8c, 0x0102):
1338		/* C-Media CM6206 / CM106-Like Sound Device */
1339	case USB_ID(0x0ccd, 0x00b1): /* Terratec Aureon 7.1 USB */
1340		return snd_usb_cm6206_boot_quirk(dev);
1341
1342	case USB_ID(0x0dba, 0x3000):
1343		/* Digidesign Mbox 2 */
1344		return snd_usb_mbox2_boot_quirk(dev);
 
 
 
 
1345
1346	case USB_ID(0x1235, 0x0010): /* Focusrite Novation Saffire 6 USB */
1347	case USB_ID(0x1235, 0x0018): /* Focusrite Novation Twitch */
1348		return snd_usb_novation_boot_quirk(dev);
1349
1350	case USB_ID(0x133e, 0x0815):
1351		/* Access Music VirusTI Desktop */
1352		return snd_usb_accessmusic_boot_quirk(dev);
1353
1354	case USB_ID(0x17cc, 0x1000): /* Komplete Audio 6 */
1355	case USB_ID(0x17cc, 0x1010): /* Traktor Audio 6 */
1356	case USB_ID(0x17cc, 0x1020): /* Traktor Audio 10 */
1357		return snd_usb_nativeinstruments_boot_quirk(dev);
1358	case USB_ID(0x0763, 0x2012):  /* M-Audio Fast Track Pro USB */
1359		return snd_usb_fasttrackpro_boot_quirk(dev);
1360	case USB_ID(0x047f, 0xc010): /* Plantronics Gamecom 780 */
1361		return snd_usb_gamecon780_boot_quirk(dev);
1362	case USB_ID(0x2466, 0x8010): /* Fractal Audio Axe-Fx 3 */
1363		return snd_usb_axefx3_boot_quirk(dev);
1364	case USB_ID(0x07fd, 0x0004): /* MOTU MicroBook II */
1365		/*
1366		 * For some reason interface 3 with vendor-spec class is
1367		 * detected on MicroBook IIc.
1368		 */
1369		if (get_iface_desc(intf->altsetting)->bInterfaceClass ==
1370		    USB_CLASS_VENDOR_SPEC &&
1371		    get_iface_desc(intf->altsetting)->bInterfaceNumber < 3)
1372			return snd_usb_motu_microbookii_boot_quirk(dev);
1373		break;
1374	}
1375
1376	return 0;
1377}
1378
1379int snd_usb_apply_boot_quirk_once(struct usb_device *dev,
1380				  struct usb_interface *intf,
1381				  const struct snd_usb_audio_quirk *quirk,
1382				  unsigned int id)
1383{
1384	switch (id) {
1385	case USB_ID(0x07fd, 0x0008): /* MOTU M Series */
1386		return snd_usb_motu_m_series_boot_quirk(dev);
1387	}
1388
1389	return 0;
1390}
1391
1392/*
1393 * check if the device uses big-endian samples
1394 */
1395int snd_usb_is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *fp)
 
1396{
1397	/* it depends on altsetting whether the device is big-endian or not */
1398	switch (chip->usb_id) {
1399	case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
1400		if (fp->altsetting == 2 || fp->altsetting == 3 ||
1401			fp->altsetting == 5 || fp->altsetting == 6)
1402			return 1;
1403		break;
1404	case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
1405		if (chip->setup == 0x00 ||
1406			fp->altsetting == 1 || fp->altsetting == 2 ||
1407			fp->altsetting == 3)
1408			return 1;
1409		break;
1410	case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro */
1411		if (fp->altsetting == 2 || fp->altsetting == 3 ||
1412			fp->altsetting == 5 || fp->altsetting == 6)
1413			return 1;
1414		break;
1415	}
1416	return 0;
1417}
1418
1419/*
1420 * For E-Mu 0404USB/0202USB/TrackerPre/0204 sample rate should be set for device,
1421 * not for interface.
1422 */
1423
1424enum {
1425	EMU_QUIRK_SR_44100HZ = 0,
1426	EMU_QUIRK_SR_48000HZ,
1427	EMU_QUIRK_SR_88200HZ,
1428	EMU_QUIRK_SR_96000HZ,
1429	EMU_QUIRK_SR_176400HZ,
1430	EMU_QUIRK_SR_192000HZ
1431};
1432
1433static void set_format_emu_quirk(struct snd_usb_substream *subs,
1434				 struct audioformat *fmt)
1435{
1436	unsigned char emu_samplerate_id = 0;
1437
1438	/* When capture is active
1439	 * sample rate shouldn't be changed
1440	 * by playback substream
1441	 */
1442	if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
1443		if (subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE].interface != -1)
1444			return;
1445	}
1446
1447	switch (fmt->rate_min) {
1448	case 48000:
1449		emu_samplerate_id = EMU_QUIRK_SR_48000HZ;
1450		break;
1451	case 88200:
1452		emu_samplerate_id = EMU_QUIRK_SR_88200HZ;
1453		break;
1454	case 96000:
1455		emu_samplerate_id = EMU_QUIRK_SR_96000HZ;
1456		break;
1457	case 176400:
1458		emu_samplerate_id = EMU_QUIRK_SR_176400HZ;
1459		break;
1460	case 192000:
1461		emu_samplerate_id = EMU_QUIRK_SR_192000HZ;
1462		break;
1463	default:
1464		emu_samplerate_id = EMU_QUIRK_SR_44100HZ;
1465		break;
1466	}
1467	snd_emuusb_set_samplerate(subs->stream->chip, emu_samplerate_id);
1468	subs->pkt_offset_adj = (emu_samplerate_id >= EMU_QUIRK_SR_176400HZ) ? 4 : 0;
1469}
1470
1471
1472/*
1473 * Pioneer DJ DJM-900NXS2
1474 * Device needs to know the sample rate each time substream is started
1475 */
1476static int pioneer_djm_set_format_quirk(struct snd_usb_substream *subs)
1477{
1478
1479	/* Convert sample rate value to little endian */
1480	u8 sr[3];
1481
1482	sr[0] = subs->cur_rate & 0xff;
1483	sr[1] = (subs->cur_rate >> 8) & 0xff;
1484	sr[2] = (subs->cur_rate >> 16) & 0xff;
1485
1486	/* Configure device */
1487	usb_set_interface(subs->dev, 0, 1);
 
1488	snd_usb_ctl_msg(subs->stream->chip->dev,
1489		usb_rcvctrlpipe(subs->stream->chip->dev, 0),
1490		0x01, 0x22, 0x0100, 0x0082, &sr, 0x0003);
1491
1492	return 0;
1493}
1494
1495void snd_usb_set_format_quirk(struct snd_usb_substream *subs,
1496			      struct audioformat *fmt)
1497{
1498	switch (subs->stream->chip->usb_id) {
1499	case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
1500	case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
1501	case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
1502	case USB_ID(0x041e, 0x3f19): /* E-Mu 0204 USB */
1503		set_format_emu_quirk(subs, fmt);
1504		break;
1505	case USB_ID(0x2b73, 0x000a): /* Pioneer DJ DJM-900NXS2 */
1506	case USB_ID(0x2b73, 0x0017): /* Pioneer DJ DJM-250MK2 */
1507		pioneer_djm_set_format_quirk(subs);
1508		break;
1509	case USB_ID(0x534d, 0x2109): /* MacroSilicon MS2109 */
1510		subs->stream_offset_adj = 2;
1511		break;
 
 
 
 
 
 
 
1512	}
1513}
1514
1515bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip)
1516{
1517	/* devices which do not support reading the sample rate. */
1518	switch (chip->usb_id) {
1519	case USB_ID(0x041e, 0x4080): /* Creative Live Cam VF0610 */
1520	case USB_ID(0x04d8, 0xfeea): /* Benchmark DAC1 Pre */
1521	case USB_ID(0x0556, 0x0014): /* Phoenix Audio TMX320VC */
1522	case USB_ID(0x05a3, 0x9420): /* ELP HD USB Camera */
1523	case USB_ID(0x05a7, 0x1020): /* Bose Companion 5 */
1524	case USB_ID(0x074d, 0x3553): /* Outlaw RR2150 (Micronas UAC3553B) */
1525	case USB_ID(0x1395, 0x740a): /* Sennheiser DECT */
1526	case USB_ID(0x1901, 0x0191): /* GE B850V3 CP2114 audio interface */
1527	case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */
1528	case USB_ID(0x2912, 0x30c8): /* Audioengine D1 */
1529		return true;
1530	}
1531
1532	/* devices of these vendors don't support reading rate, either */
1533	switch (USB_ID_VENDOR(chip->usb_id)) {
1534	case 0x045e: /* MS Lifecam */
1535	case 0x047f: /* Plantronics */
1536	case 0x1de7: /* Phoenix Audio */
1537		return true;
1538	}
1539
1540	return false;
1541}
1542
1543/* ITF-USB DSD based DACs need a vendor cmd to switch
1544 * between PCM and native DSD mode
1545 */
1546static bool is_itf_usb_dsd_dac(unsigned int id)
1547{
1548	switch (id) {
1549	case USB_ID(0x154e, 0x1002): /* Denon DCD-1500RE */
1550	case USB_ID(0x154e, 0x1003): /* Denon DA-300USB */
1551	case USB_ID(0x154e, 0x3005): /* Marantz HD-DAC1 */
1552	case USB_ID(0x154e, 0x3006): /* Marantz SA-14S1 */
1553	case USB_ID(0x1852, 0x5065): /* Luxman DA-06 */
1554	case USB_ID(0x0644, 0x8043): /* TEAC UD-501/UD-501V2/UD-503/NT-503 */
1555	case USB_ID(0x0644, 0x8044): /* Esoteric D-05X */
1556	case USB_ID(0x0644, 0x804a): /* TEAC UD-301 */
1557		return true;
1558	}
1559	return false;
1560}
1561
1562int snd_usb_select_mode_quirk(struct snd_usb_substream *subs,
1563			      struct audioformat *fmt)
1564{
1565	struct usb_device *dev = subs->dev;
1566	int err;
1567
1568	if (is_itf_usb_dsd_dac(subs->stream->chip->usb_id)) {
1569		/* First switch to alt set 0, otherwise the mode switch cmd
1570		 * will not be accepted by the DAC
1571		 */
1572		err = usb_set_interface(dev, fmt->iface, 0);
1573		if (err < 0)
1574			return err;
1575
1576		msleep(20); /* Delay needed after setting the interface */
1577
1578		/* Vendor mode switch cmd is required. */
1579		if (fmt->formats & SNDRV_PCM_FMTBIT_DSD_U32_BE) {
1580			/* DSD mode (DSD_U32) requested */
1581			err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,
1582					      USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
1583					      1, 1, NULL, 0);
1584			if (err < 0)
1585				return err;
1586
1587		} else {
1588			/* PCM or DOP mode (S32) requested */
1589			/* PCM mode (S16) requested */
1590			err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,
1591					      USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
1592					      0, 1, NULL, 0);
1593			if (err < 0)
1594				return err;
1595
1596		}
1597		msleep(20);
1598	}
1599	return 0;
1600}
1601
1602void snd_usb_endpoint_start_quirk(struct snd_usb_endpoint *ep)
1603{
1604	/*
1605	 * "Playback Design" products send bogus feedback data at the start
1606	 * of the stream. Ignore them.
1607	 */
1608	if (USB_ID_VENDOR(ep->chip->usb_id) == 0x23ba &&
1609	    ep->type == SND_USB_ENDPOINT_TYPE_SYNC)
1610		ep->skip_packets = 4;
1611
1612	/*
1613	 * M-Audio Fast Track C400/C600 - when packets are not skipped, real
1614	 * world latency varies by approx. +/- 50 frames (at 96kHz) each time
1615	 * the stream is (re)started. When skipping packets 16 at endpoint
1616	 * start up, the real world latency is stable within +/- 1 frame (also
1617	 * across power cycles).
1618	 */
1619	if ((ep->chip->usb_id == USB_ID(0x0763, 0x2030) ||
1620	     ep->chip->usb_id == USB_ID(0x0763, 0x2031)) &&
1621	    ep->type == SND_USB_ENDPOINT_TYPE_DATA)
1622		ep->skip_packets = 16;
1623
1624	/* Work around devices that report unreasonable feedback data */
1625	if ((ep->chip->usb_id == USB_ID(0x0644, 0x8038) ||  /* TEAC UD-H01 */
1626	     ep->chip->usb_id == USB_ID(0x1852, 0x5034)) && /* T+A Dac8 */
1627	    ep->syncmaxsize == 4)
1628		ep->tenor_fb_quirk = 1;
1629}
1630
1631void snd_usb_set_interface_quirk(struct usb_device *dev)
1632{
1633	struct snd_usb_audio *chip = dev_get_drvdata(&dev->dev);
1634
1635	if (!chip)
1636		return;
1637	/*
1638	 * "Playback Design" products need a 50ms delay after setting the
1639	 * USB interface.
1640	 */
1641	switch (USB_ID_VENDOR(chip->usb_id)) {
1642	case 0x23ba: /* Playback Design */
1643	case 0x0644: /* TEAC Corp. */
1644		msleep(50);
1645		break;
1646	}
1647}
1648
1649/* quirk applied after snd_usb_ctl_msg(); not applied during boot quirks */
1650void snd_usb_ctl_msg_quirk(struct usb_device *dev, unsigned int pipe,
1651			   __u8 request, __u8 requesttype, __u16 value,
1652			   __u16 index, void *data, __u16 size)
1653{
1654	struct snd_usb_audio *chip = dev_get_drvdata(&dev->dev);
1655
1656	if (!chip)
1657		return;
1658	/*
1659	 * "Playback Design" products need a 20ms delay after each
1660	 * class compliant request
1661	 */
1662	if (USB_ID_VENDOR(chip->usb_id) == 0x23ba &&
1663	    (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1664		msleep(20);
1665
1666	/*
1667	 * "TEAC Corp." products need a 20ms delay after each
1668	 * class compliant request
1669	 */
1670	if (USB_ID_VENDOR(chip->usb_id) == 0x0644 &&
1671	    (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1672		msleep(20);
1673
1674	/* ITF-USB DSD based DACs functionality need a delay
1675	 * after each class compliant request
1676	 */
1677	if (is_itf_usb_dsd_dac(chip->usb_id)
1678	    && (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1679		msleep(20);
1680
1681	/* Zoom R16/24, Logitech H650e/H570e, Jabra 550a, Kingston HyperX
1682	 *  needs a tiny delay here, otherwise requests like get/set
1683	 *  frequency return as failed despite actually succeeding.
1684	 */
1685	if ((chip->usb_id == USB_ID(0x1686, 0x00dd) ||
1686	     chip->usb_id == USB_ID(0x046d, 0x0a46) ||
1687	     chip->usb_id == USB_ID(0x046d, 0x0a56) ||
1688	     chip->usb_id == USB_ID(0x0b0e, 0x0349) ||
1689	     chip->usb_id == USB_ID(0x0951, 0x16ad)) &&
1690	    (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1691		usleep_range(1000, 2000);
1692
1693	/*
1694	 * Samsung USBC Headset (AKG) need a tiny delay after each
1695	 * class compliant request. (Model number: AAM625R or AAM627R)
1696	 */
1697	if (chip->usb_id == USB_ID(0x04e8, 0xa051) &&
1698	    (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1699		usleep_range(5000, 6000);
1700}
1701
1702/*
1703 * snd_usb_interface_dsd_format_quirks() is called from format.c to
1704 * augment the PCM format bit-field for DSD types. The UAC standards
1705 * don't have a designated bit field to denote DSD-capable interfaces,
1706 * hence all hardware that is known to support this format has to be
1707 * listed here.
1708 */
1709u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip,
1710					struct audioformat *fp,
1711					unsigned int sample_bytes)
1712{
1713	struct usb_interface *iface;
1714
1715	/* Playback Designs */
1716	if (USB_ID_VENDOR(chip->usb_id) == 0x23ba &&
1717	    USB_ID_PRODUCT(chip->usb_id) < 0x0110) {
1718		switch (fp->altsetting) {
1719		case 1:
1720			fp->dsd_dop = true;
1721			return SNDRV_PCM_FMTBIT_DSD_U16_LE;
1722		case 2:
1723			fp->dsd_bitrev = true;
1724			return SNDRV_PCM_FMTBIT_DSD_U8;
1725		case 3:
1726			fp->dsd_bitrev = true;
1727			return SNDRV_PCM_FMTBIT_DSD_U16_LE;
1728		}
1729	}
1730
1731	/* XMOS based USB DACs */
1732	switch (chip->usb_id) {
1733	case USB_ID(0x1511, 0x0037): /* AURALiC VEGA */
 
1734	case USB_ID(0x2522, 0x0012): /* LH Labs VI DAC Infinity */
1735	case USB_ID(0x2772, 0x0230): /* Pro-Ject Pre Box S2 Digital */
1736		if (fp->altsetting == 2)
1737			return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1738		break;
1739
1740	case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */
1741	case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */
1742	case USB_ID(0x16d0, 0x06b2): /* NuPrime DAC-10 */
1743	case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */
1744	case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */
1745	case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */
1746	case USB_ID(0x1db5, 0x0003): /* Bryston BDA3 */
1747	case USB_ID(0x22e1, 0xca01): /* HDTA Serenade DSD */
1748	case USB_ID(0x249c, 0x9326): /* M2Tech Young MkIII */
1749	case USB_ID(0x2616, 0x0106): /* PS Audio NuWave DAC */
1750	case USB_ID(0x2622, 0x0041): /* Audiolab M-DAC+ */
1751	case USB_ID(0x27f7, 0x3002): /* W4S DAC-2v2SE */
1752	case USB_ID(0x29a2, 0x0086): /* Mutec MC3+ USB */
1753	case USB_ID(0x6b42, 0x0042): /* MSB Technology */
1754		if (fp->altsetting == 3)
1755			return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1756		break;
1757
1758	/* Amanero Combo384 USB based DACs with native DSD support */
1759	case USB_ID(0x16d0, 0x071a):  /* Amanero - Combo384 */
1760	case USB_ID(0x2ab6, 0x0004):  /* T+A DAC8DSD-V2.0, MP1000E-V2.0, MP2000R-V2.0, MP2500R-V2.0, MP3100HV-V2.0 */
1761	case USB_ID(0x2ab6, 0x0005):  /* T+A USB HD Audio 1 */
1762	case USB_ID(0x2ab6, 0x0006):  /* T+A USB HD Audio 2 */
1763		if (fp->altsetting == 2) {
1764			switch (le16_to_cpu(chip->dev->descriptor.bcdDevice)) {
1765			case 0x199:
1766				return SNDRV_PCM_FMTBIT_DSD_U32_LE;
1767			case 0x19b:
1768			case 0x203:
1769				return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1770			default:
1771				break;
1772			}
1773		}
1774		break;
1775	case USB_ID(0x16d0, 0x0a23):
1776		if (fp->altsetting == 2)
1777			return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1778		break;
1779
1780	default:
1781		break;
1782	}
1783
1784	/* ITF-USB DSD based DACs */
1785	if (is_itf_usb_dsd_dac(chip->usb_id)) {
1786		iface = usb_ifnum_to_if(chip->dev, fp->iface);
1787
1788		/* Altsetting 2 support native DSD if the num of altsets is
1789		 * three (0-2),
1790		 * Altsetting 3 support native DSD if the num of altsets is
1791		 * four (0-3).
1792		 */
1793		if (fp->altsetting == iface->num_altsetting - 1)
1794			return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1795	}
1796
1797	/* Mostly generic method to detect many DSD-capable implementations -
1798	 * from XMOS/Thesycon
1799	 */
1800	switch (USB_ID_VENDOR(chip->usb_id)) {
1801	case 0x152a:  /* Thesycon devices */
1802	case 0x20b1:  /* XMOS based devices */
1803	case 0x22d9:  /* Oppo */
1804	case 0x23ba:  /* Playback Designs */
1805	case 0x25ce:  /* Mytek devices */
1806	case 0x278b:  /* Rotel? */
1807	case 0x292b:  /* Gustard/Ess based devices */
1808	case 0x2ab6:  /* T+A devices */
1809	case 0x3842:  /* EVGA */
1810	case 0xc502:  /* HiBy devices */
1811		if (fp->dsd_raw)
1812			return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1813		break;
1814	default:
1815		break;
1816
1817	}
1818
1819	return 0;
1820}
1821
1822void snd_usb_audioformat_attributes_quirk(struct snd_usb_audio *chip,
1823					  struct audioformat *fp,
1824					  int stream)
1825{
1826	switch (chip->usb_id) {
1827	case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
1828		/* Optoplay sets the sample rate attribute although
1829		 * it seems not supporting it in fact.
1830		 */
1831		fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE;
1832		break;
1833	case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
1834	case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
1835		/* doesn't set the sample rate attribute, but supports it */
1836		fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE;
1837		break;
1838	case USB_ID(0x0763, 0x2001):  /* M-Audio Quattro USB */
1839	case USB_ID(0x0763, 0x2012):  /* M-Audio Fast Track Pro USB */
1840	case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
1841	case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
1842					an older model 77d:223) */
1843	/*
1844	 * plantronics headset and Griffin iMic have set adaptive-in
1845	 * although it's really not...
1846	 */
1847		fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE;
1848		if (stream == SNDRV_PCM_STREAM_PLAYBACK)
1849			fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE;
1850		else
1851			fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC;
1852		break;
1853	case USB_ID(0x07fd, 0x0004):  /* MOTU MicroBook IIc */
1854		/*
1855		 * MaxPacketsOnly attribute is erroneously set in endpoint
1856		 * descriptors. As a result this card produces noise with
1857		 * all sample rates other than 96 kHz.
1858		 */
1859		fp->attributes &= ~UAC_EP_CS_ATTR_FILL_MAX;
1860		break;
 
 
 
 
 
1861	}
1862}
1863
1864/*
1865 * registration quirk:
1866 * the registration is skipped if a device matches with the given ID,
1867 * unless the interface reaches to the defined one.  This is for delaying
1868 * the registration until the last known interface, so that the card and
1869 * devices appear at the same time.
1870 */
1871
1872struct registration_quirk {
1873	unsigned int usb_id;	/* composed via USB_ID() */
1874	unsigned int interface;	/* the interface to trigger register */
1875};
1876
1877#define REG_QUIRK_ENTRY(vendor, product, iface) \
1878	{ .usb_id = USB_ID(vendor, product), .interface = (iface) }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1879
1880static const struct registration_quirk registration_quirks[] = {
1881	REG_QUIRK_ENTRY(0x0951, 0x16d8, 2),	/* Kingston HyperX AMP */
1882	REG_QUIRK_ENTRY(0x0951, 0x16ed, 2),	/* Kingston HyperX Cloud Alpha S */
1883	REG_QUIRK_ENTRY(0x0951, 0x16ea, 2),	/* Kingston HyperX Cloud Flight S */
1884	{ 0 }					/* terminator */
1885};
1886
1887/* return true if skipping registration */
1888bool snd_usb_registration_quirk(struct snd_usb_audio *chip, int iface)
1889{
1890	const struct registration_quirk *q;
1891
1892	for (q = registration_quirks; q->usb_id; q++)
1893		if (chip->usb_id == q->usb_id)
1894			return iface != q->interface;
1895
1896	/* Register as normal */
1897	return false;
 
 
 
 
 
 
1898}