Linux Audio

Check our new training course

Loading...
v5.9
   1/* SPDX-License-Identifier: GPL-2.0-or-later */
   2/*
   3 * ALSA USB Audio Driver
   4 *
   5 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>,
   6 *                       Clemens Ladisch <clemens@ladisch.de>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
   7 */
   8
   9/*
  10 * The contents of this file are part of the driver's id_table.
  11 *
  12 * In a perfect world, this file would be empty.
  13 */
  14
  15/*
  16 * Use this for devices where other interfaces are standard compliant,
  17 * to prevent the quirk being applied to those interfaces. (To work with
  18 * hotplugging, bDeviceClass must be set to USB_CLASS_PER_INTERFACE.)
  19 */
  20#define USB_DEVICE_VENDOR_SPEC(vend, prod) \
  21	.match_flags = USB_DEVICE_ID_MATCH_VENDOR | \
  22		       USB_DEVICE_ID_MATCH_PRODUCT | \
  23		       USB_DEVICE_ID_MATCH_INT_CLASS, \
  24	.idVendor = vend, \
  25	.idProduct = prod, \
  26	.bInterfaceClass = USB_CLASS_VENDOR_SPEC
  27
  28#define QUIRK_RENAME_DEVICE(_vendor, _device)				\
  29	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
  30		.vendor_name = _vendor,					\
  31		.product_name = _device,				\
  32		.ifnum = QUIRK_NO_INTERFACE				\
  33	}
  34
  35#define QUIRK_DEVICE_PROFILE(_vendor, _device, _profile)		\
  36	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
  37		.vendor_name = _vendor,					\
  38		.product_name = _device,				\
  39		.profile_name = _profile,				\
  40		.ifnum = QUIRK_NO_INTERFACE				\
  41	}
  42
  43/* HP Thunderbolt Dock Audio Headset */
  44{
  45	USB_DEVICE(0x03f0, 0x0269),
  46	QUIRK_DEVICE_PROFILE("HP", "Thunderbolt Dock Audio Headset",
  47			     "HP-Thunderbolt-Dock-Audio-Headset"),
  48},
  49/* HP Thunderbolt Dock Audio Module */
  50{
  51	USB_DEVICE(0x03f0, 0x0567),
  52	QUIRK_DEVICE_PROFILE("HP", "Thunderbolt Dock Audio Module",
  53			     "HP-Thunderbolt-Dock-Audio-Module"),
  54},
  55/* FTDI devices */
  56{
  57	USB_DEVICE(0x0403, 0xb8d8),
  58	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  59		/* .vendor_name = "STARR LABS", */
  60		/* .product_name = "Starr Labs MIDI USB device", */
  61		.ifnum = 0,
  62		.type = QUIRK_MIDI_FTDI
  63	}
  64},
  65
  66{
  67	/* Creative BT-D1 */
  68	USB_DEVICE(0x041e, 0x0005),
  69	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  70		.ifnum = 1,
  71		.type = QUIRK_AUDIO_FIXED_ENDPOINT,
  72		.data = &(const struct audioformat) {
  73			.formats = SNDRV_PCM_FMTBIT_S16_LE,
  74			.channels = 2,
  75			.iface = 1,
  76			.altsetting = 1,
  77			.altset_idx = 1,
  78			.endpoint = 0x03,
  79			.ep_attr = USB_ENDPOINT_XFER_ISOC,
  80			.attributes = 0,
  81			.rates = SNDRV_PCM_RATE_CONTINUOUS,
  82			.rate_min = 48000,
  83			.rate_max = 48000,
  84		}
  85	}
  86},
  87
  88/* Creative/E-Mu devices */
  89{
  90	USB_DEVICE(0x041e, 0x3010),
  91	QUIRK_RENAME_DEVICE("Creative Labs", "Sound Blaster MP3+")
 
 
 
 
  92},
  93/* Creative/Toshiba Multimedia Center SB-0500 */
  94{
  95	USB_DEVICE(0x041e, 0x3048),
  96	QUIRK_RENAME_DEVICE("Toshiba", "SB-0500")
 
 
 
 
  97},
  98{
  99	/* E-Mu 0202 USB */
 100	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
 101	.idVendor = 0x041e,
 102	.idProduct = 0x3f02,
 103	.bInterfaceClass = USB_CLASS_AUDIO,
 104},
 105{
 106	/* E-Mu 0404 USB */
 107	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
 108	.idVendor = 0x041e,
 109	.idProduct = 0x3f04,
 110	.bInterfaceClass = USB_CLASS_AUDIO,
 111},
 112{
 113	/* E-Mu Tracker Pre */
 114	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
 115	.idVendor = 0x041e,
 116	.idProduct = 0x3f0a,
 117	.bInterfaceClass = USB_CLASS_AUDIO,
 118},
 119{
 120	/* E-Mu 0204 USB */
 121	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
 122	.idVendor = 0x041e,
 123	.idProduct = 0x3f19,
 124	.bInterfaceClass = USB_CLASS_AUDIO,
 125},
 126
 127/*
 128 * HP Wireless Audio
 129 * When not ignored, causes instability issues for some users, forcing them to
 130 * skip the entire module.
 131 */
 132{
 133	USB_DEVICE(0x0424, 0xb832),
 134	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
 135		.vendor_name = "Standard Microsystems Corp.",
 136		.product_name = "HP Wireless Audio",
 137		.ifnum = QUIRK_ANY_INTERFACE,
 138		.type = QUIRK_COMPOSITE,
 139		.data = (const struct snd_usb_audio_quirk[]) {
 140			/* Mixer */
 141			{
 142				.ifnum = 0,
 143				.type = QUIRK_IGNORE_INTERFACE,
 144			},
 145			/* Playback */
 146			{
 147				.ifnum = 1,
 148				.type = QUIRK_IGNORE_INTERFACE,
 149			},
 150			/* Capture */
 151			{
 152				.ifnum = 2,
 153				.type = QUIRK_IGNORE_INTERFACE,
 154			},
 155			/* HID Device, .ifnum = 3 */
 156			{
 157				.ifnum = -1,
 158			}
 159		}
 160	}
 161},
 162
 163/*
 164 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
 165 * class matches do not take effect without an explicit ID match.
 166 */
 167{
 168	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 169		       USB_DEVICE_ID_MATCH_INT_CLASS |
 170		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 171	.idVendor = 0x046d,
 172	.idProduct = 0x0850,
 173	.bInterfaceClass = USB_CLASS_AUDIO,
 174	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 175},
 176{
 177	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 178		       USB_DEVICE_ID_MATCH_INT_CLASS |
 179		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 180	.idVendor = 0x046d,
 181	.idProduct = 0x08ae,
 182	.bInterfaceClass = USB_CLASS_AUDIO,
 183	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 184},
 185{
 186	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 187		       USB_DEVICE_ID_MATCH_INT_CLASS |
 188		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 189	.idVendor = 0x046d,
 190	.idProduct = 0x08c6,
 191	.bInterfaceClass = USB_CLASS_AUDIO,
 192	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 193},
 194{
 195	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 196		       USB_DEVICE_ID_MATCH_INT_CLASS |
 197		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 198	.idVendor = 0x046d,
 199	.idProduct = 0x08f0,
 200	.bInterfaceClass = USB_CLASS_AUDIO,
 201	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 202},
 203{
 204	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 205		       USB_DEVICE_ID_MATCH_INT_CLASS |
 206		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 207	.idVendor = 0x046d,
 208	.idProduct = 0x08f5,
 209	.bInterfaceClass = USB_CLASS_AUDIO,
 210	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 211},
 212{
 213	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 214		       USB_DEVICE_ID_MATCH_INT_CLASS |
 215		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 216	.idVendor = 0x046d,
 217	.idProduct = 0x08f6,
 218	.bInterfaceClass = USB_CLASS_AUDIO,
 219	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 220},
 221{
 222	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 223		       USB_DEVICE_ID_MATCH_INT_CLASS |
 224		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 225	.idVendor = 0x046d,
 226	.idProduct = 0x0990,
 227	.bInterfaceClass = USB_CLASS_AUDIO,
 228	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
 229	QUIRK_RENAME_DEVICE("Logitech, Inc.", "QuickCam Pro 9000")
 
 
 
 
 230},
 231
 232/*
 233 * Yamaha devices
 234 */
 235
 236#define YAMAHA_DEVICE(id, name) { \
 237	USB_DEVICE(0x0499, id), \
 238	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 239		.vendor_name = "Yamaha", \
 240		.product_name = name, \
 241		.ifnum = QUIRK_ANY_INTERFACE, \
 242		.type = QUIRK_MIDI_YAMAHA \
 243	} \
 244}
 245#define YAMAHA_INTERFACE(id, intf, name) { \
 246	USB_DEVICE_VENDOR_SPEC(0x0499, id), \
 247	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 248		.vendor_name = "Yamaha", \
 249		.product_name = name, \
 250		.ifnum = intf, \
 251		.type = QUIRK_MIDI_YAMAHA \
 252	} \
 253}
 254YAMAHA_DEVICE(0x1000, "UX256"),
 255YAMAHA_DEVICE(0x1001, "MU1000"),
 256YAMAHA_DEVICE(0x1002, "MU2000"),
 257YAMAHA_DEVICE(0x1003, "MU500"),
 258YAMAHA_INTERFACE(0x1004, 3, "UW500"),
 259YAMAHA_DEVICE(0x1005, "MOTIF6"),
 260YAMAHA_DEVICE(0x1006, "MOTIF7"),
 261YAMAHA_DEVICE(0x1007, "MOTIF8"),
 262YAMAHA_DEVICE(0x1008, "UX96"),
 263YAMAHA_DEVICE(0x1009, "UX16"),
 264YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
 265YAMAHA_DEVICE(0x100c, "UC-MX"),
 266YAMAHA_DEVICE(0x100d, "UC-KX"),
 267YAMAHA_DEVICE(0x100e, "S08"),
 268YAMAHA_DEVICE(0x100f, "CLP-150"),
 269YAMAHA_DEVICE(0x1010, "CLP-170"),
 270YAMAHA_DEVICE(0x1011, "P-250"),
 271YAMAHA_DEVICE(0x1012, "TYROS"),
 272YAMAHA_DEVICE(0x1013, "PF-500"),
 273YAMAHA_DEVICE(0x1014, "S90"),
 274YAMAHA_DEVICE(0x1015, "MOTIF-R"),
 275YAMAHA_DEVICE(0x1016, "MDP-5"),
 276YAMAHA_DEVICE(0x1017, "CVP-204"),
 277YAMAHA_DEVICE(0x1018, "CVP-206"),
 278YAMAHA_DEVICE(0x1019, "CVP-208"),
 279YAMAHA_DEVICE(0x101a, "CVP-210"),
 280YAMAHA_DEVICE(0x101b, "PSR-1100"),
 281YAMAHA_DEVICE(0x101c, "PSR-2100"),
 282YAMAHA_DEVICE(0x101d, "CLP-175"),
 283YAMAHA_DEVICE(0x101e, "PSR-K1"),
 284YAMAHA_DEVICE(0x101f, "EZ-J24"),
 285YAMAHA_DEVICE(0x1020, "EZ-250i"),
 286YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
 287YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
 288YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
 289YAMAHA_DEVICE(0x1024, "CVP-301"),
 290YAMAHA_DEVICE(0x1025, "CVP-303"),
 291YAMAHA_DEVICE(0x1026, "CVP-305"),
 292YAMAHA_DEVICE(0x1027, "CVP-307"),
 293YAMAHA_DEVICE(0x1028, "CVP-309"),
 294YAMAHA_DEVICE(0x1029, "CVP-309GP"),
 295YAMAHA_DEVICE(0x102a, "PSR-1500"),
 296YAMAHA_DEVICE(0x102b, "PSR-3000"),
 297YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
 298YAMAHA_DEVICE(0x1030, "PSR-295/293"),
 299YAMAHA_DEVICE(0x1031, "DGX-205/203"),
 300YAMAHA_DEVICE(0x1032, "DGX-305"),
 301YAMAHA_DEVICE(0x1033, "DGX-505"),
 302YAMAHA_DEVICE(0x1034, NULL),
 303YAMAHA_DEVICE(0x1035, NULL),
 304YAMAHA_DEVICE(0x1036, NULL),
 305YAMAHA_DEVICE(0x1037, NULL),
 306YAMAHA_DEVICE(0x1038, NULL),
 307YAMAHA_DEVICE(0x1039, NULL),
 308YAMAHA_DEVICE(0x103a, NULL),
 309YAMAHA_DEVICE(0x103b, NULL),
 310YAMAHA_DEVICE(0x103c, NULL),
 311YAMAHA_DEVICE(0x103d, NULL),
 312YAMAHA_DEVICE(0x103e, NULL),
 313YAMAHA_DEVICE(0x103f, NULL),
 314YAMAHA_DEVICE(0x1040, NULL),
 315YAMAHA_DEVICE(0x1041, NULL),
 316YAMAHA_DEVICE(0x1042, NULL),
 317YAMAHA_DEVICE(0x1043, NULL),
 318YAMAHA_DEVICE(0x1044, NULL),
 319YAMAHA_DEVICE(0x1045, NULL),
 320YAMAHA_INTERFACE(0x104e, 0, NULL),
 321YAMAHA_DEVICE(0x104f, NULL),
 322YAMAHA_DEVICE(0x1050, NULL),
 323YAMAHA_DEVICE(0x1051, NULL),
 324YAMAHA_DEVICE(0x1052, NULL),
 325YAMAHA_INTERFACE(0x1053, 0, NULL),
 326YAMAHA_INTERFACE(0x1054, 0, NULL),
 327YAMAHA_DEVICE(0x1055, NULL),
 328YAMAHA_DEVICE(0x1056, NULL),
 329YAMAHA_DEVICE(0x1057, NULL),
 330YAMAHA_DEVICE(0x1058, NULL),
 331YAMAHA_DEVICE(0x1059, NULL),
 332YAMAHA_DEVICE(0x105a, NULL),
 333YAMAHA_DEVICE(0x105b, NULL),
 334YAMAHA_DEVICE(0x105c, NULL),
 335YAMAHA_DEVICE(0x105d, NULL),
 336{
 337	USB_DEVICE(0x0499, 0x1503),
 338	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 339		/* .vendor_name = "Yamaha", */
 340		/* .product_name = "MOX6/MOX8", */
 341		.ifnum = QUIRK_ANY_INTERFACE,
 342		.type = QUIRK_COMPOSITE,
 343		.data = (const struct snd_usb_audio_quirk[]) {
 344			{
 345				.ifnum = 1,
 346				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 347			},
 348			{
 349				.ifnum = 2,
 350				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 351			},
 352			{
 353				.ifnum = 3,
 354				.type = QUIRK_MIDI_YAMAHA
 355			},
 356			{
 357				.ifnum = -1
 358			}
 359		}
 360	}
 361},
 362{
 363	USB_DEVICE(0x0499, 0x1507),
 364	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 365		/* .vendor_name = "Yamaha", */
 366		/* .product_name = "THR10", */
 367		.ifnum = QUIRK_ANY_INTERFACE,
 368		.type = QUIRK_COMPOSITE,
 369		.data = (const struct snd_usb_audio_quirk[]) {
 370			{
 371				.ifnum = 1,
 372				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 373			},
 374			{
 375				.ifnum = 2,
 376				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 377			},
 378			{
 379				.ifnum = 3,
 380				.type = QUIRK_MIDI_YAMAHA
 381			},
 382			{
 383				.ifnum = -1
 384			}
 385		}
 386	}
 387},
 388{
 389	USB_DEVICE(0x0499, 0x1509),
 390	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 391		/* .vendor_name = "Yamaha", */
 392		/* .product_name = "Steinberg UR22", */
 393		.ifnum = QUIRK_ANY_INTERFACE,
 394		.type = QUIRK_COMPOSITE,
 395		.data = (const struct snd_usb_audio_quirk[]) {
 396			{
 397				.ifnum = 1,
 398				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 399			},
 400			{
 401				.ifnum = 2,
 402				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 403			},
 404			{
 405				.ifnum = 3,
 406				.type = QUIRK_MIDI_YAMAHA
 407			},
 408			{
 409				.ifnum = 4,
 410				.type = QUIRK_IGNORE_INTERFACE
 411			},
 412			{
 413				.ifnum = -1
 414			}
 415		}
 416	}
 417},
 418{
 419	USB_DEVICE(0x0499, 0x150a),
 420	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 421		/* .vendor_name = "Yamaha", */
 422		/* .product_name = "THR5A", */
 423		.ifnum = QUIRK_ANY_INTERFACE,
 424		.type = QUIRK_COMPOSITE,
 425		.data = (const struct snd_usb_audio_quirk[]) {
 426			{
 427				.ifnum = 1,
 428				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 429			},
 430			{
 431				.ifnum = 2,
 432				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 433			},
 434			{
 435				.ifnum = 3,
 436				.type = QUIRK_MIDI_YAMAHA
 437			},
 438			{
 439				.ifnum = -1
 440			}
 441		}
 442	}
 443},
 444{
 445	USB_DEVICE(0x0499, 0x150c),
 446	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 447		/* .vendor_name = "Yamaha", */
 448		/* .product_name = "THR10C", */
 449		.ifnum = QUIRK_ANY_INTERFACE,
 450		.type = QUIRK_COMPOSITE,
 451		.data = (const struct snd_usb_audio_quirk[]) {
 452			{
 453				.ifnum = 1,
 454				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 455			},
 456			{
 457				.ifnum = 2,
 458				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 459			},
 460			{
 461				.ifnum = 3,
 462				.type = QUIRK_MIDI_YAMAHA
 463			},
 464			{
 465				.ifnum = -1
 466			}
 467		}
 468	}
 469},
 470YAMAHA_DEVICE(0x2000, "DGP-7"),
 471YAMAHA_DEVICE(0x2001, "DGP-5"),
 472YAMAHA_DEVICE(0x2002, NULL),
 473YAMAHA_DEVICE(0x2003, NULL),
 474YAMAHA_DEVICE(0x5000, "CS1D"),
 475YAMAHA_DEVICE(0x5001, "DSP1D"),
 476YAMAHA_DEVICE(0x5002, "DME32"),
 477YAMAHA_DEVICE(0x5003, "DM2000"),
 478YAMAHA_DEVICE(0x5004, "02R96"),
 479YAMAHA_DEVICE(0x5005, "ACU16-C"),
 480YAMAHA_DEVICE(0x5006, "NHB32-C"),
 481YAMAHA_DEVICE(0x5007, "DM1000"),
 482YAMAHA_DEVICE(0x5008, "01V96"),
 483YAMAHA_DEVICE(0x5009, "SPX2000"),
 484YAMAHA_DEVICE(0x500a, "PM5D"),
 485YAMAHA_DEVICE(0x500b, "DME64N"),
 486YAMAHA_DEVICE(0x500c, "DME24N"),
 487YAMAHA_DEVICE(0x500d, NULL),
 488YAMAHA_DEVICE(0x500e, NULL),
 489YAMAHA_DEVICE(0x500f, NULL),
 490YAMAHA_DEVICE(0x7000, "DTX"),
 491YAMAHA_DEVICE(0x7010, "UB99"),
 492#undef YAMAHA_DEVICE
 493#undef YAMAHA_INTERFACE
 494/* this catches most recent vendor-specific Yamaha devices */
 495{
 496	.match_flags = USB_DEVICE_ID_MATCH_VENDOR |
 497	               USB_DEVICE_ID_MATCH_INT_CLASS,
 498	.idVendor = 0x0499,
 499	.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
 500	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
 501		.ifnum = QUIRK_ANY_INTERFACE,
 502		.type = QUIRK_AUTODETECT
 503	}
 504},
 505
 506/*
 507 * Roland/RolandED/Edirol/BOSS devices
 508 */
 509{
 510	USB_DEVICE(0x0582, 0x0000),
 511	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 512		.vendor_name = "Roland",
 513		.product_name = "UA-100",
 514		.ifnum = QUIRK_ANY_INTERFACE,
 515		.type = QUIRK_COMPOSITE,
 516		.data = (const struct snd_usb_audio_quirk[]) {
 517			{
 518				.ifnum = 0,
 519				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
 520				.data = & (const struct audioformat) {
 521					.formats = SNDRV_PCM_FMTBIT_S16_LE,
 522					.channels = 4,
 523					.iface = 0,
 524					.altsetting = 1,
 525					.altset_idx = 1,
 526					.attributes = 0,
 527					.endpoint = 0x01,
 528					.ep_attr = 0x09,
 529					.rates = SNDRV_PCM_RATE_CONTINUOUS,
 530					.rate_min = 44100,
 531					.rate_max = 44100,
 532				}
 533			},
 534			{
 535				.ifnum = 1,
 536				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
 537				.data = & (const struct audioformat) {
 538					.formats = SNDRV_PCM_FMTBIT_S16_LE,
 539					.channels = 2,
 540					.iface = 1,
 541					.altsetting = 1,
 542					.altset_idx = 1,
 543					.attributes = UAC_EP_CS_ATTR_FILL_MAX,
 544					.endpoint = 0x81,
 545					.ep_attr = 0x05,
 546					.rates = SNDRV_PCM_RATE_CONTINUOUS,
 547					.rate_min = 44100,
 548					.rate_max = 44100,
 549				}
 550			},
 551			{
 552				.ifnum = 2,
 553				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 554				.data = & (const struct snd_usb_midi_endpoint_info) {
 555					.out_cables = 0x0007,
 556					.in_cables  = 0x0007
 557				}
 558			},
 559			{
 560				.ifnum = -1
 561			}
 562		}
 563	}
 564},
 565{
 566	USB_DEVICE(0x0582, 0x0002),
 567	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 568		.vendor_name = "EDIROL",
 569		.product_name = "UM-4",
 570		.ifnum = QUIRK_ANY_INTERFACE,
 571		.type = QUIRK_COMPOSITE,
 572		.data = (const struct snd_usb_audio_quirk[]) {
 573			{
 574				.ifnum = 0,
 575				.type = QUIRK_IGNORE_INTERFACE
 576			},
 577			{
 578				.ifnum = 1,
 579				.type = QUIRK_IGNORE_INTERFACE
 580			},
 581			{
 582				.ifnum = 2,
 583				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 584				.data = & (const struct snd_usb_midi_endpoint_info) {
 585					.out_cables = 0x000f,
 586					.in_cables  = 0x000f
 587				}
 588			},
 589			{
 590				.ifnum = -1
 591			}
 592		}
 593	}
 594},
 595{
 596	USB_DEVICE(0x0582, 0x0003),
 597	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 598		.vendor_name = "Roland",
 599		.product_name = "SC-8850",
 600		.ifnum = QUIRK_ANY_INTERFACE,
 601		.type = QUIRK_COMPOSITE,
 602		.data = (const struct snd_usb_audio_quirk[]) {
 603			{
 604				.ifnum = 0,
 605				.type = QUIRK_IGNORE_INTERFACE
 606			},
 607			{
 608				.ifnum = 1,
 609				.type = QUIRK_IGNORE_INTERFACE
 610			},
 611			{
 612				.ifnum = 2,
 613				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 614				.data = & (const struct snd_usb_midi_endpoint_info) {
 615					.out_cables = 0x003f,
 616					.in_cables  = 0x003f
 617				}
 618			},
 619			{
 620				.ifnum = -1
 621			}
 622		}
 623	}
 624},
 625{
 626	USB_DEVICE(0x0582, 0x0004),
 627	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 628		.vendor_name = "Roland",
 629		.product_name = "U-8",
 630		.ifnum = QUIRK_ANY_INTERFACE,
 631		.type = QUIRK_COMPOSITE,
 632		.data = (const struct snd_usb_audio_quirk[]) {
 633			{
 634				.ifnum = 0,
 635				.type = QUIRK_IGNORE_INTERFACE
 636			},
 637			{
 638				.ifnum = 1,
 639				.type = QUIRK_IGNORE_INTERFACE
 640			},
 641			{
 642				.ifnum = 2,
 643				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 644				.data = & (const struct snd_usb_midi_endpoint_info) {
 645					.out_cables = 0x0005,
 646					.in_cables  = 0x0005
 647				}
 648			},
 649			{
 650				.ifnum = -1
 651			}
 652		}
 653	}
 654},
 655{
 656	/* Has ID 0x0099 when not in "Advanced Driver" mode.
 657	 * The UM-2EX has only one input, but we cannot detect this. */
 658	USB_DEVICE(0x0582, 0x0005),
 659	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 660		.vendor_name = "EDIROL",
 661		.product_name = "UM-2",
 662		.ifnum = QUIRK_ANY_INTERFACE,
 663		.type = QUIRK_COMPOSITE,
 664		.data = (const struct snd_usb_audio_quirk[]) {
 665			{
 666				.ifnum = 0,
 667				.type = QUIRK_IGNORE_INTERFACE
 668			},
 669			{
 670				.ifnum = 1,
 671				.type = QUIRK_IGNORE_INTERFACE
 672			},
 673			{
 674				.ifnum = 2,
 675				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 676				.data = & (const struct snd_usb_midi_endpoint_info) {
 677					.out_cables = 0x0003,
 678					.in_cables  = 0x0003
 679				}
 680			},
 681			{
 682				.ifnum = -1
 683			}
 684		}
 685	}
 686},
 687{
 688	USB_DEVICE(0x0582, 0x0007),
 689	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 690		.vendor_name = "Roland",
 691		.product_name = "SC-8820",
 692		.ifnum = QUIRK_ANY_INTERFACE,
 693		.type = QUIRK_COMPOSITE,
 694		.data = (const struct snd_usb_audio_quirk[]) {
 695			{
 696				.ifnum = 0,
 697				.type = QUIRK_IGNORE_INTERFACE
 698			},
 699			{
 700				.ifnum = 1,
 701				.type = QUIRK_IGNORE_INTERFACE
 702			},
 703			{
 704				.ifnum = 2,
 705				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 706				.data = & (const struct snd_usb_midi_endpoint_info) {
 707					.out_cables = 0x0013,
 708					.in_cables  = 0x0013
 709				}
 710			},
 711			{
 712				.ifnum = -1
 713			}
 714		}
 715	}
 716},
 717{
 718	USB_DEVICE(0x0582, 0x0008),
 719	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 720		.vendor_name = "Roland",
 721		.product_name = "PC-300",
 722		.ifnum = QUIRK_ANY_INTERFACE,
 723		.type = QUIRK_COMPOSITE,
 724		.data = (const struct snd_usb_audio_quirk[]) {
 725			{
 726				.ifnum = 0,
 727				.type = QUIRK_IGNORE_INTERFACE
 728			},
 729			{
 730				.ifnum = 1,
 731				.type = QUIRK_IGNORE_INTERFACE
 732			},
 733			{
 734				.ifnum = 2,
 735				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 736				.data = & (const struct snd_usb_midi_endpoint_info) {
 737					.out_cables = 0x0001,
 738					.in_cables  = 0x0001
 739				}
 740			},
 741			{
 742				.ifnum = -1
 743			}
 744		}
 745	}
 746},
 747{
 748	/* has ID 0x009d when not in "Advanced Driver" mode */
 749	USB_DEVICE(0x0582, 0x0009),
 750	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 751		.vendor_name = "EDIROL",
 752		.product_name = "UM-1",
 753		.ifnum = QUIRK_ANY_INTERFACE,
 754		.type = QUIRK_COMPOSITE,
 755		.data = (const struct snd_usb_audio_quirk[]) {
 756			{
 757				.ifnum = 0,
 758				.type = QUIRK_IGNORE_INTERFACE
 759			},
 760			{
 761				.ifnum = 1,
 762				.type = QUIRK_IGNORE_INTERFACE
 763			},
 764			{
 765				.ifnum = 2,
 766				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 767				.data = & (const struct snd_usb_midi_endpoint_info) {
 768					.out_cables = 0x0001,
 769					.in_cables  = 0x0001
 770				}
 771			},
 772			{
 773				.ifnum = -1
 774			}
 775		}
 776	}
 777},
 778{
 779	USB_DEVICE(0x0582, 0x000b),
 780	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 781		.vendor_name = "Roland",
 782		.product_name = "SK-500",
 783		.ifnum = QUIRK_ANY_INTERFACE,
 784		.type = QUIRK_COMPOSITE,
 785		.data = (const struct snd_usb_audio_quirk[]) {
 786			{
 787				.ifnum = 0,
 788				.type = QUIRK_IGNORE_INTERFACE
 789			},
 790			{
 791				.ifnum = 1,
 792				.type = QUIRK_IGNORE_INTERFACE
 793			},
 794			{
 795				.ifnum = 2,
 796				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 797				.data = & (const struct snd_usb_midi_endpoint_info) {
 798					.out_cables = 0x0013,
 799					.in_cables  = 0x0013
 800				}
 801			},
 802			{
 803				.ifnum = -1
 804			}
 805		}
 806	}
 807},
 808{
 809	/* thanks to Emiliano Grilli <emillo@libero.it>
 810	 * for helping researching this data */
 811	USB_DEVICE(0x0582, 0x000c),
 812	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 813		.vendor_name = "Roland",
 814		.product_name = "SC-D70",
 815		.ifnum = QUIRK_ANY_INTERFACE,
 816		.type = QUIRK_COMPOSITE,
 817		.data = (const struct snd_usb_audio_quirk[]) {
 818			{
 819				.ifnum = 0,
 820				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 
 
 
 
 
 
 
 
 
 
 
 
 
 821			},
 822			{
 823				.ifnum = 1,
 824				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 
 
 
 
 
 
 
 
 
 
 
 
 
 825			},
 826			{
 827				.ifnum = 2,
 828				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 829				.data = & (const struct snd_usb_midi_endpoint_info) {
 830					.out_cables = 0x0007,
 831					.in_cables  = 0x0007
 832				}
 833			},
 834			{
 835				.ifnum = -1
 836			}
 837		}
 838	}
 839},
 840{	/*
 841	 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 842	 * If the advanced mode switch at the back of the unit is off, the
 843	 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 844	 * but offers only 16-bit PCM.
 845	 * In advanced mode, the UA-5 will output S24_3LE samples (two
 846	 * channels) at the rate indicated on the front switch, including
 847	 * the 96kHz sample rate.
 848	 */
 849	USB_DEVICE(0x0582, 0x0010),
 850	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 851		.vendor_name = "EDIROL",
 852		.product_name = "UA-5",
 853		.ifnum = QUIRK_ANY_INTERFACE,
 854		.type = QUIRK_COMPOSITE,
 855		.data = (const struct snd_usb_audio_quirk[]) {
 856			{
 857				.ifnum = 1,
 858				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 859			},
 860			{
 861				.ifnum = 2,
 862				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 863			},
 864			{
 865				.ifnum = -1
 866			}
 867		}
 868	}
 869},
 870{
 871	/* has ID 0x0013 when not in "Advanced Driver" mode */
 872	USB_DEVICE(0x0582, 0x0012),
 873	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 874		.vendor_name = "Roland",
 875		.product_name = "XV-5050",
 876		.ifnum = 0,
 877		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 878		.data = & (const struct snd_usb_midi_endpoint_info) {
 879			.out_cables = 0x0001,
 880			.in_cables  = 0x0001
 881		}
 882	}
 883},
 884{
 885	/* has ID 0x0015 when not in "Advanced Driver" mode */
 886	USB_DEVICE(0x0582, 0x0014),
 887	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 888		.vendor_name = "EDIROL",
 889		.product_name = "UM-880",
 890		.ifnum = 0,
 891		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 892		.data = & (const struct snd_usb_midi_endpoint_info) {
 893			.out_cables = 0x01ff,
 894			.in_cables  = 0x01ff
 895		}
 896	}
 897},
 898{
 899	/* has ID 0x0017 when not in "Advanced Driver" mode */
 900	USB_DEVICE(0x0582, 0x0016),
 901	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 902		.vendor_name = "EDIROL",
 903		.product_name = "SD-90",
 904		.ifnum = QUIRK_ANY_INTERFACE,
 905		.type = QUIRK_COMPOSITE,
 906		.data = (const struct snd_usb_audio_quirk[]) {
 907			{
 908				.ifnum = 0,
 909				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 910			},
 911			{
 912				.ifnum = 1,
 913				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 914			},
 915			{
 916				.ifnum = 2,
 917				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 918				.data = & (const struct snd_usb_midi_endpoint_info) {
 919					.out_cables = 0x000f,
 920					.in_cables  = 0x000f
 921				}
 922			},
 923			{
 924				.ifnum = -1
 925			}
 926		}
 927	}
 928},
 929{
 930	/* has ID 0x001c when not in "Advanced Driver" mode */
 931	USB_DEVICE(0x0582, 0x001b),
 932	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 933		.vendor_name = "Roland",
 934		.product_name = "MMP-2",
 935		.ifnum = QUIRK_ANY_INTERFACE,
 936		.type = QUIRK_COMPOSITE,
 937		.data = (const struct snd_usb_audio_quirk[]) {
 938			{
 939				.ifnum = 0,
 940				.type = QUIRK_IGNORE_INTERFACE
 941			},
 942			{
 943				.ifnum = 1,
 944				.type = QUIRK_IGNORE_INTERFACE
 945			},
 946			{
 947				.ifnum = 2,
 948				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 949				.data = & (const struct snd_usb_midi_endpoint_info) {
 950					.out_cables = 0x0001,
 951					.in_cables  = 0x0001
 952				}
 953			},
 954			{
 955				.ifnum = -1
 956			}
 957		}
 958	}
 959},
 960{
 961	/* has ID 0x001e when not in "Advanced Driver" mode */
 962	USB_DEVICE(0x0582, 0x001d),
 963	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 964		.vendor_name = "Roland",
 965		.product_name = "V-SYNTH",
 966		.ifnum = 0,
 967		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 968		.data = & (const struct snd_usb_midi_endpoint_info) {
 969			.out_cables = 0x0001,
 970			.in_cables  = 0x0001
 971		}
 972	}
 973},
 974{
 975	/* has ID 0x0024 when not in "Advanced Driver" mode */
 976	USB_DEVICE(0x0582, 0x0023),
 977	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 978		.vendor_name = "EDIROL",
 979		.product_name = "UM-550",
 980		.ifnum = 0,
 981		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 982		.data = & (const struct snd_usb_midi_endpoint_info) {
 983			.out_cables = 0x003f,
 984			.in_cables  = 0x003f
 985		}
 986	}
 987},
 988{
 989	/*
 990	 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 991	 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 992	 * and no MIDI.
 993	 */
 994	USB_DEVICE(0x0582, 0x0025),
 995	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 996		.vendor_name = "EDIROL",
 997		.product_name = "UA-20",
 998		.ifnum = QUIRK_ANY_INTERFACE,
 999		.type = QUIRK_COMPOSITE,
1000		.data = (const struct snd_usb_audio_quirk[]) {
1001			{
1002				.ifnum = 0,
1003				.type = QUIRK_IGNORE_INTERFACE
1004			},
1005			{
1006				.ifnum = 1,
1007				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
1008				.data = & (const struct audioformat) {
1009					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
1010					.channels = 2,
1011					.iface = 1,
1012					.altsetting = 1,
1013					.altset_idx = 1,
1014					.attributes = 0,
1015					.endpoint = 0x01,
1016					.ep_attr = 0x01,
1017					.rates = SNDRV_PCM_RATE_CONTINUOUS,
1018					.rate_min = 44100,
1019					.rate_max = 44100,
1020				}
1021			},
1022			{
1023				.ifnum = 2,
1024				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
1025				.data = & (const struct audioformat) {
1026					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
1027					.channels = 2,
1028					.iface = 2,
1029					.altsetting = 1,
1030					.altset_idx = 1,
1031					.attributes = 0,
1032					.endpoint = 0x82,
1033					.ep_attr = 0x01,
1034					.rates = SNDRV_PCM_RATE_CONTINUOUS,
1035					.rate_min = 44100,
1036					.rate_max = 44100,
1037				}
1038			},
1039			{
1040				.ifnum = 3,
1041				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1042				.data = & (const struct snd_usb_midi_endpoint_info) {
1043					.out_cables = 0x0001,
1044					.in_cables  = 0x0001
1045				}
1046			},
1047			{
1048				.ifnum = -1
1049			}
1050		}
1051	}
1052},
1053{
1054	/* has ID 0x0028 when not in "Advanced Driver" mode */
1055	USB_DEVICE(0x0582, 0x0027),
1056	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1057		.vendor_name = "EDIROL",
1058		.product_name = "SD-20",
1059		.ifnum = 0,
1060		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1061		.data = & (const struct snd_usb_midi_endpoint_info) {
1062			.out_cables = 0x0003,
1063			.in_cables  = 0x0007
1064		}
1065	}
1066},
1067{
1068	/* has ID 0x002a when not in "Advanced Driver" mode */
1069	USB_DEVICE(0x0582, 0x0029),
1070	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1071		.vendor_name = "EDIROL",
1072		.product_name = "SD-80",
1073		.ifnum = 0,
1074		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1075		.data = & (const struct snd_usb_midi_endpoint_info) {
1076			.out_cables = 0x000f,
1077			.in_cables  = 0x000f
1078		}
1079	}
1080},
1081{	/*
1082	 * This quirk is for the "Advanced" modes of the Edirol UA-700.
1083	 * If the sample format switch is not in an advanced setting, the
1084	 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
1085	 * but offers only 16-bit PCM and no MIDI.
1086	 */
1087	USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
1088	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1089		.vendor_name = "EDIROL",
1090		.product_name = "UA-700",
1091		.ifnum = QUIRK_ANY_INTERFACE,
1092		.type = QUIRK_COMPOSITE,
1093		.data = (const struct snd_usb_audio_quirk[]) {
1094			{
1095				.ifnum = 1,
1096				.type = QUIRK_AUDIO_EDIROL_UAXX
1097			},
1098			{
1099				.ifnum = 2,
1100				.type = QUIRK_AUDIO_EDIROL_UAXX
1101			},
1102			{
1103				.ifnum = 3,
1104				.type = QUIRK_AUDIO_EDIROL_UAXX
1105			},
1106			{
1107				.ifnum = -1
1108			}
1109		}
1110	}
1111},
1112{
1113	/* has ID 0x002e when not in "Advanced Driver" mode */
1114	USB_DEVICE(0x0582, 0x002d),
1115	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1116		.vendor_name = "Roland",
1117		.product_name = "XV-2020",
1118		.ifnum = 0,
1119		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1120		.data = & (const struct snd_usb_midi_endpoint_info) {
1121			.out_cables = 0x0001,
1122			.in_cables  = 0x0001
1123		}
1124	}
1125},
1126{
1127	/* has ID 0x0030 when not in "Advanced Driver" mode */
1128	USB_DEVICE(0x0582, 0x002f),
1129	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1130		.vendor_name = "Roland",
1131		.product_name = "VariOS",
1132		.ifnum = 0,
1133		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1134		.data = & (const struct snd_usb_midi_endpoint_info) {
1135			.out_cables = 0x0007,
1136			.in_cables  = 0x0007
1137		}
1138	}
1139},
1140{
1141	/* has ID 0x0034 when not in "Advanced Driver" mode */
1142	USB_DEVICE(0x0582, 0x0033),
1143	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1144		.vendor_name = "EDIROL",
1145		.product_name = "PCR",
1146		.ifnum = 0,
1147		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1148		.data = & (const struct snd_usb_midi_endpoint_info) {
1149			.out_cables = 0x0003,
1150			.in_cables  = 0x0007
1151		}
1152	}
1153},
1154{
1155	/*
1156	 * Has ID 0x0038 when not in "Advanced Driver" mode;
1157	 * later revisions use IDs 0x0054 and 0x00a2.
1158	 */
1159	USB_DEVICE(0x0582, 0x0037),
1160	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1161		.vendor_name = "Roland",
1162		.product_name = "Digital Piano",
1163		.ifnum = 0,
1164		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1165		.data = & (const struct snd_usb_midi_endpoint_info) {
1166			.out_cables = 0x0001,
1167			.in_cables  = 0x0001
1168		}
1169	}
1170},
1171{
1172	/*
1173	 * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
1174	 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1175	 * and no MIDI.
1176	 */
1177	USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1178	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1179		.vendor_name = "BOSS",
1180		.product_name = "GS-10",
1181		.ifnum = QUIRK_ANY_INTERFACE,
1182		.type = QUIRK_COMPOSITE,
1183		.data = & (const struct snd_usb_audio_quirk[]) {
1184			{
1185				.ifnum = 1,
1186				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1187			},
1188			{
1189				.ifnum = 2,
1190				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1191			},
1192			{
1193				.ifnum = 3,
1194				.type = QUIRK_MIDI_STANDARD_INTERFACE
1195			},
1196			{
1197				.ifnum = -1
1198			}
1199		}
1200	}
1201},
1202{
1203	/* has ID 0x0041 when not in "Advanced Driver" mode */
1204	USB_DEVICE(0x0582, 0x0040),
1205	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1206		.vendor_name = "Roland",
1207		.product_name = "GI-20",
1208		.ifnum = 0,
1209		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1210		.data = & (const struct snd_usb_midi_endpoint_info) {
1211			.out_cables = 0x0001,
1212			.in_cables  = 0x0001
1213		}
1214	}
1215},
1216{
1217	/* has ID 0x0043 when not in "Advanced Driver" mode */
1218	USB_DEVICE(0x0582, 0x0042),
1219	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1220		.vendor_name = "Roland",
1221		.product_name = "RS-70",
1222		.ifnum = 0,
1223		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1224		.data = & (const struct snd_usb_midi_endpoint_info) {
1225			.out_cables = 0x0001,
1226			.in_cables  = 0x0001
1227		}
1228	}
1229},
1230{
1231	/* has ID 0x0049 when not in "Advanced Driver" mode */
1232	USB_DEVICE(0x0582, 0x0047),
1233	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1234		/* .vendor_name = "EDIROL", */
1235		/* .product_name = "UR-80", */
1236		.ifnum = QUIRK_ANY_INTERFACE,
1237		.type = QUIRK_COMPOSITE,
1238		.data = (const struct snd_usb_audio_quirk[]) {
1239			/* in the 96 kHz modes, only interface 1 is there */
1240			{
1241				.ifnum = 1,
1242				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1243			},
1244			{
1245				.ifnum = 2,
1246				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1247			},
1248			{
1249				.ifnum = -1
1250			}
1251		}
1252	}
1253},
1254{
1255	/* has ID 0x004a when not in "Advanced Driver" mode */
1256	USB_DEVICE(0x0582, 0x0048),
1257	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1258		/* .vendor_name = "EDIROL", */
1259		/* .product_name = "UR-80", */
1260		.ifnum = 0,
1261		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1262		.data = & (const struct snd_usb_midi_endpoint_info) {
1263			.out_cables = 0x0003,
1264			.in_cables  = 0x0007
1265		}
1266	}
1267},
1268{
1269	/* has ID 0x004e when not in "Advanced Driver" mode */
1270	USB_DEVICE(0x0582, 0x004c),
1271	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1272		.vendor_name = "EDIROL",
1273		.product_name = "PCR-A",
1274		.ifnum = QUIRK_ANY_INTERFACE,
1275		.type = QUIRK_COMPOSITE,
1276		.data = (const struct snd_usb_audio_quirk[]) {
1277			{
1278				.ifnum = 1,
1279				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1280			},
1281			{
1282				.ifnum = 2,
1283				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1284			},
1285			{
1286				.ifnum = -1
1287			}
1288		}
1289	}
1290},
1291{
1292	/* has ID 0x004f when not in "Advanced Driver" mode */
1293	USB_DEVICE(0x0582, 0x004d),
1294	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1295		.vendor_name = "EDIROL",
1296		.product_name = "PCR-A",
1297		.ifnum = 0,
1298		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1299		.data = & (const struct snd_usb_midi_endpoint_info) {
1300			.out_cables = 0x0003,
1301			.in_cables  = 0x0007
1302		}
1303	}
1304},
1305{
1306	/*
1307	 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1308	 * is standard compliant, but has only 16-bit PCM.
1309	 */
1310	USB_DEVICE(0x0582, 0x0050),
1311	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1312		.vendor_name = "EDIROL",
1313		.product_name = "UA-3FX",
1314		.ifnum = QUIRK_ANY_INTERFACE,
1315		.type = QUIRK_COMPOSITE,
1316		.data = (const struct snd_usb_audio_quirk[]) {
1317			{
1318				.ifnum = 1,
1319				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1320			},
1321			{
1322				.ifnum = 2,
1323				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1324			},
1325			{
1326				.ifnum = -1
1327			}
1328		}
1329	}
1330},
1331{
1332	USB_DEVICE(0x0582, 0x0052),
1333	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1334		.vendor_name = "EDIROL",
1335		.product_name = "UM-1SX",
1336		.ifnum = 0,
1337		.type = QUIRK_MIDI_STANDARD_INTERFACE
1338	}
1339},
1340{
1341	USB_DEVICE(0x0582, 0x0060),
1342	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1343		.vendor_name = "Roland",
1344		.product_name = "EXR Series",
1345		.ifnum = 0,
1346		.type = QUIRK_MIDI_STANDARD_INTERFACE
1347	}
1348},
1349{
1350	/* has ID 0x0066 when not in "Advanced Driver" mode */
1351	USB_DEVICE(0x0582, 0x0064),
1352	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1353		/* .vendor_name = "EDIROL", */
1354		/* .product_name = "PCR-1", */
1355		.ifnum = QUIRK_ANY_INTERFACE,
1356		.type = QUIRK_COMPOSITE,
1357		.data = (const struct snd_usb_audio_quirk[]) {
1358			{
1359				.ifnum = 1,
1360				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1361			},
1362			{
1363				.ifnum = 2,
1364				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1365			},
1366			{
1367				.ifnum = -1
1368			}
1369		}
1370	}
1371},
1372{
1373	/* has ID 0x0067 when not in "Advanced Driver" mode */
1374	USB_DEVICE(0x0582, 0x0065),
1375	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1376		/* .vendor_name = "EDIROL", */
1377		/* .product_name = "PCR-1", */
1378		.ifnum = 0,
1379		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1380		.data = & (const struct snd_usb_midi_endpoint_info) {
1381			.out_cables = 0x0001,
1382			.in_cables  = 0x0003
1383		}
1384	}
1385},
1386{
1387	/* has ID 0x006e when not in "Advanced Driver" mode */
1388	USB_DEVICE(0x0582, 0x006d),
1389	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1390		.vendor_name = "Roland",
1391		.product_name = "FANTOM-X",
1392		.ifnum = 0,
1393		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1394		.data = & (const struct snd_usb_midi_endpoint_info) {
1395			.out_cables = 0x0001,
1396			.in_cables  = 0x0001
1397		}
1398	}
1399},
1400{	/*
1401	 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1402	 * If the switch is not in an advanced setting, the UA-25 has
1403	 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1404	 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1405	 */
1406	USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1407	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1408		.vendor_name = "EDIROL",
1409		.product_name = "UA-25",
1410		.ifnum = QUIRK_ANY_INTERFACE,
1411		.type = QUIRK_COMPOSITE,
1412		.data = (const struct snd_usb_audio_quirk[]) {
1413			{
1414				.ifnum = 0,
1415				.type = QUIRK_AUDIO_EDIROL_UAXX
1416			},
1417			{
1418				.ifnum = 1,
1419				.type = QUIRK_AUDIO_EDIROL_UAXX
1420			},
1421			{
1422				.ifnum = 2,
1423				.type = QUIRK_AUDIO_EDIROL_UAXX
1424			},
1425			{
1426				.ifnum = -1
1427			}
1428		}
1429	}
1430},
1431{
1432	/* has ID 0x0076 when not in "Advanced Driver" mode */
1433	USB_DEVICE(0x0582, 0x0075),
1434	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1435		.vendor_name = "BOSS",
1436		.product_name = "DR-880",
1437		.ifnum = 0,
1438		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1439		.data = & (const struct snd_usb_midi_endpoint_info) {
1440			.out_cables = 0x0001,
1441			.in_cables  = 0x0001
1442		}
1443	}
1444},
1445{
1446	/* has ID 0x007b when not in "Advanced Driver" mode */
1447	USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1448	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1449		.vendor_name = "Roland",
1450		/* "RD" or "RD-700SX"? */
1451		.ifnum = 0,
1452		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1453		.data = & (const struct snd_usb_midi_endpoint_info) {
1454			.out_cables = 0x0003,
1455			.in_cables  = 0x0003
1456		}
1457	}
1458},
1459{
1460	/* has ID 0x0081 when not in "Advanced Driver" mode */
1461	USB_DEVICE(0x0582, 0x0080),
1462	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1463		.vendor_name = "Roland",
1464		.product_name = "G-70",
1465		.ifnum = 0,
1466		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1467		.data = & (const struct snd_usb_midi_endpoint_info) {
1468			.out_cables = 0x0001,
1469			.in_cables  = 0x0001
1470		}
1471	}
1472},
1473{
1474	/* has ID 0x008c when not in "Advanced Driver" mode */
1475	USB_DEVICE(0x0582, 0x008b),
1476	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1477		.vendor_name = "EDIROL",
1478		.product_name = "PC-50",
1479		.ifnum = 0,
1480		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1481		.data = & (const struct snd_usb_midi_endpoint_info) {
1482			.out_cables = 0x0001,
1483			.in_cables  = 0x0001
1484		}
1485	}
1486},
1487{
1488	/*
1489	 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1490	 * is standard compliant, but has only 16-bit PCM and no MIDI.
1491	 */
1492	USB_DEVICE(0x0582, 0x00a3),
1493	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1494		.vendor_name = "EDIROL",
1495		.product_name = "UA-4FX",
1496		.ifnum = QUIRK_ANY_INTERFACE,
1497		.type = QUIRK_COMPOSITE,
1498		.data = (const struct snd_usb_audio_quirk[]) {
1499			{
1500				.ifnum = 0,
1501				.type = QUIRK_AUDIO_EDIROL_UAXX
1502			},
1503			{
1504				.ifnum = 1,
1505				.type = QUIRK_AUDIO_EDIROL_UAXX
1506			},
1507			{
1508				.ifnum = 2,
1509				.type = QUIRK_AUDIO_EDIROL_UAXX
1510			},
1511			{
1512				.ifnum = -1
1513			}
1514		}
1515	}
1516},
1517{
1518	/* Edirol M-16DX */
1519	USB_DEVICE(0x0582, 0x00c4),
1520	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1521		.ifnum = QUIRK_ANY_INTERFACE,
1522		.type = QUIRK_COMPOSITE,
1523		.data = (const struct snd_usb_audio_quirk[]) {
1524			{
1525				.ifnum = 0,
1526				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1527			},
1528			{
1529				.ifnum = 1,
1530				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1531			},
1532			{
1533				.ifnum = 2,
1534				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1535				.data = & (const struct snd_usb_midi_endpoint_info) {
1536					.out_cables = 0x0001,
1537					.in_cables  = 0x0001
1538				}
1539			},
1540			{
1541				.ifnum = -1
1542			}
1543		}
1544	}
1545},
1546{
1547	/* Advanced modes of the Edirol UA-25EX.
1548	 * For the standard mode, UA-25EX has ID 0582:00e7, which
1549	 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1550	 */
1551	USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1552	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1553		.vendor_name = "EDIROL",
1554		.product_name = "UA-25EX",
1555		.ifnum = QUIRK_ANY_INTERFACE,
1556		.type = QUIRK_COMPOSITE,
1557		.data = (const struct snd_usb_audio_quirk[]) {
1558			{
1559				.ifnum = 0,
1560				.type = QUIRK_AUDIO_EDIROL_UAXX
1561			},
1562			{
1563				.ifnum = 1,
1564				.type = QUIRK_AUDIO_EDIROL_UAXX
1565			},
1566			{
1567				.ifnum = 2,
1568				.type = QUIRK_AUDIO_EDIROL_UAXX
1569			},
1570			{
1571				.ifnum = -1
1572			}
1573		}
1574	}
1575},
1576{
1577	/* Edirol UM-3G */
1578	USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1579	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1580		.ifnum = 0,
1581		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1582		.data = & (const struct snd_usb_midi_endpoint_info) {
1583			.out_cables = 0x0007,
1584			.in_cables  = 0x0007
1585		}
1586	}
1587},
1588{
1589	/* BOSS ME-25 */
1590	USB_DEVICE(0x0582, 0x0113),
1591	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1592		.ifnum = QUIRK_ANY_INTERFACE,
1593		.type = QUIRK_COMPOSITE,
1594		.data = (const struct snd_usb_audio_quirk[]) {
1595			{
1596				.ifnum = 0,
1597				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1598			},
1599			{
1600				.ifnum = 1,
1601				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1602			},
1603			{
1604				.ifnum = 2,
1605				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1606				.data = & (const struct snd_usb_midi_endpoint_info) {
1607					.out_cables = 0x0001,
1608					.in_cables  = 0x0001
1609				}
1610			},
1611			{
1612				.ifnum = -1
1613			}
1614		}
1615	}
1616},
1617{
1618	/* only 44.1 kHz works at the moment */
1619	USB_DEVICE(0x0582, 0x0120),
1620	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1621		/* .vendor_name = "Roland", */
1622		/* .product_name = "OCTO-CAPTURE", */
1623		.ifnum = QUIRK_ANY_INTERFACE,
1624		.type = QUIRK_COMPOSITE,
1625		.data = (const struct snd_usb_audio_quirk[]) {
1626			{
1627				.ifnum = 0,
1628				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
1629				.data = & (const struct audioformat) {
1630					.formats = SNDRV_PCM_FMTBIT_S32_LE,
1631					.channels = 10,
1632					.iface = 0,
1633					.altsetting = 1,
1634					.altset_idx = 1,
1635					.endpoint = 0x05,
1636					.ep_attr = 0x05,
1637					.rates = SNDRV_PCM_RATE_44100,
1638					.rate_min = 44100,
1639					.rate_max = 44100,
1640					.nr_rates = 1,
1641					.rate_table = (unsigned int[]) { 44100 }
1642				}
1643			},
1644			{
1645				.ifnum = 1,
1646				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
1647				.data = & (const struct audioformat) {
1648					.formats = SNDRV_PCM_FMTBIT_S32_LE,
1649					.channels = 12,
1650					.iface = 1,
1651					.altsetting = 1,
1652					.altset_idx = 1,
1653					.endpoint = 0x85,
1654					.ep_attr = 0x25,
1655					.rates = SNDRV_PCM_RATE_44100,
1656					.rate_min = 44100,
1657					.rate_max = 44100,
1658					.nr_rates = 1,
1659					.rate_table = (unsigned int[]) { 44100 }
1660				}
1661			},
1662			{
1663				.ifnum = 2,
1664				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1665				.data = & (const struct snd_usb_midi_endpoint_info) {
1666					.out_cables = 0x0001,
1667					.in_cables  = 0x0001
1668				}
1669			},
1670			{
1671				.ifnum = 3,
1672				.type = QUIRK_IGNORE_INTERFACE
1673			},
1674			{
1675				.ifnum = 4,
1676				.type = QUIRK_IGNORE_INTERFACE
1677			},
1678			{
1679				.ifnum = -1
1680			}
1681		}
1682	}
1683},
1684{
1685	/* only 44.1 kHz works at the moment */
1686	USB_DEVICE(0x0582, 0x012f),
1687	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1688		/* .vendor_name = "Roland", */
1689		/* .product_name = "QUAD-CAPTURE", */
1690		.ifnum = QUIRK_ANY_INTERFACE,
1691		.type = QUIRK_COMPOSITE,
1692		.data = (const struct snd_usb_audio_quirk[]) {
1693			{
1694				.ifnum = 0,
1695				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
1696				.data = & (const struct audioformat) {
1697					.formats = SNDRV_PCM_FMTBIT_S32_LE,
1698					.channels = 4,
1699					.iface = 0,
1700					.altsetting = 1,
1701					.altset_idx = 1,
1702					.endpoint = 0x05,
1703					.ep_attr = 0x05,
1704					.rates = SNDRV_PCM_RATE_44100,
1705					.rate_min = 44100,
1706					.rate_max = 44100,
1707					.nr_rates = 1,
1708					.rate_table = (unsigned int[]) { 44100 }
1709				}
1710			},
1711			{
1712				.ifnum = 1,
1713				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
1714				.data = & (const struct audioformat) {
1715					.formats = SNDRV_PCM_FMTBIT_S32_LE,
1716					.channels = 6,
1717					.iface = 1,
1718					.altsetting = 1,
1719					.altset_idx = 1,
1720					.endpoint = 0x85,
1721					.ep_attr = 0x25,
1722					.rates = SNDRV_PCM_RATE_44100,
1723					.rate_min = 44100,
1724					.rate_max = 44100,
1725					.nr_rates = 1,
1726					.rate_table = (unsigned int[]) { 44100 }
1727				}
1728			},
1729			{
1730				.ifnum = 2,
1731				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1732				.data = & (const struct snd_usb_midi_endpoint_info) {
1733					.out_cables = 0x0001,
1734					.in_cables  = 0x0001
1735				}
1736			},
1737			{
1738				.ifnum = 3,
1739				.type = QUIRK_IGNORE_INTERFACE
1740			},
1741			{
1742				.ifnum = 4,
1743				.type = QUIRK_IGNORE_INTERFACE
1744			},
1745			{
1746				.ifnum = -1
1747			}
1748		}
1749	}
1750},
1751{
1752	USB_DEVICE(0x0582, 0x0159),
1753	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1754		/* .vendor_name = "Roland", */
1755		/* .product_name = "UA-22", */
1756		.ifnum = QUIRK_ANY_INTERFACE,
1757		.type = QUIRK_COMPOSITE,
1758		.data = (const struct snd_usb_audio_quirk[]) {
1759			{
1760				.ifnum = 0,
1761				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1762			},
1763			{
1764				.ifnum = 1,
1765				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1766			},
1767			{
1768				.ifnum = 2,
1769				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1770				.data = & (const struct snd_usb_midi_endpoint_info) {
1771					.out_cables = 0x0001,
1772					.in_cables = 0x0001
1773				}
1774			},
1775			{
1776				.ifnum = -1
1777			}
1778		}
1779	}
1780},
1781/* this catches most recent vendor-specific Roland devices */
1782{
1783	.match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1784	               USB_DEVICE_ID_MATCH_INT_CLASS,
1785	.idVendor = 0x0582,
1786	.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1787	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1788		.ifnum = QUIRK_ANY_INTERFACE,
1789		.type = QUIRK_AUTODETECT
1790	}
1791},
1792
1793/* Guillemot devices */
1794{
1795	/*
1796	 * This is for the "Windows Edition" where the external MIDI ports are
1797	 * the only MIDI ports; the control data is reported through HID
1798	 * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1799	 * compliant USB MIDI ports for external MIDI and controls.
1800	 */
1801	USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1802	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1803		.vendor_name = "Hercules",
1804		.product_name = "DJ Console (WE)",
1805		.ifnum = 4,
1806		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1807		.data = & (const struct snd_usb_midi_endpoint_info) {
1808			.out_cables = 0x0001,
1809			.in_cables = 0x0001
1810		}
1811	}
1812},
1813
1814/* Midiman/M-Audio devices */
1815{
1816	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1817	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1818		.vendor_name = "M-Audio",
1819		.product_name = "MidiSport 2x2",
1820		.ifnum = QUIRK_ANY_INTERFACE,
1821		.type = QUIRK_MIDI_MIDIMAN,
1822		.data = & (const struct snd_usb_midi_endpoint_info) {
1823			.out_cables = 0x0003,
1824			.in_cables  = 0x0003
1825		}
1826	}
1827},
1828{
1829	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1830	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1831		.vendor_name = "M-Audio",
1832		.product_name = "MidiSport 1x1",
1833		.ifnum = QUIRK_ANY_INTERFACE,
1834		.type = QUIRK_MIDI_MIDIMAN,
1835		.data = & (const struct snd_usb_midi_endpoint_info) {
1836			.out_cables = 0x0001,
1837			.in_cables  = 0x0001
1838		}
1839	}
1840},
1841{
1842	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1843	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1844		.vendor_name = "M-Audio",
1845		.product_name = "Keystation",
1846		.ifnum = QUIRK_ANY_INTERFACE,
1847		.type = QUIRK_MIDI_MIDIMAN,
1848		.data = & (const struct snd_usb_midi_endpoint_info) {
1849			.out_cables = 0x0001,
1850			.in_cables  = 0x0001
1851		}
1852	}
1853},
1854{
1855	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1856	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1857		.vendor_name = "M-Audio",
1858		.product_name = "MidiSport 4x4",
1859		.ifnum = QUIRK_ANY_INTERFACE,
1860		.type = QUIRK_MIDI_MIDIMAN,
1861		.data = & (const struct snd_usb_midi_endpoint_info) {
1862			.out_cables = 0x000f,
1863			.in_cables  = 0x000f
1864		}
1865	}
1866},
1867{
1868	/*
1869	 * For hardware revision 1.05; in the later revisions (1.10 and
1870	 * 1.21), 0x1031 is the ID for the device without firmware.
1871	 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1872	 */
1873	USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1874	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1875		.vendor_name = "M-Audio",
1876		.product_name = "MidiSport 8x8",
1877		.ifnum = QUIRK_ANY_INTERFACE,
1878		.type = QUIRK_MIDI_MIDIMAN,
1879		.data = & (const struct snd_usb_midi_endpoint_info) {
1880			.out_cables = 0x01ff,
1881			.in_cables  = 0x01ff
1882		}
1883	}
1884},
1885{
1886	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1887	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1888		.vendor_name = "M-Audio",
1889		.product_name = "MidiSport 8x8",
1890		.ifnum = QUIRK_ANY_INTERFACE,
1891		.type = QUIRK_MIDI_MIDIMAN,
1892		.data = & (const struct snd_usb_midi_endpoint_info) {
1893			.out_cables = 0x01ff,
1894			.in_cables  = 0x01ff
1895		}
1896	}
1897},
1898{
1899	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1900	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1901		.vendor_name = "M-Audio",
1902		.product_name = "MidiSport 2x4",
1903		.ifnum = QUIRK_ANY_INTERFACE,
1904		.type = QUIRK_MIDI_MIDIMAN,
1905		.data = & (const struct snd_usb_midi_endpoint_info) {
1906			.out_cables = 0x000f,
1907			.in_cables  = 0x0003
1908		}
1909	}
1910},
1911{
1912	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1913	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1914		.vendor_name = "M-Audio",
1915		.product_name = "Quattro",
1916		.ifnum = QUIRK_ANY_INTERFACE,
1917		.type = QUIRK_COMPOSITE,
1918		.data = & (const struct snd_usb_audio_quirk[]) {
1919			/*
1920			 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1921			 * and share endpoints with the other interfaces.
1922			 * Ignore them.  The other interfaces can do 24 bits,
1923			 * but captured samples are big-endian (see usbaudio.c).
1924			 */
1925			{
1926				.ifnum = 0,
1927				.type = QUIRK_IGNORE_INTERFACE
1928			},
1929			{
1930				.ifnum = 1,
1931				.type = QUIRK_IGNORE_INTERFACE
1932			},
1933			{
1934				.ifnum = 2,
1935				.type = QUIRK_IGNORE_INTERFACE
1936			},
1937			{
1938				.ifnum = 3,
1939				.type = QUIRK_IGNORE_INTERFACE
1940			},
1941			{
1942				.ifnum = 4,
1943				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1944			},
1945			{
1946				.ifnum = 5,
1947				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1948			},
1949			{
1950				.ifnum = 6,
1951				.type = QUIRK_IGNORE_INTERFACE
1952			},
1953			{
1954				.ifnum = 7,
1955				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1956			},
1957			{
1958				.ifnum = 8,
1959				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1960			},
1961			{
1962				.ifnum = 9,
1963				.type = QUIRK_MIDI_MIDIMAN,
1964				.data = & (const struct snd_usb_midi_endpoint_info) {
1965					.out_cables = 0x0001,
1966					.in_cables  = 0x0001
1967				}
1968			},
1969			{
1970				.ifnum = -1
1971			}
1972		}
1973	}
1974},
1975{
1976	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1977	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1978		.vendor_name = "M-Audio",
1979		.product_name = "AudioPhile",
1980		.ifnum = 6,
1981		.type = QUIRK_MIDI_MIDIMAN,
1982		.data = & (const struct snd_usb_midi_endpoint_info) {
1983			.out_cables = 0x0001,
1984			.in_cables  = 0x0001
1985		}
1986	}
1987},
1988{
1989	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1990	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1991		.vendor_name = "M-Audio",
1992		.product_name = "Ozone",
1993		.ifnum = 3,
1994		.type = QUIRK_MIDI_MIDIMAN,
1995		.data = & (const struct snd_usb_midi_endpoint_info) {
1996			.out_cables = 0x0001,
1997			.in_cables  = 0x0001
1998		}
1999	}
2000},
2001{
2002	USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
2003	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2004		.vendor_name = "M-Audio",
2005		.product_name = "OmniStudio",
2006		.ifnum = QUIRK_ANY_INTERFACE,
2007		.type = QUIRK_COMPOSITE,
2008		.data = & (const struct snd_usb_audio_quirk[]) {
2009			{
2010				.ifnum = 0,
2011				.type = QUIRK_IGNORE_INTERFACE
2012			},
2013			{
2014				.ifnum = 1,
2015				.type = QUIRK_IGNORE_INTERFACE
2016			},
2017			{
2018				.ifnum = 2,
2019				.type = QUIRK_IGNORE_INTERFACE
2020			},
2021			{
2022				.ifnum = 3,
2023				.type = QUIRK_IGNORE_INTERFACE
2024			},
2025			{
2026				.ifnum = 4,
2027				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2028			},
2029			{
2030				.ifnum = 5,
2031				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2032			},
2033			{
2034				.ifnum = 6,
2035				.type = QUIRK_IGNORE_INTERFACE
2036			},
2037			{
2038				.ifnum = 7,
2039				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2040			},
2041			{
2042				.ifnum = 8,
2043				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2044			},
2045			{
2046				.ifnum = 9,
2047				.type = QUIRK_MIDI_MIDIMAN,
2048				.data = & (const struct snd_usb_midi_endpoint_info) {
2049					.out_cables = 0x0001,
2050					.in_cables  = 0x0001
2051				}
2052			},
2053			{
2054				.ifnum = -1
2055			}
2056		}
2057	}
2058},
2059{
2060	USB_DEVICE(0x0763, 0x2019),
2061	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2062		/* .vendor_name = "M-Audio", */
2063		/* .product_name = "Ozone Academic", */
2064		.ifnum = QUIRK_ANY_INTERFACE,
2065		.type = QUIRK_COMPOSITE,
2066		.data = & (const struct snd_usb_audio_quirk[]) {
2067			{
2068				.ifnum = 0,
2069				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2070			},
2071			{
2072				.ifnum = 1,
2073				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2074			},
2075			{
2076				.ifnum = 2,
2077				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2078			},
2079			{
2080				.ifnum = 3,
2081				.type = QUIRK_MIDI_MIDIMAN,
2082				.data = & (const struct snd_usb_midi_endpoint_info) {
2083					.out_cables = 0x0001,
2084					.in_cables  = 0x0001
2085				}
2086			},
2087			{
2088				.ifnum = -1
2089			}
2090		}
2091	}
2092},
2093{
2094	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2095	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2096		/* .vendor_name = "M-Audio", */
2097		/* .product_name = "Fast Track C400", */
2098		.ifnum = QUIRK_ANY_INTERFACE,
2099		.type = QUIRK_COMPOSITE,
2100		.data = &(const struct snd_usb_audio_quirk[]) {
2101			{
2102				.ifnum = 1,
2103				.type = QUIRK_AUDIO_STANDARD_MIXER,
2104			},
2105			/* Playback */
2106			{
2107				.ifnum = 2,
2108				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2109				.data = &(const struct audioformat) {
2110					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2111					.channels = 6,
2112					.iface = 2,
2113					.altsetting = 1,
2114					.altset_idx = 1,
2115					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2116					.endpoint = 0x01,
2117					.ep_attr = 0x09,
2118					.rates = SNDRV_PCM_RATE_44100 |
2119						 SNDRV_PCM_RATE_48000 |
2120						 SNDRV_PCM_RATE_88200 |
2121						 SNDRV_PCM_RATE_96000,
2122					.rate_min = 44100,
2123					.rate_max = 96000,
2124					.nr_rates = 4,
2125					.rate_table = (unsigned int[]) {
2126							44100, 48000, 88200, 96000
2127					},
2128					.clock = 0x80,
2129				}
2130			},
2131			/* Capture */
2132			{
2133				.ifnum = 3,
2134				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2135				.data = &(const struct audioformat) {
2136					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2137					.channels = 4,
2138					.iface = 3,
2139					.altsetting = 1,
2140					.altset_idx = 1,
2141					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2142					.endpoint = 0x81,
2143					.ep_attr = 0x05,
2144					.rates = SNDRV_PCM_RATE_44100 |
2145						 SNDRV_PCM_RATE_48000 |
2146						 SNDRV_PCM_RATE_88200 |
2147						 SNDRV_PCM_RATE_96000,
2148					.rate_min = 44100,
2149					.rate_max = 96000,
2150					.nr_rates = 4,
2151					.rate_table = (unsigned int[]) {
2152						44100, 48000, 88200, 96000
2153					},
2154					.clock = 0x80,
2155				}
2156			},
2157			/* MIDI */
2158			{
2159				.ifnum = -1 /* Interface = 4 */
2160			}
2161		}
2162	}
2163},
2164{
2165	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2166	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2167		/* .vendor_name = "M-Audio", */
2168		/* .product_name = "Fast Track C600", */
2169		.ifnum = QUIRK_ANY_INTERFACE,
2170		.type = QUIRK_COMPOSITE,
2171		.data = &(const struct snd_usb_audio_quirk[]) {
2172			{
2173				.ifnum = 1,
2174				.type = QUIRK_AUDIO_STANDARD_MIXER,
2175			},
2176			/* Playback */
2177			{
2178				.ifnum = 2,
2179				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2180				.data = &(const struct audioformat) {
2181					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2182					.channels = 8,
2183					.iface = 2,
2184					.altsetting = 1,
2185					.altset_idx = 1,
2186					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2187					.endpoint = 0x01,
2188					.ep_attr = 0x09,
2189					.rates = SNDRV_PCM_RATE_44100 |
2190						 SNDRV_PCM_RATE_48000 |
2191						 SNDRV_PCM_RATE_88200 |
2192						 SNDRV_PCM_RATE_96000,
2193					.rate_min = 44100,
2194					.rate_max = 96000,
2195					.nr_rates = 4,
2196					.rate_table = (unsigned int[]) {
2197							44100, 48000, 88200, 96000
2198					},
2199					.clock = 0x80,
2200				}
2201			},
2202			/* Capture */
2203			{
2204				.ifnum = 3,
2205				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2206				.data = &(const struct audioformat) {
2207					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2208					.channels = 6,
2209					.iface = 3,
2210					.altsetting = 1,
2211					.altset_idx = 1,
2212					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2213					.endpoint = 0x81,
2214					.ep_attr = 0x05,
2215					.rates = SNDRV_PCM_RATE_44100 |
2216						 SNDRV_PCM_RATE_48000 |
2217						 SNDRV_PCM_RATE_88200 |
2218						 SNDRV_PCM_RATE_96000,
2219					.rate_min = 44100,
2220					.rate_max = 96000,
2221					.nr_rates = 4,
2222					.rate_table = (unsigned int[]) {
2223						44100, 48000, 88200, 96000
2224					},
2225					.clock = 0x80,
2226				}
2227			},
2228			/* MIDI */
2229			{
2230				.ifnum = -1 /* Interface = 4 */
2231			}
2232		}
2233	}
2234},
2235{
2236	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2237	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2238		/* .vendor_name = "M-Audio", */
2239		/* .product_name = "Fast Track Ultra", */
2240		.ifnum = QUIRK_ANY_INTERFACE,
2241		.type = QUIRK_COMPOSITE,
2242		.data = & (const struct snd_usb_audio_quirk[]) {
2243			{
2244				.ifnum = 0,
2245				.type = QUIRK_AUDIO_STANDARD_MIXER,
2246			},
2247			{
2248				.ifnum = 1,
2249				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2250				.data = & (const struct audioformat) {
2251					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2252					.channels = 8,
2253					.iface = 1,
2254					.altsetting = 1,
2255					.altset_idx = 1,
2256					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2257					.endpoint = 0x01,
2258					.ep_attr = 0x09,
2259					.rates = SNDRV_PCM_RATE_44100 |
2260						 SNDRV_PCM_RATE_48000 |
2261						 SNDRV_PCM_RATE_88200 |
2262						 SNDRV_PCM_RATE_96000,
2263					.rate_min = 44100,
2264					.rate_max = 96000,
2265					.nr_rates = 4,
2266					.rate_table = (unsigned int[]) {
2267						44100, 48000, 88200, 96000
2268					}
2269				}
2270			},
2271			{
2272				.ifnum = 2,
2273				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2274				.data = & (const struct audioformat) {
2275					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2276					.channels = 8,
2277					.iface = 2,
2278					.altsetting = 1,
2279					.altset_idx = 1,
2280					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2281					.endpoint = 0x81,
2282					.ep_attr = 0x05,
2283					.rates = SNDRV_PCM_RATE_44100 |
2284						 SNDRV_PCM_RATE_48000 |
2285						 SNDRV_PCM_RATE_88200 |
2286						 SNDRV_PCM_RATE_96000,
2287					.rate_min = 44100,
2288					.rate_max = 96000,
2289					.nr_rates = 4,
2290					.rate_table = (unsigned int[]) {
2291						44100, 48000, 88200, 96000
2292					}
2293				}
2294			},
2295			/* interface 3 (MIDI) is standard compliant */
2296			{
2297				.ifnum = -1
2298			}
2299		}
2300	}
2301},
2302{
2303	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2304	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2305		/* .vendor_name = "M-Audio", */
2306		/* .product_name = "Fast Track Ultra 8R", */
2307		.ifnum = QUIRK_ANY_INTERFACE,
2308		.type = QUIRK_COMPOSITE,
2309		.data = & (const struct snd_usb_audio_quirk[]) {
2310			{
2311				.ifnum = 0,
2312				.type = QUIRK_AUDIO_STANDARD_MIXER,
2313			},
2314			{
2315				.ifnum = 1,
2316				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2317				.data = & (const struct audioformat) {
2318					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2319					.channels = 8,
2320					.iface = 1,
2321					.altsetting = 1,
2322					.altset_idx = 1,
2323					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2324					.endpoint = 0x01,
2325					.ep_attr = 0x09,
2326					.rates = SNDRV_PCM_RATE_44100 |
2327						 SNDRV_PCM_RATE_48000 |
2328						 SNDRV_PCM_RATE_88200 |
2329						 SNDRV_PCM_RATE_96000,
2330					.rate_min = 44100,
2331					.rate_max = 96000,
2332					.nr_rates = 4,
2333					.rate_table = (unsigned int[]) {
2334							44100, 48000, 88200, 96000
2335					}
2336				}
2337			},
2338			{
2339				.ifnum = 2,
2340				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2341				.data = & (const struct audioformat) {
2342					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2343					.channels = 8,
2344					.iface = 2,
2345					.altsetting = 1,
2346					.altset_idx = 1,
2347					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2348					.endpoint = 0x81,
2349					.ep_attr = 0x05,
2350					.rates = SNDRV_PCM_RATE_44100 |
2351						 SNDRV_PCM_RATE_48000 |
2352						 SNDRV_PCM_RATE_88200 |
2353						 SNDRV_PCM_RATE_96000,
2354					.rate_min = 44100,
2355					.rate_max = 96000,
2356					.nr_rates = 4,
2357					.rate_table = (unsigned int[]) {
2358						44100, 48000, 88200, 96000
2359					}
2360				}
2361			},
2362			/* interface 3 (MIDI) is standard compliant */
2363			{
2364				.ifnum = -1
2365			}
2366		}
2367	}
2368},
2369
2370/* Casio devices */
2371{
2372	USB_DEVICE(0x07cf, 0x6801),
2373	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2374		.vendor_name = "Casio",
2375		.product_name = "PL-40R",
2376		.ifnum = 0,
2377		.type = QUIRK_MIDI_YAMAHA
2378	}
2379},
2380{
2381	/* this ID is used by several devices without a product ID */
2382	USB_DEVICE(0x07cf, 0x6802),
2383	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2384		.vendor_name = "Casio",
2385		.product_name = "Keyboard",
2386		.ifnum = 0,
2387		.type = QUIRK_MIDI_YAMAHA
2388	}
2389},
2390
2391/* Mark of the Unicorn devices */
2392{
2393	/* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2394	.match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2395		       USB_DEVICE_ID_MATCH_PRODUCT |
2396		       USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2397	.idVendor = 0x07fd,
2398	.idProduct = 0x0001,
2399	.bDeviceSubClass = 2,
2400	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2401		.vendor_name = "MOTU",
2402		.product_name = "Fastlane",
2403		.ifnum = QUIRK_ANY_INTERFACE,
2404		.type = QUIRK_COMPOSITE,
2405		.data = & (const struct snd_usb_audio_quirk[]) {
2406			{
2407				.ifnum = 0,
2408				.type = QUIRK_MIDI_RAW_BYTES
2409			},
2410			{
2411				.ifnum = 1,
2412				.type = QUIRK_IGNORE_INTERFACE
2413			},
2414			{
2415				.ifnum = -1
2416			}
2417		}
2418	}
2419},
2420
2421/* Emagic devices */
2422{
2423	USB_DEVICE(0x086a, 0x0001),
2424	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2425		.vendor_name = "Emagic",
2426		.product_name = "Unitor8",
2427		.ifnum = 2,
2428		.type = QUIRK_MIDI_EMAGIC,
2429		.data = & (const struct snd_usb_midi_endpoint_info) {
2430			.out_cables = 0x80ff,
2431			.in_cables  = 0x80ff
2432		}
2433	}
2434},
2435{
2436	USB_DEVICE(0x086a, 0x0002),
2437	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2438		.vendor_name = "Emagic",
2439		/* .product_name = "AMT8", */
2440		.ifnum = 2,
2441		.type = QUIRK_MIDI_EMAGIC,
2442		.data = & (const struct snd_usb_midi_endpoint_info) {
2443			.out_cables = 0x80ff,
2444			.in_cables  = 0x80ff
2445		}
2446	}
2447},
2448{
2449	USB_DEVICE(0x086a, 0x0003),
2450	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2451		.vendor_name = "Emagic",
2452		/* .product_name = "MT4", */
2453		.ifnum = 2,
2454		.type = QUIRK_MIDI_EMAGIC,
2455		.data = & (const struct snd_usb_midi_endpoint_info) {
2456			.out_cables = 0x800f,
2457			.in_cables  = 0x8003
2458		}
2459	}
2460},
2461
2462/* KORG devices */
2463{
2464	USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2465	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2466		.vendor_name = "KORG, Inc.",
2467		/* .product_name = "PANDORA PX5D", */
2468		.ifnum = 3,
2469		.type = QUIRK_MIDI_STANDARD_INTERFACE,
2470	}
2471},
2472
2473{
2474	USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2475	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2476		.vendor_name = "KORG, Inc.",
2477		/* .product_name = "ToneLab ST", */
2478		.ifnum = 3,
2479		.type = QUIRK_MIDI_STANDARD_INTERFACE,
2480	}
2481},
2482
2483/* AKAI devices */
2484{
2485	USB_DEVICE(0x09e8, 0x0062),
2486	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2487		.vendor_name = "AKAI",
2488		.product_name = "MPD16",
2489		.ifnum = 0,
2490		.type = QUIRK_MIDI_AKAI,
2491	}
2492},
2493
2494{
2495	/* Akai MPC Element */
2496	USB_DEVICE(0x09e8, 0x0021),
2497	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2498		.ifnum = QUIRK_ANY_INTERFACE,
2499		.type = QUIRK_COMPOSITE,
2500		.data = & (const struct snd_usb_audio_quirk[]) {
2501			{
2502				.ifnum = 0,
2503				.type = QUIRK_IGNORE_INTERFACE
2504			},
2505			{
2506				.ifnum = 1,
2507				.type = QUIRK_MIDI_STANDARD_INTERFACE
2508			},
2509			{
2510				.ifnum = -1
2511			}
2512		}
2513	}
2514},
2515
2516/* Steinberg devices */
2517{
2518	/* Steinberg MI2 */
2519	USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2520	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2521		.ifnum = QUIRK_ANY_INTERFACE,
2522		.type = QUIRK_COMPOSITE,
2523		.data = & (const struct snd_usb_audio_quirk[]) {
2524			{
2525				.ifnum = 0,
2526				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2527			},
2528			{
2529				.ifnum = 1,
2530				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2531			},
2532			{
2533				.ifnum = 2,
2534				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2535			},
2536			{
2537				.ifnum = 3,
2538				.type = QUIRK_MIDI_FIXED_ENDPOINT,
2539				.data = &(const struct snd_usb_midi_endpoint_info) {
2540					.out_cables = 0x0001,
2541					.in_cables  = 0x0001
2542				}
2543			},
2544			{
2545				.ifnum = -1
2546			}
2547		}
2548	}
2549},
2550{
2551	/* Steinberg MI4 */
2552	USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2553	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2554		.ifnum = QUIRK_ANY_INTERFACE,
2555		.type = QUIRK_COMPOSITE,
2556		.data = & (const struct snd_usb_audio_quirk[]) {
2557			{
2558				.ifnum = 0,
2559				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2560			},
2561			{
2562				.ifnum = 1,
2563				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2564			},
2565			{
2566				.ifnum = 2,
2567				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2568			},
2569			{
2570				.ifnum = 3,
2571				.type = QUIRK_MIDI_FIXED_ENDPOINT,
2572				.data = &(const struct snd_usb_midi_endpoint_info) {
2573					.out_cables = 0x0001,
2574					.in_cables  = 0x0001
2575				}
2576			},
2577			{
2578				.ifnum = -1
2579			}
2580		}
2581	}
2582},
2583
2584/* TerraTec devices */
2585{
2586	USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2587	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2588		.vendor_name = "TerraTec",
2589		.product_name = "PHASE 26",
2590		.ifnum = 3,
2591		.type = QUIRK_MIDI_STANDARD_INTERFACE
2592	}
2593},
2594{
2595	USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2596	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2597		.vendor_name = "TerraTec",
2598		.product_name = "PHASE 26",
2599		.ifnum = 3,
2600		.type = QUIRK_MIDI_STANDARD_INTERFACE
2601	}
2602},
2603{
2604	USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2605	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2606		.vendor_name = "TerraTec",
2607		.product_name = "PHASE 26",
2608		.ifnum = 3,
2609		.type = QUIRK_MIDI_STANDARD_INTERFACE
2610	}
2611},
2612{
2613	USB_DEVICE(0x0ccd, 0x0028),
2614	QUIRK_RENAME_DEVICE("TerraTec", "Aureon5.1MkII")
 
 
 
 
2615},
2616{
2617	USB_DEVICE(0x0ccd, 0x0035),
2618	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2619		.vendor_name = "Miditech",
2620		.product_name = "Play'n Roll",
2621		.ifnum = 0,
2622		.type = QUIRK_MIDI_CME
2623	}
2624},
2625
2626/* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2627{
2628	USB_DEVICE(0x103d, 0x0100),
2629	QUIRK_RENAME_DEVICE("Stanton", "ScratchAmp")
 
 
 
 
2630},
2631{
2632	USB_DEVICE(0x103d, 0x0101),
2633	QUIRK_RENAME_DEVICE("Stanton", "ScratchAmp")
 
 
 
 
2634},
2635
2636/* Novation EMS devices */
2637{
2638	USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2639	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2640		.vendor_name = "Novation",
2641		.product_name = "ReMOTE Audio/XStation",
2642		.ifnum = 4,
2643		.type = QUIRK_MIDI_NOVATION
2644	}
2645},
2646{
2647	USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2648	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2649		.vendor_name = "Novation",
2650		.product_name = "Speedio",
2651		.ifnum = 3,
2652		.type = QUIRK_MIDI_NOVATION
2653	}
2654},
2655{
2656	USB_DEVICE(0x1235, 0x000a),
2657	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2658		/* .vendor_name = "Novation", */
2659		/* .product_name = "Nocturn", */
2660		.ifnum = 0,
2661		.type = QUIRK_MIDI_RAW_BYTES
2662	}
2663},
2664{
2665	USB_DEVICE(0x1235, 0x000e),
2666	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2667		/* .vendor_name = "Novation", */
2668		/* .product_name = "Launchpad", */
2669		.ifnum = 0,
2670		.type = QUIRK_MIDI_RAW_BYTES
2671	}
2672},
2673{
2674	USB_DEVICE(0x1235, 0x0010),
2675	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2676		.vendor_name = "Focusrite",
2677		.product_name = "Saffire 6 USB",
2678		.ifnum = QUIRK_ANY_INTERFACE,
2679		.type = QUIRK_COMPOSITE,
2680		.data = (const struct snd_usb_audio_quirk[]) {
2681			{
2682				.ifnum = 0,
2683				.type = QUIRK_AUDIO_STANDARD_MIXER,
2684			},
2685			{
2686				.ifnum = 0,
2687				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2688				.data = &(const struct audioformat) {
2689					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2690					.channels = 4,
2691					.iface = 0,
2692					.altsetting = 1,
2693					.altset_idx = 1,
2694					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2695					.endpoint = 0x01,
2696					.ep_attr = USB_ENDPOINT_XFER_ISOC,
2697					.datainterval = 1,
2698					.maxpacksize = 0x024c,
2699					.rates = SNDRV_PCM_RATE_44100 |
2700						 SNDRV_PCM_RATE_48000,
2701					.rate_min = 44100,
2702					.rate_max = 48000,
2703					.nr_rates = 2,
2704					.rate_table = (unsigned int[]) {
2705						44100, 48000
2706					}
2707				}
2708			},
2709			{
2710				.ifnum = 0,
2711				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2712				.data = &(const struct audioformat) {
2713					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2714					.channels = 2,
2715					.iface = 0,
2716					.altsetting = 1,
2717					.altset_idx = 1,
2718					.attributes = 0,
2719					.endpoint = 0x82,
2720					.ep_attr = USB_ENDPOINT_XFER_ISOC,
2721					.datainterval = 1,
2722					.maxpacksize = 0x0126,
2723					.rates = SNDRV_PCM_RATE_44100 |
2724						 SNDRV_PCM_RATE_48000,
2725					.rate_min = 44100,
2726					.rate_max = 48000,
2727					.nr_rates = 2,
2728					.rate_table = (unsigned int[]) {
2729						44100, 48000
2730					}
2731				}
2732			},
2733			{
2734				.ifnum = 1,
2735				.type = QUIRK_MIDI_RAW_BYTES
2736			},
2737			{
2738				.ifnum = -1
2739			}
2740		}
2741	}
2742},
2743{
2744	USB_DEVICE(0x1235, 0x0018),
2745	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2746		.vendor_name = "Novation",
2747		.product_name = "Twitch",
2748		.ifnum = QUIRK_ANY_INTERFACE,
2749		.type = QUIRK_COMPOSITE,
2750		.data = (const struct snd_usb_audio_quirk[]) {
2751			{
2752				.ifnum = 0,
2753				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2754				.data = & (const struct audioformat) {
2755					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2756					.channels = 4,
2757					.iface = 0,
2758					.altsetting = 1,
2759					.altset_idx = 1,
2760					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2761					.endpoint = 0x01,
2762					.ep_attr = USB_ENDPOINT_XFER_ISOC,
2763					.rates = SNDRV_PCM_RATE_44100 |
2764						 SNDRV_PCM_RATE_48000,
2765					.rate_min = 44100,
2766					.rate_max = 48000,
2767					.nr_rates = 2,
2768					.rate_table = (unsigned int[]) {
2769						44100, 48000
2770					}
2771				}
2772			},
2773			{
2774				.ifnum = 1,
2775				.type = QUIRK_MIDI_RAW_BYTES
2776			},
2777			{
2778				.ifnum = -1
2779			}
2780		}
2781	}
2782},
2783{
2784	USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2785	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2786		.vendor_name = "Novation",
2787		.product_name = "ReMOTE25",
2788		.ifnum = 0,
2789		.type = QUIRK_MIDI_NOVATION
2790	}
2791},
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2792
2793/* Access Music devices */
2794{
2795	/* VirusTI Desktop */
2796	USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2797	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2798		.ifnum = QUIRK_ANY_INTERFACE,
2799		.type = QUIRK_COMPOSITE,
2800		.data = &(const struct snd_usb_audio_quirk[]) {
2801			{
2802				.ifnum = 3,
2803				.type = QUIRK_MIDI_FIXED_ENDPOINT,
2804				.data = &(const struct snd_usb_midi_endpoint_info) {
2805					.out_cables = 0x0003,
2806					.in_cables  = 0x0003
2807				}
2808			},
2809			{
2810				.ifnum = 4,
2811				.type = QUIRK_IGNORE_INTERFACE
2812			},
2813			{
2814				.ifnum = -1
2815			}
2816		}
2817	}
2818},
2819
2820/* */
2821{
2822	/* aka. Serato Scratch Live DJ Box */
2823	USB_DEVICE(0x13e5, 0x0001),
2824	QUIRK_RENAME_DEVICE("Rane", "SL-1")
2825},
2826
2827/* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */
2828{
2829	USB_DEVICE(0x17aa, 0x1046),
2830	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2831		.vendor_name = "Lenovo",
2832		.product_name = "ThinkStation P620 Rear",
2833		.profile_name = "Lenovo-ThinkStation-P620-Rear",
2834		.ifnum = QUIRK_ANY_INTERFACE,
2835		.type = QUIRK_SETUP_DISABLE_AUTOSUSPEND
2836	}
2837},
2838/* Lenovo ThinkStation P620 Internal Speaker + Front Headset */
2839{
2840	USB_DEVICE(0x17aa, 0x104d),
2841	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2842		.vendor_name = "Lenovo",
2843		.product_name = "ThinkStation P620 Main",
2844		.profile_name = "Lenovo-ThinkStation-P620-Main",
2845		.ifnum = QUIRK_ANY_INTERFACE,
2846		.type = QUIRK_SETUP_DISABLE_AUTOSUSPEND
2847	}
2848},
2849
2850/* Native Instruments MK2 series */
2851{
2852	/* Komplete Audio 6 */
2853	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2854	.idVendor = 0x17cc,
2855	.idProduct = 0x1000,
2856},
2857{
2858	/* Traktor Audio 6 */
2859	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2860	.idVendor = 0x17cc,
2861	.idProduct = 0x1010,
2862},
2863{
2864	/* Traktor Audio 10 */
2865	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2866	.idVendor = 0x17cc,
2867	.idProduct = 0x1020,
2868},
2869
2870/* QinHeng devices */
2871{
2872	USB_DEVICE(0x1a86, 0x752d),
2873	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2874		.vendor_name = "QinHeng",
2875		.product_name = "CH345",
2876		.ifnum = 1,
2877		.type = QUIRK_MIDI_CH345
2878	}
2879},
2880
2881/* KeithMcMillen Stringport */
2882{
2883	USB_DEVICE(0x1f38, 0x0001),
2884	.bInterfaceClass = USB_CLASS_AUDIO,
2885},
2886
2887/* Miditech devices */
2888{
2889	USB_DEVICE(0x4752, 0x0011),
2890	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2891		.vendor_name = "Miditech",
2892		.product_name = "Midistart-2",
2893		.ifnum = 0,
2894		.type = QUIRK_MIDI_CME
2895	}
2896},
2897
2898/* Central Music devices */
2899{
2900	/* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2901	USB_DEVICE(0x7104, 0x2202),
2902	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2903		.ifnum = 0,
2904		.type = QUIRK_MIDI_CME
2905	}
2906},
2907
2908/*
2909 * Auvitek au0828 devices with audio interface.
2910 * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
2911 * Please notice that some drivers are DVB only, and don't need to be
2912 * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2913 */
2914
2915#define AU0828_DEVICE(vid, pid, vname, pname) { \
2916	.idVendor = vid, \
2917	.idProduct = pid, \
2918	.match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
2919		       USB_DEVICE_ID_MATCH_INT_CLASS | \
2920		       USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
2921	.bInterfaceClass = USB_CLASS_AUDIO, \
2922	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, \
2923	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2924		.vendor_name = vname, \
2925		.product_name = pname, \
2926		.ifnum = QUIRK_ANY_INTERFACE, \
2927		.type = QUIRK_AUDIO_ALIGN_TRANSFER, \
2928		.shares_media_device = 1, \
2929	} \
2930}
2931
2932AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2933AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2934AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
2935AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
2936AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
2937AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
2938AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
2939AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
2940AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
2941AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
2942AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
2943AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
2944AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
2945AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
2946AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
2947AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
2948AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
2949
2950/* Syntek STK1160 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2951{
 
2952	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2953		       USB_DEVICE_ID_MATCH_INT_CLASS |
2954		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2955	.idVendor = 0x05e1,
2956	.idProduct = 0x0408,
2957	.bInterfaceClass = USB_CLASS_AUDIO,
2958	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2959	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2960		.vendor_name = "Syntek",
2961		.product_name = "STK1160",
2962		.ifnum = QUIRK_ANY_INTERFACE,
2963		.type = QUIRK_AUDIO_ALIGN_TRANSFER
2964	}
2965},
2966
2967/* Digidesign Mbox */
2968{
2969	/* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2970	USB_DEVICE(0x0dba, 0x1000),
2971	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2972		.vendor_name = "Digidesign",
2973		.product_name = "MBox",
2974		.ifnum = QUIRK_ANY_INTERFACE,
2975		.type = QUIRK_COMPOSITE,
2976		.data = (const struct snd_usb_audio_quirk[]){
2977			{
2978				.ifnum = 0,
2979				.type = QUIRK_AUDIO_STANDARD_MIXER,
2980			},
2981			{
2982				.ifnum = 1,
2983				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2984				.data = &(const struct audioformat) {
2985					.formats = SNDRV_PCM_FMTBIT_S24_3BE,
2986					.channels = 2,
2987					.iface = 1,
2988					.altsetting = 1,
2989					.altset_idx = 1,
2990					.attributes = 0x4,
2991					.endpoint = 0x02,
2992					.ep_attr = USB_ENDPOINT_XFER_ISOC |
2993						USB_ENDPOINT_SYNC_SYNC,
2994					.maxpacksize = 0x130,
2995					.rates = SNDRV_PCM_RATE_48000,
2996					.rate_min = 48000,
2997					.rate_max = 48000,
2998					.nr_rates = 1,
2999					.rate_table = (unsigned int[]) {
3000						48000
3001					}
3002				}
3003			},
3004			{
3005				.ifnum = 1,
3006				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3007				.data = &(const struct audioformat) {
3008					.formats = SNDRV_PCM_FMTBIT_S24_3BE,
3009					.channels = 2,
3010					.iface = 1,
3011					.altsetting = 1,
3012					.altset_idx = 1,
3013					.attributes = 0x4,
3014					.endpoint = 0x81,
3015					.ep_attr = USB_ENDPOINT_XFER_ISOC |
3016						USB_ENDPOINT_SYNC_ASYNC,
3017					.maxpacksize = 0x130,
3018					.rates = SNDRV_PCM_RATE_48000,
3019					.rate_min = 48000,
3020					.rate_max = 48000,
3021					.nr_rates = 1,
3022					.rate_table = (unsigned int[]) {
3023						48000
3024					}
3025				}
3026			},
3027			{
3028				.ifnum = -1
3029			}
3030		}
 
3031	}
3032},
3033
3034/* DIGIDESIGN MBOX 2 */
3035{
3036	USB_DEVICE(0x0dba, 0x3000),
3037	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3038		.vendor_name = "Digidesign",
3039		.product_name = "Mbox 2",
3040		.ifnum = QUIRK_ANY_INTERFACE,
3041		.type = QUIRK_COMPOSITE,
3042		.data = (const struct snd_usb_audio_quirk[]) {
3043			{
3044				.ifnum = 0,
3045				.type = QUIRK_IGNORE_INTERFACE
3046			},
3047			{
3048				.ifnum = 1,
3049				.type = QUIRK_IGNORE_INTERFACE
3050			},
3051			{
3052				.ifnum = 2,
3053				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3054				.data = &(const struct audioformat) {
3055					.formats = SNDRV_PCM_FMTBIT_S24_3BE,
3056					.channels = 2,
3057					.iface = 2,
3058					.altsetting = 2,
3059					.altset_idx = 1,
3060					.attributes = 0x00,
3061					.endpoint = 0x03,
3062					.ep_attr = USB_ENDPOINT_SYNC_ASYNC,
3063					.rates = SNDRV_PCM_RATE_48000,
3064					.rate_min = 48000,
3065					.rate_max = 48000,
3066					.nr_rates = 1,
3067					.rate_table = (unsigned int[]) {
3068						48000
3069					}
3070				}
3071			},
3072			{
3073				.ifnum = 3,
3074				.type = QUIRK_IGNORE_INTERFACE
3075			},
3076			{
3077				.ifnum = 4,
3078				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3079				.data = &(const struct audioformat) {
3080				.formats = SNDRV_PCM_FMTBIT_S24_3BE,
3081					.channels = 2,
3082					.iface = 4,
3083					.altsetting = 2,
3084					.altset_idx = 1,
3085					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3086					.endpoint = 0x85,
3087					.ep_attr = USB_ENDPOINT_SYNC_SYNC,
3088					.rates = SNDRV_PCM_RATE_48000,
3089					.rate_min = 48000,
3090					.rate_max = 48000,
3091					.nr_rates = 1,
3092					.rate_table = (unsigned int[]) {
3093						48000
3094					}
3095				}
3096			},
3097			{
3098				.ifnum = 5,
3099				.type = QUIRK_IGNORE_INTERFACE
3100			},
3101			{
3102				.ifnum = 6,
3103				.type = QUIRK_MIDI_MIDIMAN,
3104				.data = &(const struct snd_usb_midi_endpoint_info) {
3105					.out_ep =  0x02,
3106					.out_cables = 0x0001,
3107					.in_ep = 0x81,
3108					.in_interval = 0x01,
3109					.in_cables = 0x0001
3110				}
3111			},
3112			{
3113				.ifnum = -1
3114			}
3115		}
3116	}
3117},
3118{
3119	/* Tascam US122 MKII - playback-only support */
3120	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
3121	.idVendor = 0x0644,
3122	.idProduct = 0x8021,
3123	.bInterfaceClass = USB_CLASS_AUDIO,
3124	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3125		.vendor_name = "TASCAM",
3126		.product_name = "US122 MKII",
3127		.ifnum = QUIRK_ANY_INTERFACE,
3128		.type = QUIRK_COMPOSITE,
3129		.data = (const struct snd_usb_audio_quirk[]) {
3130			{
3131				.ifnum = 0,
3132				.type = QUIRK_IGNORE_INTERFACE
3133			},
3134			{
3135				.ifnum = 1,
3136				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3137				.data = &(const struct audioformat) {
3138					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
3139					.channels = 2,
3140					.iface = 1,
3141					.altsetting = 1,
3142					.altset_idx = 1,
3143					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3144					.endpoint = 0x02,
3145					.ep_attr = USB_ENDPOINT_XFER_ISOC,
3146					.rates = SNDRV_PCM_RATE_44100 |
3147						 SNDRV_PCM_RATE_48000 |
3148						 SNDRV_PCM_RATE_88200 |
3149						 SNDRV_PCM_RATE_96000,
3150					.rate_min = 44100,
3151					.rate_max = 96000,
3152					.nr_rates = 4,
3153					.rate_table = (unsigned int[]) {
3154						44100, 48000, 88200, 96000
3155					}
3156				}
3157			},
3158			{
3159				.ifnum = -1
3160			}
3161		}
3162	}
3163},
3164
3165/* Microsoft XboxLive Headset/Xbox Communicator */
3166{
3167	USB_DEVICE(0x045e, 0x0283),
3168	.bInterfaceClass = USB_CLASS_PER_INTERFACE,
3169	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3170		.vendor_name = "Microsoft",
3171		.product_name = "XboxLive Headset/Xbox Communicator",
3172		.ifnum = QUIRK_ANY_INTERFACE,
3173		.type = QUIRK_COMPOSITE,
3174		.data = &(const struct snd_usb_audio_quirk[]) {
3175			{
3176				/* playback */
3177				.ifnum = 0,
3178				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3179				.data = &(const struct audioformat) {
3180					.formats = SNDRV_PCM_FMTBIT_S16_LE,
3181					.channels = 1,
3182					.iface = 0,
3183					.altsetting = 0,
3184					.altset_idx = 0,
3185					.attributes = 0,
3186					.endpoint = 0x04,
3187					.ep_attr = 0x05,
3188					.rates = SNDRV_PCM_RATE_CONTINUOUS,
3189					.rate_min = 22050,
3190					.rate_max = 22050
3191				}
3192			},
3193			{
3194				/* capture */
3195				.ifnum = 1,
3196				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3197				.data = &(const struct audioformat) {
3198					.formats = SNDRV_PCM_FMTBIT_S16_LE,
3199					.channels = 1,
3200					.iface = 1,
3201					.altsetting = 0,
3202					.altset_idx = 0,
3203					.attributes = 0,
3204					.endpoint = 0x85,
3205					.ep_attr = 0x05,
3206					.rates = SNDRV_PCM_RATE_CONTINUOUS,
3207					.rate_min = 16000,
3208					.rate_max = 16000
3209				}
3210			},
3211			{
3212				.ifnum = -1
3213			}
3214		}
3215	}
3216},
3217
3218/* Reloop Play */
3219{
3220	USB_DEVICE(0x200c, 0x100b),
3221	.bInterfaceClass = USB_CLASS_PER_INTERFACE,
3222	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3223		.ifnum = QUIRK_ANY_INTERFACE,
3224		.type = QUIRK_COMPOSITE,
3225		.data = &(const struct snd_usb_audio_quirk[]) {
3226			{
3227				.ifnum = 0,
3228				.type = QUIRK_AUDIO_STANDARD_MIXER,
3229			},
3230			{
3231				.ifnum = 1,
3232				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3233				.data = &(const struct audioformat) {
3234					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
3235					.channels = 4,
3236					.iface = 1,
3237					.altsetting = 1,
3238					.altset_idx = 1,
3239					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3240					.endpoint = 0x01,
3241					.ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3242					.rates = SNDRV_PCM_RATE_44100 |
3243						 SNDRV_PCM_RATE_48000,
3244					.rate_min = 44100,
3245					.rate_max = 48000,
3246					.nr_rates = 2,
3247					.rate_table = (unsigned int[]) {
3248						44100, 48000
3249					}
3250				}
3251			},
3252			{
3253				.ifnum = -1
3254			}
3255		}
3256	}
3257},
3258
3259{
3260	/*
3261	 * ZOOM R16/24 in audio interface mode.
3262	 * Playback requires an extra four byte LE length indicator
3263	 * at the start of each isochronous packet. This quirk is
3264	 * enabled in create_standard_audio_quirk().
3265	 */
3266	USB_DEVICE(0x1686, 0x00dd),
3267	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3268		.ifnum = QUIRK_ANY_INTERFACE,
3269		.type = QUIRK_COMPOSITE,
3270		.data = (const struct snd_usb_audio_quirk[]) {
3271			{
3272				/* Playback  */
3273				.ifnum = 1,
3274				.type = QUIRK_AUDIO_STANDARD_INTERFACE,
3275			},
3276			{
3277				/* Capture */
3278				.ifnum = 2,
3279				.type = QUIRK_AUDIO_STANDARD_INTERFACE,
3280			},
3281			{
3282				/* Midi */
3283				.ifnum = 3,
3284				.type = QUIRK_MIDI_STANDARD_INTERFACE
3285			},
3286			{
3287				.ifnum = -1
3288			},
3289		}
3290	}
3291},
3292
3293{
3294	/*
3295	 * Some USB MIDI devices don't have an audio control interface,
3296	 * so we have to grab MIDI streaming interfaces here.
3297	 */
3298	.match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3299		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3300	.bInterfaceClass = USB_CLASS_AUDIO,
3301	.bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3302	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3303		.ifnum = QUIRK_ANY_INTERFACE,
3304		.type = QUIRK_MIDI_STANDARD_INTERFACE
3305	}
3306},
3307
3308/*
3309 * The original product_name is "USB Sound Device", however this name
3310 * is also used by the CM106 based cards, so make it unique.
3311 */
3312{
3313	USB_DEVICE(0x0d8c, 0x0102),
3314	QUIRK_RENAME_DEVICE(NULL, "ICUSBAUDIO7D")
3315},
3316{
3317	USB_DEVICE(0x0d8c, 0x0103),
3318	QUIRK_RENAME_DEVICE(NULL, "Audio Advantage MicroII")
3319},
3320
3321/* disabled due to regression for other devices;
3322 * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3323 */
3324#if 0
3325{
3326	/*
3327	 * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3328	 * ID, but it looks like the product ID actually is only for Nura.
3329	 * The capture interface does not work at all (even on Windows),
3330	 * and only the 48 kHz sample rate works for the playback interface.
3331	 */
3332	USB_DEVICE(0x0a12, 0x1243),
3333	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3334		.ifnum = QUIRK_ANY_INTERFACE,
3335		.type = QUIRK_COMPOSITE,
3336		.data = (const struct snd_usb_audio_quirk[]) {
3337			{
3338				.ifnum = 0,
3339				.type = QUIRK_AUDIO_STANDARD_MIXER,
3340			},
3341			/* Capture */
3342			{
3343				.ifnum = 1,
3344				.type = QUIRK_IGNORE_INTERFACE,
3345			},
3346			/* Playback */
3347			{
3348				.ifnum = 2,
3349				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3350				.data = &(const struct audioformat) {
3351					.formats = SNDRV_PCM_FMTBIT_S16_LE,
3352					.channels = 2,
3353					.iface = 2,
3354					.altsetting = 1,
3355					.altset_idx = 1,
3356					.attributes = UAC_EP_CS_ATTR_FILL_MAX |
3357						UAC_EP_CS_ATTR_SAMPLE_RATE,
3358					.endpoint = 0x03,
3359					.ep_attr = USB_ENDPOINT_XFER_ISOC,
3360					.rates = SNDRV_PCM_RATE_48000,
3361					.rate_min = 48000,
3362					.rate_max = 48000,
3363					.nr_rates = 1,
3364					.rate_table = (unsigned int[]) {
3365						48000
3366					}
3367				}
3368			},
3369			{
3370				.ifnum = -1
3371			},
3372		}
3373	}
3374},
3375#endif /* disabled */
3376
3377{
3378	/*
3379	 * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3380	 * even though it advertises more. The capture interface doesn't work
3381	 * even on windows.
3382	 */
3383	USB_DEVICE(0x19b5, 0x0021),
3384	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3385		.ifnum = QUIRK_ANY_INTERFACE,
3386		.type = QUIRK_COMPOSITE,
3387		.data = (const struct snd_usb_audio_quirk[]) {
3388			{
3389				.ifnum = 0,
3390				.type = QUIRK_AUDIO_STANDARD_MIXER,
3391			},
3392			/* Playback */
3393			{
3394				.ifnum = 1,
3395				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3396				.data = &(const struct audioformat) {
3397					.formats = SNDRV_PCM_FMTBIT_S16_LE,
3398					.channels = 2,
3399					.iface = 1,
3400					.altsetting = 1,
3401					.altset_idx = 1,
3402					.attributes = UAC_EP_CS_ATTR_FILL_MAX |
3403						UAC_EP_CS_ATTR_SAMPLE_RATE,
3404					.endpoint = 0x03,
3405					.ep_attr = USB_ENDPOINT_XFER_ISOC,
3406					.rates = SNDRV_PCM_RATE_48000,
3407					.rate_min = 48000,
3408					.rate_max = 48000,
3409					.nr_rates = 1,
3410					.rate_table = (unsigned int[]) {
3411						48000
3412					}
3413				}
3414			},
3415			{
3416				.ifnum = -1
3417			},
3418		}
3419	}
3420},
3421/* Dell WD15 Dock */
3422{
3423	USB_DEVICE(0x0bda, 0x4014),
3424	QUIRK_DEVICE_PROFILE("Dell", "WD15 Dock", "Dell-WD15-Dock")
3425},
3426/* Dell WD19 Dock */
3427{
3428	USB_DEVICE(0x0bda, 0x402e),
3429	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3430		.vendor_name = "Dell",
3431		.product_name = "WD19 Dock",
3432		.profile_name = "Dell-WD15-Dock",
3433		.ifnum = QUIRK_ANY_INTERFACE,
3434		.type = QUIRK_SETUP_FMT_AFTER_RESUME
3435	}
3436},
3437/* MOTU Microbook II */
3438{
3439	USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004),
3440	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3441		.vendor_name = "MOTU",
3442		.product_name = "MicroBookII",
3443		.ifnum = QUIRK_ANY_INTERFACE,
3444		.type = QUIRK_COMPOSITE,
3445		.data = (const struct snd_usb_audio_quirk[]) {
3446			{
3447				.ifnum = 0,
3448				.type = QUIRK_AUDIO_STANDARD_MIXER,
3449			},
3450			{
3451				.ifnum = 0,
3452				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3453				.data = &(const struct audioformat) {
3454					.formats = SNDRV_PCM_FMTBIT_S24_3BE,
3455					.channels = 6,
3456					.iface = 0,
3457					.altsetting = 1,
3458					.altset_idx = 1,
3459					.attributes = 0,
3460					.endpoint = 0x84,
3461					.rates = SNDRV_PCM_RATE_96000,
3462					.ep_attr = USB_ENDPOINT_XFER_ISOC |
3463						   USB_ENDPOINT_SYNC_ASYNC,
3464					.rate_min = 96000,
3465					.rate_max = 96000,
3466					.nr_rates = 1,
3467					.maxpacksize = 0x00d8,
3468					.rate_table = (unsigned int[]) {
3469						96000
3470					}
3471				}
3472			},
3473			{
3474				.ifnum = 0,
3475				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3476				.data = &(const struct audioformat) {
3477					.formats = SNDRV_PCM_FMTBIT_S24_3BE,
3478					.channels = 8,
3479					.iface = 0,
3480					.altsetting = 1,
3481					.altset_idx = 1,
3482					.attributes = 0,
3483					.endpoint = 0x03,
3484					.rates = SNDRV_PCM_RATE_96000,
3485					.ep_attr = USB_ENDPOINT_XFER_ISOC |
3486						   USB_ENDPOINT_SYNC_ASYNC,
3487					.rate_min = 96000,
3488					.rate_max = 96000,
3489					.nr_rates = 1,
3490					.maxpacksize = 0x0120,
3491					.rate_table = (unsigned int[]) {
3492						96000
3493					}
3494				}
3495			},
3496			{
3497				.ifnum = -1
3498			}
3499		}
3500	}
3501},
3502{
3503	/*
3504	 * PIONEER DJ DDJ-SX3
3505	 * PCM is 12 channels out, 10 channels in @ 44.1 fixed
3506	 * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
3507	 * The feedback for the output is the input.
3508	 */
3509	USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
3510	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3511		.ifnum = QUIRK_ANY_INTERFACE,
3512		.type = QUIRK_COMPOSITE,
3513		.data = (const struct snd_usb_audio_quirk[]) {
3514			{
3515				.ifnum = 0,
3516				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3517				.data = &(const struct audioformat) {
3518					.formats = SNDRV_PCM_FMTBIT_S32_LE,
3519					.channels = 12,
3520					.iface = 0,
3521					.altsetting = 1,
3522					.altset_idx = 1,
3523					.endpoint = 0x05,
3524					.ep_attr = USB_ENDPOINT_XFER_ISOC|
3525						   USB_ENDPOINT_SYNC_ASYNC,
3526					.rates = SNDRV_PCM_RATE_44100,
3527					.rate_min = 44100,
3528					.rate_max = 44100,
3529					.nr_rates = 1,
3530					.rate_table = (unsigned int[]) { 44100 }
3531				}
3532			},
3533			{
3534				.ifnum = 0,
3535				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3536				.data = &(const struct audioformat) {
3537					.formats = SNDRV_PCM_FMTBIT_S32_LE,
3538					.channels = 10,
3539					.iface = 0,
3540					.altsetting = 1,
3541					.altset_idx = 1,
3542					.endpoint = 0x86,
3543					.ep_attr = USB_ENDPOINT_XFER_ISOC|
3544						 USB_ENDPOINT_SYNC_ASYNC|
3545						 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3546					.rates = SNDRV_PCM_RATE_44100,
3547					.rate_min = 44100,
3548					.rate_max = 44100,
3549					.nr_rates = 1,
3550					.rate_table = (unsigned int[]) { 44100 }
3551				}
3552			},
3553			{
3554				.ifnum = -1
3555			}
3556		}
3557	}
3558},
3559{
3560	/*
3561	 * Pioneer DJ DJM-250MK2
3562	 * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
3563	 * and 8 channels in @ 48 fixed (endpoint 0x82).
3564	 *
3565	 * Both playback and recording is working, even simultaneously.
3566	 *
3567	 * Playback channels could be mapped to:
3568	 *  - CH1
3569	 *  - CH2
3570	 *  - AUX
3571	 *
3572	 * Recording channels could be mapped to:
3573	 *  - Post CH1 Fader
3574	 *  - Post CH2 Fader
3575	 *  - Cross Fader A
3576	 *  - Cross Fader B
3577	 *  - MIC
3578	 *  - AUX
3579	 *  - REC OUT
3580	 *
3581	 * There is remaining problem with recording directly from PHONO/LINE.
3582	 * If we map a channel to:
3583	 *  - CH1 Control Tone PHONO
3584	 *  - CH1 Control Tone LINE
3585	 *  - CH2 Control Tone PHONO
3586	 *  - CH2 Control Tone LINE
3587	 * it is silent.
3588	 * There is no signal even on other operating systems with official drivers.
3589	 * The signal appears only when a supported application is started.
3590	 * This needs to be investigated yet...
3591	 * (there is quite a lot communication on the USB in both directions)
3592	 *
3593	 * In current version this mixer could be used for playback
3594	 * and for recording from vinyls (through Post CH* Fader)
3595	 * but not for DVS (Digital Vinyl Systems) like in Mixxx.
3596	 */
3597	USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3598	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3599		.ifnum = QUIRK_ANY_INTERFACE,
3600		.type = QUIRK_COMPOSITE,
3601		.data = (const struct snd_usb_audio_quirk[]) {
3602			{
3603				.ifnum = 0,
3604				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3605				.data = &(const struct audioformat) {
3606					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
3607					.channels = 8, // outputs
3608					.iface = 0,
3609					.altsetting = 1,
3610					.altset_idx = 1,
3611					.endpoint = 0x01,
3612					.ep_attr = USB_ENDPOINT_XFER_ISOC|
3613						USB_ENDPOINT_SYNC_ASYNC,
3614					.rates = SNDRV_PCM_RATE_48000,
3615					.rate_min = 48000,
3616					.rate_max = 48000,
3617					.nr_rates = 1,
3618					.rate_table = (unsigned int[]) { 48000 }
3619					}
3620			},
3621			{
3622				.ifnum = 0,
3623				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3624				.data = &(const struct audioformat) {
3625					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
3626					.channels = 8, // inputs
3627					.iface = 0,
3628					.altsetting = 1,
3629					.altset_idx = 1,
3630					.endpoint = 0x82,
3631					.ep_attr = USB_ENDPOINT_XFER_ISOC|
3632						USB_ENDPOINT_SYNC_ASYNC|
3633						USB_ENDPOINT_USAGE_IMPLICIT_FB,
3634					.rates = SNDRV_PCM_RATE_48000,
3635					.rate_min = 48000,
3636					.rate_max = 48000,
3637					.nr_rates = 1,
3638					.rate_table = (unsigned int[]) { 48000 }
3639				}
3640			},
3641			{
3642				.ifnum = -1
3643			}
3644		}
3645	}
3646},
3647{
3648	/*
3649	 * PIONEER DJ DDJ-RB
3650	 * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3651	 * The feedback for the output is the dummy input.
3652	 */
3653	USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3654	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3655		.ifnum = QUIRK_ANY_INTERFACE,
3656		.type = QUIRK_COMPOSITE,
3657		.data = (const struct snd_usb_audio_quirk[]) {
3658			{
3659				.ifnum = 0,
3660				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3661				.data = &(const struct audioformat) {
3662					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
3663					.channels = 4,
3664					.iface = 0,
3665					.altsetting = 1,
3666					.altset_idx = 1,
3667					.endpoint = 0x01,
3668					.ep_attr = USB_ENDPOINT_XFER_ISOC|
3669						   USB_ENDPOINT_SYNC_ASYNC,
3670					.rates = SNDRV_PCM_RATE_44100,
3671					.rate_min = 44100,
3672					.rate_max = 44100,
3673					.nr_rates = 1,
3674					.rate_table = (unsigned int[]) { 44100 }
3675				}
3676			},
3677			{
3678				.ifnum = 0,
3679				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3680				.data = &(const struct audioformat) {
3681					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
3682					.channels = 2,
3683					.iface = 0,
3684					.altsetting = 1,
3685					.altset_idx = 1,
3686					.endpoint = 0x82,
3687					.ep_attr = USB_ENDPOINT_XFER_ISOC|
3688						 USB_ENDPOINT_SYNC_ASYNC|
3689						 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3690					.rates = SNDRV_PCM_RATE_44100,
3691					.rate_min = 44100,
3692					.rate_max = 44100,
3693					.nr_rates = 1,
3694					.rate_table = (unsigned int[]) { 44100 }
3695				}
3696			},
3697			{
3698				.ifnum = -1
3699			}
3700		}
3701	}
3702},
3703
3704#define ALC1220_VB_DESKTOP(vend, prod) { \
3705	USB_DEVICE(vend, prod),	\
3706	QUIRK_DEVICE_PROFILE("Realtek", "ALC1220-VB-DT", \
3707			     "Realtek-ALC1220-VB-Desktop") \
3708}
3709ALC1220_VB_DESKTOP(0x0414, 0xa002), /* Gigabyte TRX40 Aorus Pro WiFi */
3710ALC1220_VB_DESKTOP(0x0db0, 0x0d64), /* MSI TRX40 Creator */
3711ALC1220_VB_DESKTOP(0x0db0, 0x543d), /* MSI TRX40 */
3712ALC1220_VB_DESKTOP(0x26ce, 0x0a01), /* Asrock TRX40 Creator */
3713#undef ALC1220_VB_DESKTOP
3714
3715/* Two entries for Gigabyte TRX40 Aorus Master:
3716 * TRX40 Aorus Master has two USB-audio devices, one for the front headphone
3717 * with ESS SABRE9218 DAC chip, while another for the rest I/O (the rear
3718 * panel and the front mic) with Realtek ALC1220-VB.
3719 * Here we provide two distinct names for making UCM profiles easier.
3720 */
3721{
3722	USB_DEVICE(0x0414, 0xa000),
3723	QUIRK_DEVICE_PROFILE("Gigabyte", "Aorus Master Front Headphone",
3724			     "Gigabyte-Aorus-Master-Front-Headphone")
3725},
3726{
3727	USB_DEVICE(0x0414, 0xa001),
3728	QUIRK_DEVICE_PROFILE("Gigabyte", "Aorus Master Main Audio",
3729			     "Gigabyte-Aorus-Master-Main-Audio")
3730},
3731{
3732	/*
3733	 * Pioneer DJ DJM-900NXS2
3734	 * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE
3735	 */
3736	USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a),
3737	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3738		.ifnum = QUIRK_ANY_INTERFACE,
3739		.type = QUIRK_COMPOSITE,
3740		.data = (const struct snd_usb_audio_quirk[]) {
3741			{
3742				.ifnum = 0,
3743				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3744				.data = &(const struct audioformat) {
3745					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
3746					.channels = 10,
3747					.iface = 0,
3748					.altsetting = 1,
3749					.altset_idx = 1,
3750					.endpoint = 0x01,
3751					.ep_attr = USB_ENDPOINT_XFER_ISOC|
3752					    USB_ENDPOINT_SYNC_ASYNC,
3753					.rates = SNDRV_PCM_RATE_44100|
3754					    SNDRV_PCM_RATE_48000|
3755					    SNDRV_PCM_RATE_96000,
3756					.rate_min = 44100,
3757					.rate_max = 96000,
3758					.nr_rates = 3,
3759					.rate_table = (unsigned int[]) {
3760						44100, 48000, 96000
3761					}
3762				}
3763			},
3764			{
3765				.ifnum = 0,
3766				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3767				.data = &(const struct audioformat) {
3768					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
3769					.channels = 12,
3770					.iface = 0,
3771					.altsetting = 1,
3772					.altset_idx = 1,
3773					.endpoint = 0x82,
3774					.ep_attr = USB_ENDPOINT_XFER_ISOC|
3775					    USB_ENDPOINT_SYNC_ASYNC|
3776					    USB_ENDPOINT_USAGE_IMPLICIT_FB,
3777					.rates = SNDRV_PCM_RATE_44100|
3778					    SNDRV_PCM_RATE_48000|
3779					    SNDRV_PCM_RATE_96000,
3780					.rate_min = 44100,
3781					.rate_max = 96000,
3782					.nr_rates = 3,
3783					.rate_table = (unsigned int[]) {
3784						44100, 48000, 96000
3785					}
3786				}
3787			},
3788			{
3789				.ifnum = -1
3790			}
3791		}
3792	}
3793},
3794
3795/*
3796 * MacroSilicon MS2109 based HDMI capture cards
3797 *
3798 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3799 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if
3800 * they pretend to be 96kHz mono as a workaround for stereo being broken
3801 * by that...
3802 *
3803 * They also have an issue with initial stream alignment that causes the
3804 * channels to be swapped and out of phase, which is dealt with in quirks.c.
3805 */
3806{
3807	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
3808		       USB_DEVICE_ID_MATCH_INT_CLASS |
3809		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3810	.idVendor = 0x534d,
3811	.idProduct = 0x2109,
3812	.bInterfaceClass = USB_CLASS_AUDIO,
3813	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
3814	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3815		.vendor_name = "MacroSilicon",
3816		.product_name = "MS2109",
3817		.ifnum = QUIRK_ANY_INTERFACE,
3818		.type = QUIRK_COMPOSITE,
3819		.data = &(const struct snd_usb_audio_quirk[]) {
3820			{
3821				.ifnum = 2,
3822				.type = QUIRK_AUDIO_ALIGN_TRANSFER,
3823			},
3824			{
3825				.ifnum = 2,
3826				.type = QUIRK_AUDIO_STANDARD_MIXER,
3827			},
3828			{
3829				.ifnum = 3,
3830				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3831				.data = &(const struct audioformat) {
3832					.formats = SNDRV_PCM_FMTBIT_S16_LE,
3833					.channels = 2,
3834					.iface = 3,
3835					.altsetting = 1,
3836					.altset_idx = 1,
3837					.attributes = 0,
3838					.endpoint = 0x82,
3839					.ep_attr = USB_ENDPOINT_XFER_ISOC |
3840						USB_ENDPOINT_SYNC_ASYNC,
3841					.rates = SNDRV_PCM_RATE_CONTINUOUS,
3842					.rate_min = 48000,
3843					.rate_max = 48000,
3844				}
3845			},
3846			{
3847				.ifnum = -1
3848			}
3849		}
3850	}
3851},
3852
3853#undef USB_DEVICE_VENDOR_SPEC
v3.15
 
   1/*
   2 * ALSA USB Audio Driver
   3 *
   4 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>,
   5 *                       Clemens Ladisch <clemens@ladisch.de>
   6 *
   7 *
   8 *  This program is free software; you can redistribute it and/or modify
   9 *  it under the terms of the GNU General Public License as published by
  10 *  the Free Software Foundation; either version 2 of the License, or
  11 *  (at your option) any later version.
  12 *
  13 *  This program is distributed in the hope that it will be useful,
  14 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 *  GNU General Public License for more details.
  17 *
  18 *  You should have received a copy of the GNU General Public License
  19 *  along with this program; if not, write to the Free Software
  20 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21 */
  22
  23/*
  24 * The contents of this file are part of the driver's id_table.
  25 *
  26 * In a perfect world, this file would be empty.
  27 */
  28
  29/*
  30 * Use this for devices where other interfaces are standard compliant,
  31 * to prevent the quirk being applied to those interfaces. (To work with
  32 * hotplugging, bDeviceClass must be set to USB_CLASS_PER_INTERFACE.)
  33 */
  34#define USB_DEVICE_VENDOR_SPEC(vend, prod) \
  35	.match_flags = USB_DEVICE_ID_MATCH_VENDOR | \
  36		       USB_DEVICE_ID_MATCH_PRODUCT | \
  37		       USB_DEVICE_ID_MATCH_INT_CLASS, \
  38	.idVendor = vend, \
  39	.idProduct = prod, \
  40	.bInterfaceClass = USB_CLASS_VENDOR_SPEC
  41
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  42/* FTDI devices */
  43{
  44	USB_DEVICE(0x0403, 0xb8d8),
  45	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  46		/* .vendor_name = "STARR LABS", */
  47		/* .product_name = "Starr Labs MIDI USB device", */
  48		.ifnum = 0,
  49		.type = QUIRK_MIDI_FTDI
  50	}
  51},
  52
  53{
  54	/* Creative BT-D1 */
  55	USB_DEVICE(0x041e, 0x0005),
  56	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  57		.ifnum = 1,
  58		.type = QUIRK_AUDIO_FIXED_ENDPOINT,
  59		.data = &(const struct audioformat) {
  60			.formats = SNDRV_PCM_FMTBIT_S16_LE,
  61			.channels = 2,
  62			.iface = 1,
  63			.altsetting = 1,
  64			.altset_idx = 1,
  65			.endpoint = 0x03,
  66			.ep_attr = USB_ENDPOINT_XFER_ISOC,
  67			.attributes = 0,
  68			.rates = SNDRV_PCM_RATE_CONTINUOUS,
  69			.rate_min = 48000,
  70			.rate_max = 48000,
  71		}
  72	}
  73},
  74
  75/* Creative/E-Mu devices */
  76{
  77	USB_DEVICE(0x041e, 0x3010),
  78	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  79		.vendor_name = "Creative Labs",
  80		.product_name = "Sound Blaster MP3+",
  81		.ifnum = QUIRK_NO_INTERFACE
  82	}
  83},
  84/* Creative/Toshiba Multimedia Center SB-0500 */
  85{
  86	USB_DEVICE(0x041e, 0x3048),
  87	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  88		.vendor_name = "Toshiba",
  89		.product_name = "SB-0500",
  90		.ifnum = QUIRK_NO_INTERFACE
  91	}
  92},
  93{
  94	/* E-Mu 0202 USB */
  95	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  96	.idVendor = 0x041e,
  97	.idProduct = 0x3f02,
  98	.bInterfaceClass = USB_CLASS_AUDIO,
  99},
 100{
 101	/* E-Mu 0404 USB */
 102	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
 103	.idVendor = 0x041e,
 104	.idProduct = 0x3f04,
 105	.bInterfaceClass = USB_CLASS_AUDIO,
 106},
 107{
 108	/* E-Mu Tracker Pre */
 109	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
 110	.idVendor = 0x041e,
 111	.idProduct = 0x3f0a,
 112	.bInterfaceClass = USB_CLASS_AUDIO,
 113},
 114{
 115	/* E-Mu 0204 USB */
 116	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
 117	.idVendor = 0x041e,
 118	.idProduct = 0x3f19,
 119	.bInterfaceClass = USB_CLASS_AUDIO,
 120},
 121
 122/*
 123 * HP Wireless Audio
 124 * When not ignored, causes instability issues for some users, forcing them to
 125 * blacklist the entire module.
 126 */
 127{
 128	USB_DEVICE(0x0424, 0xb832),
 129	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
 130		.vendor_name = "Standard Microsystems Corp.",
 131		.product_name = "HP Wireless Audio",
 132		.ifnum = QUIRK_ANY_INTERFACE,
 133		.type = QUIRK_COMPOSITE,
 134		.data = (const struct snd_usb_audio_quirk[]) {
 135			/* Mixer */
 136			{
 137				.ifnum = 0,
 138				.type = QUIRK_IGNORE_INTERFACE,
 139			},
 140			/* Playback */
 141			{
 142				.ifnum = 1,
 143				.type = QUIRK_IGNORE_INTERFACE,
 144			},
 145			/* Capture */
 146			{
 147				.ifnum = 2,
 148				.type = QUIRK_IGNORE_INTERFACE,
 149			},
 150			/* HID Device, .ifnum = 3 */
 151			{
 152				.ifnum = -1,
 153			}
 154		}
 155	}
 156},
 157
 158/*
 159 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
 160 * class matches do not take effect without an explicit ID match.
 161 */
 162{
 163	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 164		       USB_DEVICE_ID_MATCH_INT_CLASS |
 165		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 166	.idVendor = 0x046d,
 167	.idProduct = 0x0850,
 168	.bInterfaceClass = USB_CLASS_AUDIO,
 169	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 170},
 171{
 172	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 173		       USB_DEVICE_ID_MATCH_INT_CLASS |
 174		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 175	.idVendor = 0x046d,
 176	.idProduct = 0x08ae,
 177	.bInterfaceClass = USB_CLASS_AUDIO,
 178	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 179},
 180{
 181	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 182		       USB_DEVICE_ID_MATCH_INT_CLASS |
 183		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 184	.idVendor = 0x046d,
 185	.idProduct = 0x08c6,
 186	.bInterfaceClass = USB_CLASS_AUDIO,
 187	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 188},
 189{
 190	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 191		       USB_DEVICE_ID_MATCH_INT_CLASS |
 192		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 193	.idVendor = 0x046d,
 194	.idProduct = 0x08f0,
 195	.bInterfaceClass = USB_CLASS_AUDIO,
 196	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 197},
 198{
 199	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 200		       USB_DEVICE_ID_MATCH_INT_CLASS |
 201		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 202	.idVendor = 0x046d,
 203	.idProduct = 0x08f5,
 204	.bInterfaceClass = USB_CLASS_AUDIO,
 205	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 206},
 207{
 208	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 209		       USB_DEVICE_ID_MATCH_INT_CLASS |
 210		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 211	.idVendor = 0x046d,
 212	.idProduct = 0x08f6,
 213	.bInterfaceClass = USB_CLASS_AUDIO,
 214	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 215},
 216{
 217	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 218		       USB_DEVICE_ID_MATCH_INT_CLASS |
 219		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 220	.idVendor = 0x046d,
 221	.idProduct = 0x0990,
 222	.bInterfaceClass = USB_CLASS_AUDIO,
 223	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
 224	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 225		.vendor_name = "Logitech, Inc.",
 226		.product_name = "QuickCam Pro 9000",
 227		.ifnum = QUIRK_NO_INTERFACE
 228	}
 229},
 230
 231/*
 232 * Yamaha devices
 233 */
 234
 235#define YAMAHA_DEVICE(id, name) { \
 236	USB_DEVICE(0x0499, id), \
 237	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 238		.vendor_name = "Yamaha", \
 239		.product_name = name, \
 240		.ifnum = QUIRK_ANY_INTERFACE, \
 241		.type = QUIRK_MIDI_YAMAHA \
 242	} \
 243}
 244#define YAMAHA_INTERFACE(id, intf, name) { \
 245	USB_DEVICE_VENDOR_SPEC(0x0499, id), \
 246	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 247		.vendor_name = "Yamaha", \
 248		.product_name = name, \
 249		.ifnum = intf, \
 250		.type = QUIRK_MIDI_YAMAHA \
 251	} \
 252}
 253YAMAHA_DEVICE(0x1000, "UX256"),
 254YAMAHA_DEVICE(0x1001, "MU1000"),
 255YAMAHA_DEVICE(0x1002, "MU2000"),
 256YAMAHA_DEVICE(0x1003, "MU500"),
 257YAMAHA_INTERFACE(0x1004, 3, "UW500"),
 258YAMAHA_DEVICE(0x1005, "MOTIF6"),
 259YAMAHA_DEVICE(0x1006, "MOTIF7"),
 260YAMAHA_DEVICE(0x1007, "MOTIF8"),
 261YAMAHA_DEVICE(0x1008, "UX96"),
 262YAMAHA_DEVICE(0x1009, "UX16"),
 263YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
 264YAMAHA_DEVICE(0x100c, "UC-MX"),
 265YAMAHA_DEVICE(0x100d, "UC-KX"),
 266YAMAHA_DEVICE(0x100e, "S08"),
 267YAMAHA_DEVICE(0x100f, "CLP-150"),
 268YAMAHA_DEVICE(0x1010, "CLP-170"),
 269YAMAHA_DEVICE(0x1011, "P-250"),
 270YAMAHA_DEVICE(0x1012, "TYROS"),
 271YAMAHA_DEVICE(0x1013, "PF-500"),
 272YAMAHA_DEVICE(0x1014, "S90"),
 273YAMAHA_DEVICE(0x1015, "MOTIF-R"),
 274YAMAHA_DEVICE(0x1016, "MDP-5"),
 275YAMAHA_DEVICE(0x1017, "CVP-204"),
 276YAMAHA_DEVICE(0x1018, "CVP-206"),
 277YAMAHA_DEVICE(0x1019, "CVP-208"),
 278YAMAHA_DEVICE(0x101a, "CVP-210"),
 279YAMAHA_DEVICE(0x101b, "PSR-1100"),
 280YAMAHA_DEVICE(0x101c, "PSR-2100"),
 281YAMAHA_DEVICE(0x101d, "CLP-175"),
 282YAMAHA_DEVICE(0x101e, "PSR-K1"),
 283YAMAHA_DEVICE(0x101f, "EZ-J24"),
 284YAMAHA_DEVICE(0x1020, "EZ-250i"),
 285YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
 286YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
 287YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
 288YAMAHA_DEVICE(0x1024, "CVP-301"),
 289YAMAHA_DEVICE(0x1025, "CVP-303"),
 290YAMAHA_DEVICE(0x1026, "CVP-305"),
 291YAMAHA_DEVICE(0x1027, "CVP-307"),
 292YAMAHA_DEVICE(0x1028, "CVP-309"),
 293YAMAHA_DEVICE(0x1029, "CVP-309GP"),
 294YAMAHA_DEVICE(0x102a, "PSR-1500"),
 295YAMAHA_DEVICE(0x102b, "PSR-3000"),
 296YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
 297YAMAHA_DEVICE(0x1030, "PSR-295/293"),
 298YAMAHA_DEVICE(0x1031, "DGX-205/203"),
 299YAMAHA_DEVICE(0x1032, "DGX-305"),
 300YAMAHA_DEVICE(0x1033, "DGX-505"),
 301YAMAHA_DEVICE(0x1034, NULL),
 302YAMAHA_DEVICE(0x1035, NULL),
 303YAMAHA_DEVICE(0x1036, NULL),
 304YAMAHA_DEVICE(0x1037, NULL),
 305YAMAHA_DEVICE(0x1038, NULL),
 306YAMAHA_DEVICE(0x1039, NULL),
 307YAMAHA_DEVICE(0x103a, NULL),
 308YAMAHA_DEVICE(0x103b, NULL),
 309YAMAHA_DEVICE(0x103c, NULL),
 310YAMAHA_DEVICE(0x103d, NULL),
 311YAMAHA_DEVICE(0x103e, NULL),
 312YAMAHA_DEVICE(0x103f, NULL),
 313YAMAHA_DEVICE(0x1040, NULL),
 314YAMAHA_DEVICE(0x1041, NULL),
 315YAMAHA_DEVICE(0x1042, NULL),
 316YAMAHA_DEVICE(0x1043, NULL),
 317YAMAHA_DEVICE(0x1044, NULL),
 318YAMAHA_DEVICE(0x1045, NULL),
 319YAMAHA_INTERFACE(0x104e, 0, NULL),
 320YAMAHA_DEVICE(0x104f, NULL),
 321YAMAHA_DEVICE(0x1050, NULL),
 322YAMAHA_DEVICE(0x1051, NULL),
 323YAMAHA_DEVICE(0x1052, NULL),
 324YAMAHA_INTERFACE(0x1053, 0, NULL),
 325YAMAHA_INTERFACE(0x1054, 0, NULL),
 326YAMAHA_DEVICE(0x1055, NULL),
 327YAMAHA_DEVICE(0x1056, NULL),
 328YAMAHA_DEVICE(0x1057, NULL),
 329YAMAHA_DEVICE(0x1058, NULL),
 330YAMAHA_DEVICE(0x1059, NULL),
 331YAMAHA_DEVICE(0x105a, NULL),
 332YAMAHA_DEVICE(0x105b, NULL),
 333YAMAHA_DEVICE(0x105c, NULL),
 334YAMAHA_DEVICE(0x105d, NULL),
 335{
 336	USB_DEVICE(0x0499, 0x1503),
 337	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 338		/* .vendor_name = "Yamaha", */
 339		/* .product_name = "MOX6/MOX8", */
 340		.ifnum = QUIRK_ANY_INTERFACE,
 341		.type = QUIRK_COMPOSITE,
 342		.data = (const struct snd_usb_audio_quirk[]) {
 343			{
 344				.ifnum = 1,
 345				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 346			},
 347			{
 348				.ifnum = 2,
 349				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 350			},
 351			{
 352				.ifnum = 3,
 353				.type = QUIRK_MIDI_YAMAHA
 354			},
 355			{
 356				.ifnum = -1
 357			}
 358		}
 359	}
 360},
 361{
 362	USB_DEVICE(0x0499, 0x1507),
 363	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 364		/* .vendor_name = "Yamaha", */
 365		/* .product_name = "THR10", */
 366		.ifnum = QUIRK_ANY_INTERFACE,
 367		.type = QUIRK_COMPOSITE,
 368		.data = (const struct snd_usb_audio_quirk[]) {
 369			{
 370				.ifnum = 1,
 371				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 372			},
 373			{
 374				.ifnum = 2,
 375				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 376			},
 377			{
 378				.ifnum = 3,
 379				.type = QUIRK_MIDI_YAMAHA
 380			},
 381			{
 382				.ifnum = -1
 383			}
 384		}
 385	}
 386},
 387{
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 388	USB_DEVICE(0x0499, 0x150a),
 389	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 390		/* .vendor_name = "Yamaha", */
 391		/* .product_name = "THR5A", */
 392		.ifnum = QUIRK_ANY_INTERFACE,
 393		.type = QUIRK_COMPOSITE,
 394		.data = (const struct snd_usb_audio_quirk[]) {
 395			{
 396				.ifnum = 1,
 397				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 398			},
 399			{
 400				.ifnum = 2,
 401				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 402			},
 403			{
 404				.ifnum = 3,
 405				.type = QUIRK_MIDI_YAMAHA
 406			},
 407			{
 408				.ifnum = -1
 409			}
 410		}
 411	}
 412},
 413{
 414	USB_DEVICE(0x0499, 0x150c),
 415	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 416		/* .vendor_name = "Yamaha", */
 417		/* .product_name = "THR10C", */
 418		.ifnum = QUIRK_ANY_INTERFACE,
 419		.type = QUIRK_COMPOSITE,
 420		.data = (const struct snd_usb_audio_quirk[]) {
 421			{
 422				.ifnum = 1,
 423				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 424			},
 425			{
 426				.ifnum = 2,
 427				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 428			},
 429			{
 430				.ifnum = 3,
 431				.type = QUIRK_MIDI_YAMAHA
 432			},
 433			{
 434				.ifnum = -1
 435			}
 436		}
 437	}
 438},
 439YAMAHA_DEVICE(0x2000, "DGP-7"),
 440YAMAHA_DEVICE(0x2001, "DGP-5"),
 441YAMAHA_DEVICE(0x2002, NULL),
 442YAMAHA_DEVICE(0x2003, NULL),
 443YAMAHA_DEVICE(0x5000, "CS1D"),
 444YAMAHA_DEVICE(0x5001, "DSP1D"),
 445YAMAHA_DEVICE(0x5002, "DME32"),
 446YAMAHA_DEVICE(0x5003, "DM2000"),
 447YAMAHA_DEVICE(0x5004, "02R96"),
 448YAMAHA_DEVICE(0x5005, "ACU16-C"),
 449YAMAHA_DEVICE(0x5006, "NHB32-C"),
 450YAMAHA_DEVICE(0x5007, "DM1000"),
 451YAMAHA_DEVICE(0x5008, "01V96"),
 452YAMAHA_DEVICE(0x5009, "SPX2000"),
 453YAMAHA_DEVICE(0x500a, "PM5D"),
 454YAMAHA_DEVICE(0x500b, "DME64N"),
 455YAMAHA_DEVICE(0x500c, "DME24N"),
 456YAMAHA_DEVICE(0x500d, NULL),
 457YAMAHA_DEVICE(0x500e, NULL),
 458YAMAHA_DEVICE(0x500f, NULL),
 459YAMAHA_DEVICE(0x7000, "DTX"),
 460YAMAHA_DEVICE(0x7010, "UB99"),
 461#undef YAMAHA_DEVICE
 462#undef YAMAHA_INTERFACE
 463/* this catches most recent vendor-specific Yamaha devices */
 464{
 465	.match_flags = USB_DEVICE_ID_MATCH_VENDOR |
 466	               USB_DEVICE_ID_MATCH_INT_CLASS,
 467	.idVendor = 0x0499,
 468	.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
 469	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
 470		.ifnum = QUIRK_ANY_INTERFACE,
 471		.type = QUIRK_AUTODETECT
 472	}
 473},
 474
 475/*
 476 * Roland/RolandED/Edirol/BOSS devices
 477 */
 478{
 479	USB_DEVICE(0x0582, 0x0000),
 480	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 481		.vendor_name = "Roland",
 482		.product_name = "UA-100",
 483		.ifnum = QUIRK_ANY_INTERFACE,
 484		.type = QUIRK_COMPOSITE,
 485		.data = (const struct snd_usb_audio_quirk[]) {
 486			{
 487				.ifnum = 0,
 488				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
 489				.data = & (const struct audioformat) {
 490					.formats = SNDRV_PCM_FMTBIT_S16_LE,
 491					.channels = 4,
 492					.iface = 0,
 493					.altsetting = 1,
 494					.altset_idx = 1,
 495					.attributes = 0,
 496					.endpoint = 0x01,
 497					.ep_attr = 0x09,
 498					.rates = SNDRV_PCM_RATE_CONTINUOUS,
 499					.rate_min = 44100,
 500					.rate_max = 44100,
 501				}
 502			},
 503			{
 504				.ifnum = 1,
 505				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
 506				.data = & (const struct audioformat) {
 507					.formats = SNDRV_PCM_FMTBIT_S16_LE,
 508					.channels = 2,
 509					.iface = 1,
 510					.altsetting = 1,
 511					.altset_idx = 1,
 512					.attributes = UAC_EP_CS_ATTR_FILL_MAX,
 513					.endpoint = 0x81,
 514					.ep_attr = 0x05,
 515					.rates = SNDRV_PCM_RATE_CONTINUOUS,
 516					.rate_min = 44100,
 517					.rate_max = 44100,
 518				}
 519			},
 520			{
 521				.ifnum = 2,
 522				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 523				.data = & (const struct snd_usb_midi_endpoint_info) {
 524					.out_cables = 0x0007,
 525					.in_cables  = 0x0007
 526				}
 527			},
 528			{
 529				.ifnum = -1
 530			}
 531		}
 532	}
 533},
 534{
 535	USB_DEVICE(0x0582, 0x0002),
 536	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 537		.vendor_name = "EDIROL",
 538		.product_name = "UM-4",
 539		.ifnum = QUIRK_ANY_INTERFACE,
 540		.type = QUIRK_COMPOSITE,
 541		.data = (const struct snd_usb_audio_quirk[]) {
 542			{
 543				.ifnum = 0,
 544				.type = QUIRK_IGNORE_INTERFACE
 545			},
 546			{
 547				.ifnum = 1,
 548				.type = QUIRK_IGNORE_INTERFACE
 549			},
 550			{
 551				.ifnum = 2,
 552				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 553				.data = & (const struct snd_usb_midi_endpoint_info) {
 554					.out_cables = 0x000f,
 555					.in_cables  = 0x000f
 556				}
 557			},
 558			{
 559				.ifnum = -1
 560			}
 561		}
 562	}
 563},
 564{
 565	USB_DEVICE(0x0582, 0x0003),
 566	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 567		.vendor_name = "Roland",
 568		.product_name = "SC-8850",
 569		.ifnum = QUIRK_ANY_INTERFACE,
 570		.type = QUIRK_COMPOSITE,
 571		.data = (const struct snd_usb_audio_quirk[]) {
 572			{
 573				.ifnum = 0,
 574				.type = QUIRK_IGNORE_INTERFACE
 575			},
 576			{
 577				.ifnum = 1,
 578				.type = QUIRK_IGNORE_INTERFACE
 579			},
 580			{
 581				.ifnum = 2,
 582				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 583				.data = & (const struct snd_usb_midi_endpoint_info) {
 584					.out_cables = 0x003f,
 585					.in_cables  = 0x003f
 586				}
 587			},
 588			{
 589				.ifnum = -1
 590			}
 591		}
 592	}
 593},
 594{
 595	USB_DEVICE(0x0582, 0x0004),
 596	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 597		.vendor_name = "Roland",
 598		.product_name = "U-8",
 599		.ifnum = QUIRK_ANY_INTERFACE,
 600		.type = QUIRK_COMPOSITE,
 601		.data = (const struct snd_usb_audio_quirk[]) {
 602			{
 603				.ifnum = 0,
 604				.type = QUIRK_IGNORE_INTERFACE
 605			},
 606			{
 607				.ifnum = 1,
 608				.type = QUIRK_IGNORE_INTERFACE
 609			},
 610			{
 611				.ifnum = 2,
 612				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 613				.data = & (const struct snd_usb_midi_endpoint_info) {
 614					.out_cables = 0x0005,
 615					.in_cables  = 0x0005
 616				}
 617			},
 618			{
 619				.ifnum = -1
 620			}
 621		}
 622	}
 623},
 624{
 625	/* Has ID 0x0099 when not in "Advanced Driver" mode.
 626	 * The UM-2EX has only one input, but we cannot detect this. */
 627	USB_DEVICE(0x0582, 0x0005),
 628	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 629		.vendor_name = "EDIROL",
 630		.product_name = "UM-2",
 631		.ifnum = QUIRK_ANY_INTERFACE,
 632		.type = QUIRK_COMPOSITE,
 633		.data = (const struct snd_usb_audio_quirk[]) {
 634			{
 635				.ifnum = 0,
 636				.type = QUIRK_IGNORE_INTERFACE
 637			},
 638			{
 639				.ifnum = 1,
 640				.type = QUIRK_IGNORE_INTERFACE
 641			},
 642			{
 643				.ifnum = 2,
 644				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 645				.data = & (const struct snd_usb_midi_endpoint_info) {
 646					.out_cables = 0x0003,
 647					.in_cables  = 0x0003
 648				}
 649			},
 650			{
 651				.ifnum = -1
 652			}
 653		}
 654	}
 655},
 656{
 657	USB_DEVICE(0x0582, 0x0007),
 658	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 659		.vendor_name = "Roland",
 660		.product_name = "SC-8820",
 661		.ifnum = QUIRK_ANY_INTERFACE,
 662		.type = QUIRK_COMPOSITE,
 663		.data = (const struct snd_usb_audio_quirk[]) {
 664			{
 665				.ifnum = 0,
 666				.type = QUIRK_IGNORE_INTERFACE
 667			},
 668			{
 669				.ifnum = 1,
 670				.type = QUIRK_IGNORE_INTERFACE
 671			},
 672			{
 673				.ifnum = 2,
 674				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 675				.data = & (const struct snd_usb_midi_endpoint_info) {
 676					.out_cables = 0x0013,
 677					.in_cables  = 0x0013
 678				}
 679			},
 680			{
 681				.ifnum = -1
 682			}
 683		}
 684	}
 685},
 686{
 687	USB_DEVICE(0x0582, 0x0008),
 688	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 689		.vendor_name = "Roland",
 690		.product_name = "PC-300",
 691		.ifnum = QUIRK_ANY_INTERFACE,
 692		.type = QUIRK_COMPOSITE,
 693		.data = (const struct snd_usb_audio_quirk[]) {
 694			{
 695				.ifnum = 0,
 696				.type = QUIRK_IGNORE_INTERFACE
 697			},
 698			{
 699				.ifnum = 1,
 700				.type = QUIRK_IGNORE_INTERFACE
 701			},
 702			{
 703				.ifnum = 2,
 704				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 705				.data = & (const struct snd_usb_midi_endpoint_info) {
 706					.out_cables = 0x0001,
 707					.in_cables  = 0x0001
 708				}
 709			},
 710			{
 711				.ifnum = -1
 712			}
 713		}
 714	}
 715},
 716{
 717	/* has ID 0x009d when not in "Advanced Driver" mode */
 718	USB_DEVICE(0x0582, 0x0009),
 719	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 720		.vendor_name = "EDIROL",
 721		.product_name = "UM-1",
 722		.ifnum = QUIRK_ANY_INTERFACE,
 723		.type = QUIRK_COMPOSITE,
 724		.data = (const struct snd_usb_audio_quirk[]) {
 725			{
 726				.ifnum = 0,
 727				.type = QUIRK_IGNORE_INTERFACE
 728			},
 729			{
 730				.ifnum = 1,
 731				.type = QUIRK_IGNORE_INTERFACE
 732			},
 733			{
 734				.ifnum = 2,
 735				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 736				.data = & (const struct snd_usb_midi_endpoint_info) {
 737					.out_cables = 0x0001,
 738					.in_cables  = 0x0001
 739				}
 740			},
 741			{
 742				.ifnum = -1
 743			}
 744		}
 745	}
 746},
 747{
 748	USB_DEVICE(0x0582, 0x000b),
 749	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 750		.vendor_name = "Roland",
 751		.product_name = "SK-500",
 752		.ifnum = QUIRK_ANY_INTERFACE,
 753		.type = QUIRK_COMPOSITE,
 754		.data = (const struct snd_usb_audio_quirk[]) {
 755			{
 756				.ifnum = 0,
 757				.type = QUIRK_IGNORE_INTERFACE
 758			},
 759			{
 760				.ifnum = 1,
 761				.type = QUIRK_IGNORE_INTERFACE
 762			},
 763			{
 764				.ifnum = 2,
 765				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 766				.data = & (const struct snd_usb_midi_endpoint_info) {
 767					.out_cables = 0x0013,
 768					.in_cables  = 0x0013
 769				}
 770			},
 771			{
 772				.ifnum = -1
 773			}
 774		}
 775	}
 776},
 777{
 778	/* thanks to Emiliano Grilli <emillo@libero.it>
 779	 * for helping researching this data */
 780	USB_DEVICE(0x0582, 0x000c),
 781	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 782		.vendor_name = "Roland",
 783		.product_name = "SC-D70",
 784		.ifnum = QUIRK_ANY_INTERFACE,
 785		.type = QUIRK_COMPOSITE,
 786		.data = (const struct snd_usb_audio_quirk[]) {
 787			{
 788				.ifnum = 0,
 789				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
 790				.data = & (const struct audioformat) {
 791					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
 792					.channels = 2,
 793					.iface = 0,
 794					.altsetting = 1,
 795					.altset_idx = 1,
 796					.attributes = 0,
 797					.endpoint = 0x01,
 798					.ep_attr = 0x01,
 799					.rates = SNDRV_PCM_RATE_CONTINUOUS,
 800					.rate_min = 44100,
 801					.rate_max = 44100,
 802				}
 803			},
 804			{
 805				.ifnum = 1,
 806				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
 807				.data = & (const struct audioformat) {
 808					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
 809					.channels = 2,
 810					.iface = 1,
 811					.altsetting = 1,
 812					.altset_idx = 1,
 813					.attributes = 0,
 814					.endpoint = 0x81,
 815					.ep_attr = 0x01,
 816					.rates = SNDRV_PCM_RATE_CONTINUOUS,
 817					.rate_min = 44100,
 818					.rate_max = 44100,
 819				}
 820			},
 821			{
 822				.ifnum = 2,
 823				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 824				.data = & (const struct snd_usb_midi_endpoint_info) {
 825					.out_cables = 0x0007,
 826					.in_cables  = 0x0007
 827				}
 828			},
 829			{
 830				.ifnum = -1
 831			}
 832		}
 833	}
 834},
 835{	/*
 836	 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 837	 * If the advanced mode switch at the back of the unit is off, the
 838	 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 839	 * but offers only 16-bit PCM.
 840	 * In advanced mode, the UA-5 will output S24_3LE samples (two
 841	 * channels) at the rate indicated on the front switch, including
 842	 * the 96kHz sample rate.
 843	 */
 844	USB_DEVICE(0x0582, 0x0010),
 845	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 846		.vendor_name = "EDIROL",
 847		.product_name = "UA-5",
 848		.ifnum = QUIRK_ANY_INTERFACE,
 849		.type = QUIRK_COMPOSITE,
 850		.data = (const struct snd_usb_audio_quirk[]) {
 851			{
 852				.ifnum = 1,
 853				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 854			},
 855			{
 856				.ifnum = 2,
 857				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 858			},
 859			{
 860				.ifnum = -1
 861			}
 862		}
 863	}
 864},
 865{
 866	/* has ID 0x0013 when not in "Advanced Driver" mode */
 867	USB_DEVICE(0x0582, 0x0012),
 868	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 869		.vendor_name = "Roland",
 870		.product_name = "XV-5050",
 871		.ifnum = 0,
 872		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 873		.data = & (const struct snd_usb_midi_endpoint_info) {
 874			.out_cables = 0x0001,
 875			.in_cables  = 0x0001
 876		}
 877	}
 878},
 879{
 880	/* has ID 0x0015 when not in "Advanced Driver" mode */
 881	USB_DEVICE(0x0582, 0x0014),
 882	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 883		.vendor_name = "EDIROL",
 884		.product_name = "UM-880",
 885		.ifnum = 0,
 886		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 887		.data = & (const struct snd_usb_midi_endpoint_info) {
 888			.out_cables = 0x01ff,
 889			.in_cables  = 0x01ff
 890		}
 891	}
 892},
 893{
 894	/* has ID 0x0017 when not in "Advanced Driver" mode */
 895	USB_DEVICE(0x0582, 0x0016),
 896	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 897		.vendor_name = "EDIROL",
 898		.product_name = "SD-90",
 899		.ifnum = QUIRK_ANY_INTERFACE,
 900		.type = QUIRK_COMPOSITE,
 901		.data = (const struct snd_usb_audio_quirk[]) {
 902			{
 903				.ifnum = 0,
 904				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 905			},
 906			{
 907				.ifnum = 1,
 908				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 909			},
 910			{
 911				.ifnum = 2,
 912				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 913				.data = & (const struct snd_usb_midi_endpoint_info) {
 914					.out_cables = 0x000f,
 915					.in_cables  = 0x000f
 916				}
 917			},
 918			{
 919				.ifnum = -1
 920			}
 921		}
 922	}
 923},
 924{
 925	/* has ID 0x001c when not in "Advanced Driver" mode */
 926	USB_DEVICE(0x0582, 0x001b),
 927	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 928		.vendor_name = "Roland",
 929		.product_name = "MMP-2",
 930		.ifnum = QUIRK_ANY_INTERFACE,
 931		.type = QUIRK_COMPOSITE,
 932		.data = (const struct snd_usb_audio_quirk[]) {
 933			{
 934				.ifnum = 0,
 935				.type = QUIRK_IGNORE_INTERFACE
 936			},
 937			{
 938				.ifnum = 1,
 939				.type = QUIRK_IGNORE_INTERFACE
 940			},
 941			{
 942				.ifnum = 2,
 943				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 944				.data = & (const struct snd_usb_midi_endpoint_info) {
 945					.out_cables = 0x0001,
 946					.in_cables  = 0x0001
 947				}
 948			},
 949			{
 950				.ifnum = -1
 951			}
 952		}
 953	}
 954},
 955{
 956	/* has ID 0x001e when not in "Advanced Driver" mode */
 957	USB_DEVICE(0x0582, 0x001d),
 958	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 959		.vendor_name = "Roland",
 960		.product_name = "V-SYNTH",
 961		.ifnum = 0,
 962		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 963		.data = & (const struct snd_usb_midi_endpoint_info) {
 964			.out_cables = 0x0001,
 965			.in_cables  = 0x0001
 966		}
 967	}
 968},
 969{
 970	/* has ID 0x0024 when not in "Advanced Driver" mode */
 971	USB_DEVICE(0x0582, 0x0023),
 972	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 973		.vendor_name = "EDIROL",
 974		.product_name = "UM-550",
 975		.ifnum = 0,
 976		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 977		.data = & (const struct snd_usb_midi_endpoint_info) {
 978			.out_cables = 0x003f,
 979			.in_cables  = 0x003f
 980		}
 981	}
 982},
 983{
 984	/*
 985	 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 986	 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 987	 * and no MIDI.
 988	 */
 989	USB_DEVICE(0x0582, 0x0025),
 990	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 991		.vendor_name = "EDIROL",
 992		.product_name = "UA-20",
 993		.ifnum = QUIRK_ANY_INTERFACE,
 994		.type = QUIRK_COMPOSITE,
 995		.data = (const struct snd_usb_audio_quirk[]) {
 996			{
 997				.ifnum = 0,
 998				.type = QUIRK_IGNORE_INTERFACE
 999			},
1000			{
1001				.ifnum = 1,
1002				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
1003				.data = & (const struct audioformat) {
1004					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
1005					.channels = 2,
1006					.iface = 1,
1007					.altsetting = 1,
1008					.altset_idx = 1,
1009					.attributes = 0,
1010					.endpoint = 0x01,
1011					.ep_attr = 0x01,
1012					.rates = SNDRV_PCM_RATE_CONTINUOUS,
1013					.rate_min = 44100,
1014					.rate_max = 44100,
1015				}
1016			},
1017			{
1018				.ifnum = 2,
1019				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
1020				.data = & (const struct audioformat) {
1021					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
1022					.channels = 2,
1023					.iface = 2,
1024					.altsetting = 1,
1025					.altset_idx = 1,
1026					.attributes = 0,
1027					.endpoint = 0x82,
1028					.ep_attr = 0x01,
1029					.rates = SNDRV_PCM_RATE_CONTINUOUS,
1030					.rate_min = 44100,
1031					.rate_max = 44100,
1032				}
1033			},
1034			{
1035				.ifnum = 3,
1036				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1037				.data = & (const struct snd_usb_midi_endpoint_info) {
1038					.out_cables = 0x0001,
1039					.in_cables  = 0x0001
1040				}
1041			},
1042			{
1043				.ifnum = -1
1044			}
1045		}
1046	}
1047},
1048{
1049	/* has ID 0x0028 when not in "Advanced Driver" mode */
1050	USB_DEVICE(0x0582, 0x0027),
1051	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1052		.vendor_name = "EDIROL",
1053		.product_name = "SD-20",
1054		.ifnum = 0,
1055		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1056		.data = & (const struct snd_usb_midi_endpoint_info) {
1057			.out_cables = 0x0003,
1058			.in_cables  = 0x0007
1059		}
1060	}
1061},
1062{
1063	/* has ID 0x002a when not in "Advanced Driver" mode */
1064	USB_DEVICE(0x0582, 0x0029),
1065	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1066		.vendor_name = "EDIROL",
1067		.product_name = "SD-80",
1068		.ifnum = 0,
1069		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1070		.data = & (const struct snd_usb_midi_endpoint_info) {
1071			.out_cables = 0x000f,
1072			.in_cables  = 0x000f
1073		}
1074	}
1075},
1076{	/*
1077	 * This quirk is for the "Advanced" modes of the Edirol UA-700.
1078	 * If the sample format switch is not in an advanced setting, the
1079	 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
1080	 * but offers only 16-bit PCM and no MIDI.
1081	 */
1082	USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
1083	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1084		.vendor_name = "EDIROL",
1085		.product_name = "UA-700",
1086		.ifnum = QUIRK_ANY_INTERFACE,
1087		.type = QUIRK_COMPOSITE,
1088		.data = (const struct snd_usb_audio_quirk[]) {
1089			{
1090				.ifnum = 1,
1091				.type = QUIRK_AUDIO_EDIROL_UAXX
1092			},
1093			{
1094				.ifnum = 2,
1095				.type = QUIRK_AUDIO_EDIROL_UAXX
1096			},
1097			{
1098				.ifnum = 3,
1099				.type = QUIRK_AUDIO_EDIROL_UAXX
1100			},
1101			{
1102				.ifnum = -1
1103			}
1104		}
1105	}
1106},
1107{
1108	/* has ID 0x002e when not in "Advanced Driver" mode */
1109	USB_DEVICE(0x0582, 0x002d),
1110	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1111		.vendor_name = "Roland",
1112		.product_name = "XV-2020",
1113		.ifnum = 0,
1114		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1115		.data = & (const struct snd_usb_midi_endpoint_info) {
1116			.out_cables = 0x0001,
1117			.in_cables  = 0x0001
1118		}
1119	}
1120},
1121{
1122	/* has ID 0x0030 when not in "Advanced Driver" mode */
1123	USB_DEVICE(0x0582, 0x002f),
1124	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1125		.vendor_name = "Roland",
1126		.product_name = "VariOS",
1127		.ifnum = 0,
1128		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1129		.data = & (const struct snd_usb_midi_endpoint_info) {
1130			.out_cables = 0x0007,
1131			.in_cables  = 0x0007
1132		}
1133	}
1134},
1135{
1136	/* has ID 0x0034 when not in "Advanced Driver" mode */
1137	USB_DEVICE(0x0582, 0x0033),
1138	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1139		.vendor_name = "EDIROL",
1140		.product_name = "PCR",
1141		.ifnum = 0,
1142		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1143		.data = & (const struct snd_usb_midi_endpoint_info) {
1144			.out_cables = 0x0003,
1145			.in_cables  = 0x0007
1146		}
1147	}
1148},
1149{
1150	/*
1151	 * Has ID 0x0038 when not in "Advanced Driver" mode;
1152	 * later revisions use IDs 0x0054 and 0x00a2.
1153	 */
1154	USB_DEVICE(0x0582, 0x0037),
1155	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1156		.vendor_name = "Roland",
1157		.product_name = "Digital Piano",
1158		.ifnum = 0,
1159		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1160		.data = & (const struct snd_usb_midi_endpoint_info) {
1161			.out_cables = 0x0001,
1162			.in_cables  = 0x0001
1163		}
1164	}
1165},
1166{
1167	/*
1168	 * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
1169	 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1170	 * and no MIDI.
1171	 */
1172	USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1173	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1174		.vendor_name = "BOSS",
1175		.product_name = "GS-10",
1176		.ifnum = QUIRK_ANY_INTERFACE,
1177		.type = QUIRK_COMPOSITE,
1178		.data = & (const struct snd_usb_audio_quirk[]) {
1179			{
1180				.ifnum = 1,
1181				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1182			},
1183			{
1184				.ifnum = 2,
1185				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1186			},
1187			{
1188				.ifnum = 3,
1189				.type = QUIRK_MIDI_STANDARD_INTERFACE
1190			},
1191			{
1192				.ifnum = -1
1193			}
1194		}
1195	}
1196},
1197{
1198	/* has ID 0x0041 when not in "Advanced Driver" mode */
1199	USB_DEVICE(0x0582, 0x0040),
1200	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1201		.vendor_name = "Roland",
1202		.product_name = "GI-20",
1203		.ifnum = 0,
1204		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1205		.data = & (const struct snd_usb_midi_endpoint_info) {
1206			.out_cables = 0x0001,
1207			.in_cables  = 0x0001
1208		}
1209	}
1210},
1211{
1212	/* has ID 0x0043 when not in "Advanced Driver" mode */
1213	USB_DEVICE(0x0582, 0x0042),
1214	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1215		.vendor_name = "Roland",
1216		.product_name = "RS-70",
1217		.ifnum = 0,
1218		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1219		.data = & (const struct snd_usb_midi_endpoint_info) {
1220			.out_cables = 0x0001,
1221			.in_cables  = 0x0001
1222		}
1223	}
1224},
1225{
1226	/* has ID 0x0049 when not in "Advanced Driver" mode */
1227	USB_DEVICE(0x0582, 0x0047),
1228	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1229		/* .vendor_name = "EDIROL", */
1230		/* .product_name = "UR-80", */
1231		.ifnum = QUIRK_ANY_INTERFACE,
1232		.type = QUIRK_COMPOSITE,
1233		.data = (const struct snd_usb_audio_quirk[]) {
1234			/* in the 96 kHz modes, only interface 1 is there */
1235			{
1236				.ifnum = 1,
1237				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1238			},
1239			{
1240				.ifnum = 2,
1241				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1242			},
1243			{
1244				.ifnum = -1
1245			}
1246		}
1247	}
1248},
1249{
1250	/* has ID 0x004a when not in "Advanced Driver" mode */
1251	USB_DEVICE(0x0582, 0x0048),
1252	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1253		/* .vendor_name = "EDIROL", */
1254		/* .product_name = "UR-80", */
1255		.ifnum = 0,
1256		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1257		.data = & (const struct snd_usb_midi_endpoint_info) {
1258			.out_cables = 0x0003,
1259			.in_cables  = 0x0007
1260		}
1261	}
1262},
1263{
1264	/* has ID 0x004e when not in "Advanced Driver" mode */
1265	USB_DEVICE(0x0582, 0x004c),
1266	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1267		.vendor_name = "EDIROL",
1268		.product_name = "PCR-A",
1269		.ifnum = QUIRK_ANY_INTERFACE,
1270		.type = QUIRK_COMPOSITE,
1271		.data = (const struct snd_usb_audio_quirk[]) {
1272			{
1273				.ifnum = 1,
1274				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1275			},
1276			{
1277				.ifnum = 2,
1278				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1279			},
1280			{
1281				.ifnum = -1
1282			}
1283		}
1284	}
1285},
1286{
1287	/* has ID 0x004f when not in "Advanced Driver" mode */
1288	USB_DEVICE(0x0582, 0x004d),
1289	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1290		.vendor_name = "EDIROL",
1291		.product_name = "PCR-A",
1292		.ifnum = 0,
1293		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1294		.data = & (const struct snd_usb_midi_endpoint_info) {
1295			.out_cables = 0x0003,
1296			.in_cables  = 0x0007
1297		}
1298	}
1299},
1300{
1301	/*
1302	 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1303	 * is standard compliant, but has only 16-bit PCM.
1304	 */
1305	USB_DEVICE(0x0582, 0x0050),
1306	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1307		.vendor_name = "EDIROL",
1308		.product_name = "UA-3FX",
1309		.ifnum = QUIRK_ANY_INTERFACE,
1310		.type = QUIRK_COMPOSITE,
1311		.data = (const struct snd_usb_audio_quirk[]) {
1312			{
1313				.ifnum = 1,
1314				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1315			},
1316			{
1317				.ifnum = 2,
1318				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1319			},
1320			{
1321				.ifnum = -1
1322			}
1323		}
1324	}
1325},
1326{
1327	USB_DEVICE(0x0582, 0x0052),
1328	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1329		.vendor_name = "EDIROL",
1330		.product_name = "UM-1SX",
1331		.ifnum = 0,
1332		.type = QUIRK_MIDI_STANDARD_INTERFACE
1333	}
1334},
1335{
1336	USB_DEVICE(0x0582, 0x0060),
1337	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1338		.vendor_name = "Roland",
1339		.product_name = "EXR Series",
1340		.ifnum = 0,
1341		.type = QUIRK_MIDI_STANDARD_INTERFACE
1342	}
1343},
1344{
1345	/* has ID 0x0066 when not in "Advanced Driver" mode */
1346	USB_DEVICE(0x0582, 0x0064),
1347	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1348		/* .vendor_name = "EDIROL", */
1349		/* .product_name = "PCR-1", */
1350		.ifnum = QUIRK_ANY_INTERFACE,
1351		.type = QUIRK_COMPOSITE,
1352		.data = (const struct snd_usb_audio_quirk[]) {
1353			{
1354				.ifnum = 1,
1355				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1356			},
1357			{
1358				.ifnum = 2,
1359				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1360			},
1361			{
1362				.ifnum = -1
1363			}
1364		}
1365	}
1366},
1367{
1368	/* has ID 0x0067 when not in "Advanced Driver" mode */
1369	USB_DEVICE(0x0582, 0x0065),
1370	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1371		/* .vendor_name = "EDIROL", */
1372		/* .product_name = "PCR-1", */
1373		.ifnum = 0,
1374		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1375		.data = & (const struct snd_usb_midi_endpoint_info) {
1376			.out_cables = 0x0001,
1377			.in_cables  = 0x0003
1378		}
1379	}
1380},
1381{
1382	/* has ID 0x006e when not in "Advanced Driver" mode */
1383	USB_DEVICE(0x0582, 0x006d),
1384	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1385		.vendor_name = "Roland",
1386		.product_name = "FANTOM-X",
1387		.ifnum = 0,
1388		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1389		.data = & (const struct snd_usb_midi_endpoint_info) {
1390			.out_cables = 0x0001,
1391			.in_cables  = 0x0001
1392		}
1393	}
1394},
1395{	/*
1396	 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1397	 * If the switch is not in an advanced setting, the UA-25 has
1398	 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1399	 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1400	 */
1401	USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1402	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1403		.vendor_name = "EDIROL",
1404		.product_name = "UA-25",
1405		.ifnum = QUIRK_ANY_INTERFACE,
1406		.type = QUIRK_COMPOSITE,
1407		.data = (const struct snd_usb_audio_quirk[]) {
1408			{
1409				.ifnum = 0,
1410				.type = QUIRK_AUDIO_EDIROL_UAXX
1411			},
1412			{
1413				.ifnum = 1,
1414				.type = QUIRK_AUDIO_EDIROL_UAXX
1415			},
1416			{
1417				.ifnum = 2,
1418				.type = QUIRK_AUDIO_EDIROL_UAXX
1419			},
1420			{
1421				.ifnum = -1
1422			}
1423		}
1424	}
1425},
1426{
1427	/* has ID 0x0076 when not in "Advanced Driver" mode */
1428	USB_DEVICE(0x0582, 0x0075),
1429	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1430		.vendor_name = "BOSS",
1431		.product_name = "DR-880",
1432		.ifnum = 0,
1433		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1434		.data = & (const struct snd_usb_midi_endpoint_info) {
1435			.out_cables = 0x0001,
1436			.in_cables  = 0x0001
1437		}
1438	}
1439},
1440{
1441	/* has ID 0x007b when not in "Advanced Driver" mode */
1442	USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1443	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1444		.vendor_name = "Roland",
1445		/* "RD" or "RD-700SX"? */
1446		.ifnum = 0,
1447		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1448		.data = & (const struct snd_usb_midi_endpoint_info) {
1449			.out_cables = 0x0003,
1450			.in_cables  = 0x0003
1451		}
1452	}
1453},
1454{
1455	/* has ID 0x0081 when not in "Advanced Driver" mode */
1456	USB_DEVICE(0x0582, 0x0080),
1457	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1458		.vendor_name = "Roland",
1459		.product_name = "G-70",
1460		.ifnum = 0,
1461		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1462		.data = & (const struct snd_usb_midi_endpoint_info) {
1463			.out_cables = 0x0001,
1464			.in_cables  = 0x0001
1465		}
1466	}
1467},
1468{
1469	/* has ID 0x008c when not in "Advanced Driver" mode */
1470	USB_DEVICE(0x0582, 0x008b),
1471	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1472		.vendor_name = "EDIROL",
1473		.product_name = "PC-50",
1474		.ifnum = 0,
1475		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1476		.data = & (const struct snd_usb_midi_endpoint_info) {
1477			.out_cables = 0x0001,
1478			.in_cables  = 0x0001
1479		}
1480	}
1481},
1482{
1483	/*
1484	 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1485	 * is standard compliant, but has only 16-bit PCM and no MIDI.
1486	 */
1487	USB_DEVICE(0x0582, 0x00a3),
1488	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1489		.vendor_name = "EDIROL",
1490		.product_name = "UA-4FX",
1491		.ifnum = QUIRK_ANY_INTERFACE,
1492		.type = QUIRK_COMPOSITE,
1493		.data = (const struct snd_usb_audio_quirk[]) {
1494			{
1495				.ifnum = 0,
1496				.type = QUIRK_AUDIO_EDIROL_UAXX
1497			},
1498			{
1499				.ifnum = 1,
1500				.type = QUIRK_AUDIO_EDIROL_UAXX
1501			},
1502			{
1503				.ifnum = 2,
1504				.type = QUIRK_AUDIO_EDIROL_UAXX
1505			},
1506			{
1507				.ifnum = -1
1508			}
1509		}
1510	}
1511},
1512{
1513	/* Edirol M-16DX */
1514	USB_DEVICE(0x0582, 0x00c4),
1515	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1516		.ifnum = QUIRK_ANY_INTERFACE,
1517		.type = QUIRK_COMPOSITE,
1518		.data = (const struct snd_usb_audio_quirk[]) {
1519			{
1520				.ifnum = 0,
1521				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1522			},
1523			{
1524				.ifnum = 1,
1525				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1526			},
1527			{
1528				.ifnum = 2,
1529				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1530				.data = & (const struct snd_usb_midi_endpoint_info) {
1531					.out_cables = 0x0001,
1532					.in_cables  = 0x0001
1533				}
1534			},
1535			{
1536				.ifnum = -1
1537			}
1538		}
1539	}
1540},
1541{
1542	/* Advanced modes of the Edirol UA-25EX.
1543	 * For the standard mode, UA-25EX has ID 0582:00e7, which
1544	 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1545	 */
1546	USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1547	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1548		.vendor_name = "EDIROL",
1549		.product_name = "UA-25EX",
1550		.ifnum = QUIRK_ANY_INTERFACE,
1551		.type = QUIRK_COMPOSITE,
1552		.data = (const struct snd_usb_audio_quirk[]) {
1553			{
1554				.ifnum = 0,
1555				.type = QUIRK_AUDIO_EDIROL_UAXX
1556			},
1557			{
1558				.ifnum = 1,
1559				.type = QUIRK_AUDIO_EDIROL_UAXX
1560			},
1561			{
1562				.ifnum = 2,
1563				.type = QUIRK_AUDIO_EDIROL_UAXX
1564			},
1565			{
1566				.ifnum = -1
1567			}
1568		}
1569	}
1570},
1571{
1572	/* Edirol UM-3G */
1573	USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1574	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1575		.ifnum = 0,
1576		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1577		.data = & (const struct snd_usb_midi_endpoint_info) {
1578			.out_cables = 0x0007,
1579			.in_cables  = 0x0007
1580		}
1581	}
1582},
1583{
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1584	/* only 44.1 kHz works at the moment */
1585	USB_DEVICE(0x0582, 0x0120),
1586	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1587		/* .vendor_name = "Roland", */
1588		/* .product_name = "OCTO-CAPTURE", */
1589		.ifnum = QUIRK_ANY_INTERFACE,
1590		.type = QUIRK_COMPOSITE,
1591		.data = (const struct snd_usb_audio_quirk[]) {
1592			{
1593				.ifnum = 0,
1594				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
1595				.data = & (const struct audioformat) {
1596					.formats = SNDRV_PCM_FMTBIT_S32_LE,
1597					.channels = 10,
1598					.iface = 0,
1599					.altsetting = 1,
1600					.altset_idx = 1,
1601					.endpoint = 0x05,
1602					.ep_attr = 0x05,
1603					.rates = SNDRV_PCM_RATE_44100,
1604					.rate_min = 44100,
1605					.rate_max = 44100,
1606					.nr_rates = 1,
1607					.rate_table = (unsigned int[]) { 44100 }
1608				}
1609			},
1610			{
1611				.ifnum = 1,
1612				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
1613				.data = & (const struct audioformat) {
1614					.formats = SNDRV_PCM_FMTBIT_S32_LE,
1615					.channels = 12,
1616					.iface = 1,
1617					.altsetting = 1,
1618					.altset_idx = 1,
1619					.endpoint = 0x85,
1620					.ep_attr = 0x25,
1621					.rates = SNDRV_PCM_RATE_44100,
1622					.rate_min = 44100,
1623					.rate_max = 44100,
1624					.nr_rates = 1,
1625					.rate_table = (unsigned int[]) { 44100 }
1626				}
1627			},
1628			{
1629				.ifnum = 2,
1630				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1631				.data = & (const struct snd_usb_midi_endpoint_info) {
1632					.out_cables = 0x0001,
1633					.in_cables  = 0x0001
1634				}
1635			},
1636			{
1637				.ifnum = 3,
1638				.type = QUIRK_IGNORE_INTERFACE
1639			},
1640			{
1641				.ifnum = 4,
1642				.type = QUIRK_IGNORE_INTERFACE
1643			},
1644			{
1645				.ifnum = -1
1646			}
1647		}
1648	}
1649},
1650{
1651	/* only 44.1 kHz works at the moment */
1652	USB_DEVICE(0x0582, 0x012f),
1653	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1654		/* .vendor_name = "Roland", */
1655		/* .product_name = "QUAD-CAPTURE", */
1656		.ifnum = QUIRK_ANY_INTERFACE,
1657		.type = QUIRK_COMPOSITE,
1658		.data = (const struct snd_usb_audio_quirk[]) {
1659			{
1660				.ifnum = 0,
1661				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
1662				.data = & (const struct audioformat) {
1663					.formats = SNDRV_PCM_FMTBIT_S32_LE,
1664					.channels = 4,
1665					.iface = 0,
1666					.altsetting = 1,
1667					.altset_idx = 1,
1668					.endpoint = 0x05,
1669					.ep_attr = 0x05,
1670					.rates = SNDRV_PCM_RATE_44100,
1671					.rate_min = 44100,
1672					.rate_max = 44100,
1673					.nr_rates = 1,
1674					.rate_table = (unsigned int[]) { 44100 }
1675				}
1676			},
1677			{
1678				.ifnum = 1,
1679				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
1680				.data = & (const struct audioformat) {
1681					.formats = SNDRV_PCM_FMTBIT_S32_LE,
1682					.channels = 6,
1683					.iface = 1,
1684					.altsetting = 1,
1685					.altset_idx = 1,
1686					.endpoint = 0x85,
1687					.ep_attr = 0x25,
1688					.rates = SNDRV_PCM_RATE_44100,
1689					.rate_min = 44100,
1690					.rate_max = 44100,
1691					.nr_rates = 1,
1692					.rate_table = (unsigned int[]) { 44100 }
1693				}
1694			},
1695			{
1696				.ifnum = 2,
1697				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1698				.data = & (const struct snd_usb_midi_endpoint_info) {
1699					.out_cables = 0x0001,
1700					.in_cables  = 0x0001
1701				}
1702			},
1703			{
1704				.ifnum = 3,
1705				.type = QUIRK_IGNORE_INTERFACE
1706			},
1707			{
1708				.ifnum = 4,
1709				.type = QUIRK_IGNORE_INTERFACE
1710			},
1711			{
1712				.ifnum = -1
1713			}
1714		}
1715	}
1716},
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1717/* this catches most recent vendor-specific Roland devices */
1718{
1719	.match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1720	               USB_DEVICE_ID_MATCH_INT_CLASS,
1721	.idVendor = 0x0582,
1722	.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1723	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1724		.ifnum = QUIRK_ANY_INTERFACE,
1725		.type = QUIRK_AUTODETECT
1726	}
1727},
1728
1729/* Guillemot devices */
1730{
1731	/*
1732	 * This is for the "Windows Edition" where the external MIDI ports are
1733	 * the only MIDI ports; the control data is reported through HID
1734	 * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1735	 * compliant USB MIDI ports for external MIDI and controls.
1736	 */
1737	USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1738	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1739		.vendor_name = "Hercules",
1740		.product_name = "DJ Console (WE)",
1741		.ifnum = 4,
1742		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1743		.data = & (const struct snd_usb_midi_endpoint_info) {
1744			.out_cables = 0x0001,
1745			.in_cables = 0x0001
1746		}
1747	}
1748},
1749
1750/* Midiman/M-Audio devices */
1751{
1752	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1753	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1754		.vendor_name = "M-Audio",
1755		.product_name = "MidiSport 2x2",
1756		.ifnum = QUIRK_ANY_INTERFACE,
1757		.type = QUIRK_MIDI_MIDIMAN,
1758		.data = & (const struct snd_usb_midi_endpoint_info) {
1759			.out_cables = 0x0003,
1760			.in_cables  = 0x0003
1761		}
1762	}
1763},
1764{
1765	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1766	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1767		.vendor_name = "M-Audio",
1768		.product_name = "MidiSport 1x1",
1769		.ifnum = QUIRK_ANY_INTERFACE,
1770		.type = QUIRK_MIDI_MIDIMAN,
1771		.data = & (const struct snd_usb_midi_endpoint_info) {
1772			.out_cables = 0x0001,
1773			.in_cables  = 0x0001
1774		}
1775	}
1776},
1777{
1778	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1779	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1780		.vendor_name = "M-Audio",
1781		.product_name = "Keystation",
1782		.ifnum = QUIRK_ANY_INTERFACE,
1783		.type = QUIRK_MIDI_MIDIMAN,
1784		.data = & (const struct snd_usb_midi_endpoint_info) {
1785			.out_cables = 0x0001,
1786			.in_cables  = 0x0001
1787		}
1788	}
1789},
1790{
1791	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1792	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1793		.vendor_name = "M-Audio",
1794		.product_name = "MidiSport 4x4",
1795		.ifnum = QUIRK_ANY_INTERFACE,
1796		.type = QUIRK_MIDI_MIDIMAN,
1797		.data = & (const struct snd_usb_midi_endpoint_info) {
1798			.out_cables = 0x000f,
1799			.in_cables  = 0x000f
1800		}
1801	}
1802},
1803{
1804	/*
1805	 * For hardware revision 1.05; in the later revisions (1.10 and
1806	 * 1.21), 0x1031 is the ID for the device without firmware.
1807	 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1808	 */
1809	USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1810	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1811		.vendor_name = "M-Audio",
1812		.product_name = "MidiSport 8x8",
1813		.ifnum = QUIRK_ANY_INTERFACE,
1814		.type = QUIRK_MIDI_MIDIMAN,
1815		.data = & (const struct snd_usb_midi_endpoint_info) {
1816			.out_cables = 0x01ff,
1817			.in_cables  = 0x01ff
1818		}
1819	}
1820},
1821{
1822	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1823	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1824		.vendor_name = "M-Audio",
1825		.product_name = "MidiSport 8x8",
1826		.ifnum = QUIRK_ANY_INTERFACE,
1827		.type = QUIRK_MIDI_MIDIMAN,
1828		.data = & (const struct snd_usb_midi_endpoint_info) {
1829			.out_cables = 0x01ff,
1830			.in_cables  = 0x01ff
1831		}
1832	}
1833},
1834{
1835	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1836	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1837		.vendor_name = "M-Audio",
1838		.product_name = "MidiSport 2x4",
1839		.ifnum = QUIRK_ANY_INTERFACE,
1840		.type = QUIRK_MIDI_MIDIMAN,
1841		.data = & (const struct snd_usb_midi_endpoint_info) {
1842			.out_cables = 0x000f,
1843			.in_cables  = 0x0003
1844		}
1845	}
1846},
1847{
1848	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1849	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1850		.vendor_name = "M-Audio",
1851		.product_name = "Quattro",
1852		.ifnum = QUIRK_ANY_INTERFACE,
1853		.type = QUIRK_COMPOSITE,
1854		.data = & (const struct snd_usb_audio_quirk[]) {
1855			/*
1856			 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1857			 * and share endpoints with the other interfaces.
1858			 * Ignore them.  The other interfaces can do 24 bits,
1859			 * but captured samples are big-endian (see usbaudio.c).
1860			 */
1861			{
1862				.ifnum = 0,
1863				.type = QUIRK_IGNORE_INTERFACE
1864			},
1865			{
1866				.ifnum = 1,
1867				.type = QUIRK_IGNORE_INTERFACE
1868			},
1869			{
1870				.ifnum = 2,
1871				.type = QUIRK_IGNORE_INTERFACE
1872			},
1873			{
1874				.ifnum = 3,
1875				.type = QUIRK_IGNORE_INTERFACE
1876			},
1877			{
1878				.ifnum = 4,
1879				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1880			},
1881			{
1882				.ifnum = 5,
1883				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1884			},
1885			{
1886				.ifnum = 6,
1887				.type = QUIRK_IGNORE_INTERFACE
1888			},
1889			{
1890				.ifnum = 7,
1891				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1892			},
1893			{
1894				.ifnum = 8,
1895				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1896			},
1897			{
1898				.ifnum = 9,
1899				.type = QUIRK_MIDI_MIDIMAN,
1900				.data = & (const struct snd_usb_midi_endpoint_info) {
1901					.out_cables = 0x0001,
1902					.in_cables  = 0x0001
1903				}
1904			},
1905			{
1906				.ifnum = -1
1907			}
1908		}
1909	}
1910},
1911{
1912	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1913	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1914		.vendor_name = "M-Audio",
1915		.product_name = "AudioPhile",
1916		.ifnum = 6,
1917		.type = QUIRK_MIDI_MIDIMAN,
1918		.data = & (const struct snd_usb_midi_endpoint_info) {
1919			.out_cables = 0x0001,
1920			.in_cables  = 0x0001
1921		}
1922	}
1923},
1924{
1925	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1926	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1927		.vendor_name = "M-Audio",
1928		.product_name = "Ozone",
1929		.ifnum = 3,
1930		.type = QUIRK_MIDI_MIDIMAN,
1931		.data = & (const struct snd_usb_midi_endpoint_info) {
1932			.out_cables = 0x0001,
1933			.in_cables  = 0x0001
1934		}
1935	}
1936},
1937{
1938	USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1939	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1940		.vendor_name = "M-Audio",
1941		.product_name = "OmniStudio",
1942		.ifnum = QUIRK_ANY_INTERFACE,
1943		.type = QUIRK_COMPOSITE,
1944		.data = & (const struct snd_usb_audio_quirk[]) {
1945			{
1946				.ifnum = 0,
1947				.type = QUIRK_IGNORE_INTERFACE
1948			},
1949			{
1950				.ifnum = 1,
1951				.type = QUIRK_IGNORE_INTERFACE
1952			},
1953			{
1954				.ifnum = 2,
1955				.type = QUIRK_IGNORE_INTERFACE
1956			},
1957			{
1958				.ifnum = 3,
1959				.type = QUIRK_IGNORE_INTERFACE
1960			},
1961			{
1962				.ifnum = 4,
1963				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1964			},
1965			{
1966				.ifnum = 5,
1967				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1968			},
1969			{
1970				.ifnum = 6,
1971				.type = QUIRK_IGNORE_INTERFACE
1972			},
1973			{
1974				.ifnum = 7,
1975				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1976			},
1977			{
1978				.ifnum = 8,
1979				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1980			},
1981			{
1982				.ifnum = 9,
1983				.type = QUIRK_MIDI_MIDIMAN,
1984				.data = & (const struct snd_usb_midi_endpoint_info) {
1985					.out_cables = 0x0001,
1986					.in_cables  = 0x0001
1987				}
1988			},
1989			{
1990				.ifnum = -1
1991			}
1992		}
1993	}
1994},
1995{
1996	USB_DEVICE(0x0763, 0x2019),
1997	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1998		/* .vendor_name = "M-Audio", */
1999		/* .product_name = "Ozone Academic", */
2000		.ifnum = QUIRK_ANY_INTERFACE,
2001		.type = QUIRK_COMPOSITE,
2002		.data = & (const struct snd_usb_audio_quirk[]) {
2003			{
2004				.ifnum = 0,
2005				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2006			},
2007			{
2008				.ifnum = 1,
2009				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2010			},
2011			{
2012				.ifnum = 2,
2013				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2014			},
2015			{
2016				.ifnum = 3,
2017				.type = QUIRK_MIDI_MIDIMAN,
2018				.data = & (const struct snd_usb_midi_endpoint_info) {
2019					.out_cables = 0x0001,
2020					.in_cables  = 0x0001
2021				}
2022			},
2023			{
2024				.ifnum = -1
2025			}
2026		}
2027	}
2028},
2029{
2030	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2031	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2032		/* .vendor_name = "M-Audio", */
2033		/* .product_name = "Fast Track C400", */
2034		.ifnum = QUIRK_ANY_INTERFACE,
2035		.type = QUIRK_COMPOSITE,
2036		.data = &(const struct snd_usb_audio_quirk[]) {
2037			{
2038				.ifnum = 1,
2039				.type = QUIRK_AUDIO_STANDARD_MIXER,
2040			},
2041			/* Playback */
2042			{
2043				.ifnum = 2,
2044				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2045				.data = &(const struct audioformat) {
2046					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2047					.channels = 6,
2048					.iface = 2,
2049					.altsetting = 1,
2050					.altset_idx = 1,
2051					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2052					.endpoint = 0x01,
2053					.ep_attr = 0x09,
2054					.rates = SNDRV_PCM_RATE_44100 |
2055						 SNDRV_PCM_RATE_48000 |
2056						 SNDRV_PCM_RATE_88200 |
2057						 SNDRV_PCM_RATE_96000,
2058					.rate_min = 44100,
2059					.rate_max = 96000,
2060					.nr_rates = 4,
2061					.rate_table = (unsigned int[]) {
2062							44100, 48000, 88200, 96000
2063					},
2064					.clock = 0x80,
2065				}
2066			},
2067			/* Capture */
2068			{
2069				.ifnum = 3,
2070				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2071				.data = &(const struct audioformat) {
2072					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2073					.channels = 4,
2074					.iface = 3,
2075					.altsetting = 1,
2076					.altset_idx = 1,
2077					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2078					.endpoint = 0x81,
2079					.ep_attr = 0x05,
2080					.rates = SNDRV_PCM_RATE_44100 |
2081						 SNDRV_PCM_RATE_48000 |
2082						 SNDRV_PCM_RATE_88200 |
2083						 SNDRV_PCM_RATE_96000,
2084					.rate_min = 44100,
2085					.rate_max = 96000,
2086					.nr_rates = 4,
2087					.rate_table = (unsigned int[]) {
2088						44100, 48000, 88200, 96000
2089					},
2090					.clock = 0x80,
2091				}
2092			},
2093			/* MIDI */
2094			{
2095				.ifnum = -1 /* Interface = 4 */
2096			}
2097		}
2098	}
2099},
2100{
2101	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2102	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2103		/* .vendor_name = "M-Audio", */
2104		/* .product_name = "Fast Track C600", */
2105		.ifnum = QUIRK_ANY_INTERFACE,
2106		.type = QUIRK_COMPOSITE,
2107		.data = &(const struct snd_usb_audio_quirk[]) {
2108			{
2109				.ifnum = 1,
2110				.type = QUIRK_AUDIO_STANDARD_MIXER,
2111			},
2112			/* Playback */
2113			{
2114				.ifnum = 2,
2115				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2116				.data = &(const struct audioformat) {
2117					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2118					.channels = 8,
2119					.iface = 2,
2120					.altsetting = 1,
2121					.altset_idx = 1,
2122					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2123					.endpoint = 0x01,
2124					.ep_attr = 0x09,
2125					.rates = SNDRV_PCM_RATE_44100 |
2126						 SNDRV_PCM_RATE_48000 |
2127						 SNDRV_PCM_RATE_88200 |
2128						 SNDRV_PCM_RATE_96000,
2129					.rate_min = 44100,
2130					.rate_max = 96000,
2131					.nr_rates = 4,
2132					.rate_table = (unsigned int[]) {
2133							44100, 48000, 88200, 96000
2134					},
2135					.clock = 0x80,
2136				}
2137			},
2138			/* Capture */
2139			{
2140				.ifnum = 3,
2141				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2142				.data = &(const struct audioformat) {
2143					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2144					.channels = 6,
2145					.iface = 3,
2146					.altsetting = 1,
2147					.altset_idx = 1,
2148					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2149					.endpoint = 0x81,
2150					.ep_attr = 0x05,
2151					.rates = SNDRV_PCM_RATE_44100 |
2152						 SNDRV_PCM_RATE_48000 |
2153						 SNDRV_PCM_RATE_88200 |
2154						 SNDRV_PCM_RATE_96000,
2155					.rate_min = 44100,
2156					.rate_max = 96000,
2157					.nr_rates = 4,
2158					.rate_table = (unsigned int[]) {
2159						44100, 48000, 88200, 96000
2160					},
2161					.clock = 0x80,
2162				}
2163			},
2164			/* MIDI */
2165			{
2166				.ifnum = -1 /* Interface = 4 */
2167			}
2168		}
2169	}
2170},
2171{
2172	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2173	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2174		/* .vendor_name = "M-Audio", */
2175		/* .product_name = "Fast Track Ultra", */
2176		.ifnum = QUIRK_ANY_INTERFACE,
2177		.type = QUIRK_COMPOSITE,
2178		.data = & (const struct snd_usb_audio_quirk[]) {
2179			{
2180				.ifnum = 0,
2181				.type = QUIRK_AUDIO_STANDARD_MIXER,
2182			},
2183			{
2184				.ifnum = 1,
2185				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2186				.data = & (const struct audioformat) {
2187					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2188					.channels = 8,
2189					.iface = 1,
2190					.altsetting = 1,
2191					.altset_idx = 1,
2192					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2193					.endpoint = 0x01,
2194					.ep_attr = 0x09,
2195					.rates = SNDRV_PCM_RATE_44100 |
2196						 SNDRV_PCM_RATE_48000 |
2197						 SNDRV_PCM_RATE_88200 |
2198						 SNDRV_PCM_RATE_96000,
2199					.rate_min = 44100,
2200					.rate_max = 96000,
2201					.nr_rates = 4,
2202					.rate_table = (unsigned int[]) {
2203						44100, 48000, 88200, 96000
2204					}
2205				}
2206			},
2207			{
2208				.ifnum = 2,
2209				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2210				.data = & (const struct audioformat) {
2211					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2212					.channels = 8,
2213					.iface = 2,
2214					.altsetting = 1,
2215					.altset_idx = 1,
2216					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2217					.endpoint = 0x81,
2218					.ep_attr = 0x05,
2219					.rates = SNDRV_PCM_RATE_44100 |
2220						 SNDRV_PCM_RATE_48000 |
2221						 SNDRV_PCM_RATE_88200 |
2222						 SNDRV_PCM_RATE_96000,
2223					.rate_min = 44100,
2224					.rate_max = 96000,
2225					.nr_rates = 4,
2226					.rate_table = (unsigned int[]) {
2227						44100, 48000, 88200, 96000
2228					}
2229				}
2230			},
2231			/* interface 3 (MIDI) is standard compliant */
2232			{
2233				.ifnum = -1
2234			}
2235		}
2236	}
2237},
2238{
2239	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2240	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2241		/* .vendor_name = "M-Audio", */
2242		/* .product_name = "Fast Track Ultra 8R", */
2243		.ifnum = QUIRK_ANY_INTERFACE,
2244		.type = QUIRK_COMPOSITE,
2245		.data = & (const struct snd_usb_audio_quirk[]) {
2246			{
2247				.ifnum = 0,
2248				.type = QUIRK_AUDIO_STANDARD_MIXER,
2249			},
2250			{
2251				.ifnum = 1,
2252				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2253				.data = & (const struct audioformat) {
2254					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2255					.channels = 8,
2256					.iface = 1,
2257					.altsetting = 1,
2258					.altset_idx = 1,
2259					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2260					.endpoint = 0x01,
2261					.ep_attr = 0x09,
2262					.rates = SNDRV_PCM_RATE_44100 |
2263						 SNDRV_PCM_RATE_48000 |
2264						 SNDRV_PCM_RATE_88200 |
2265						 SNDRV_PCM_RATE_96000,
2266					.rate_min = 44100,
2267					.rate_max = 96000,
2268					.nr_rates = 4,
2269					.rate_table = (unsigned int[]) {
2270							44100, 48000, 88200, 96000
2271					}
2272				}
2273			},
2274			{
2275				.ifnum = 2,
2276				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2277				.data = & (const struct audioformat) {
2278					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2279					.channels = 8,
2280					.iface = 2,
2281					.altsetting = 1,
2282					.altset_idx = 1,
2283					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2284					.endpoint = 0x81,
2285					.ep_attr = 0x05,
2286					.rates = SNDRV_PCM_RATE_44100 |
2287						 SNDRV_PCM_RATE_48000 |
2288						 SNDRV_PCM_RATE_88200 |
2289						 SNDRV_PCM_RATE_96000,
2290					.rate_min = 44100,
2291					.rate_max = 96000,
2292					.nr_rates = 4,
2293					.rate_table = (unsigned int[]) {
2294						44100, 48000, 88200, 96000
2295					}
2296				}
2297			},
2298			/* interface 3 (MIDI) is standard compliant */
2299			{
2300				.ifnum = -1
2301			}
2302		}
2303	}
2304},
2305
2306/* Casio devices */
2307{
2308	USB_DEVICE(0x07cf, 0x6801),
2309	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2310		.vendor_name = "Casio",
2311		.product_name = "PL-40R",
2312		.ifnum = 0,
2313		.type = QUIRK_MIDI_YAMAHA
2314	}
2315},
2316{
2317	/* this ID is used by several devices without a product ID */
2318	USB_DEVICE(0x07cf, 0x6802),
2319	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2320		.vendor_name = "Casio",
2321		.product_name = "Keyboard",
2322		.ifnum = 0,
2323		.type = QUIRK_MIDI_YAMAHA
2324	}
2325},
2326
2327/* Mark of the Unicorn devices */
2328{
2329	/* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2330	.match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2331		       USB_DEVICE_ID_MATCH_PRODUCT |
2332		       USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2333	.idVendor = 0x07fd,
2334	.idProduct = 0x0001,
2335	.bDeviceSubClass = 2,
2336	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2337		.vendor_name = "MOTU",
2338		.product_name = "Fastlane",
2339		.ifnum = QUIRK_ANY_INTERFACE,
2340		.type = QUIRK_COMPOSITE,
2341		.data = & (const struct snd_usb_audio_quirk[]) {
2342			{
2343				.ifnum = 0,
2344				.type = QUIRK_MIDI_RAW_BYTES
2345			},
2346			{
2347				.ifnum = 1,
2348				.type = QUIRK_IGNORE_INTERFACE
2349			},
2350			{
2351				.ifnum = -1
2352			}
2353		}
2354	}
2355},
2356
2357/* Emagic devices */
2358{
2359	USB_DEVICE(0x086a, 0x0001),
2360	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2361		.vendor_name = "Emagic",
2362		/* .product_name = "Unitor8", */
2363		.ifnum = 2,
2364		.type = QUIRK_MIDI_EMAGIC,
2365		.data = & (const struct snd_usb_midi_endpoint_info) {
2366			.out_cables = 0x80ff,
2367			.in_cables  = 0x80ff
2368		}
2369	}
2370},
2371{
2372	USB_DEVICE(0x086a, 0x0002),
2373	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2374		.vendor_name = "Emagic",
2375		/* .product_name = "AMT8", */
2376		.ifnum = 2,
2377		.type = QUIRK_MIDI_EMAGIC,
2378		.data = & (const struct snd_usb_midi_endpoint_info) {
2379			.out_cables = 0x80ff,
2380			.in_cables  = 0x80ff
2381		}
2382	}
2383},
2384{
2385	USB_DEVICE(0x086a, 0x0003),
2386	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2387		.vendor_name = "Emagic",
2388		/* .product_name = "MT4", */
2389		.ifnum = 2,
2390		.type = QUIRK_MIDI_EMAGIC,
2391		.data = & (const struct snd_usb_midi_endpoint_info) {
2392			.out_cables = 0x800f,
2393			.in_cables  = 0x8003
2394		}
2395	}
2396},
2397
2398/* KORG devices */
2399{
2400	USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2401	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2402		.vendor_name = "KORG, Inc.",
2403		/* .product_name = "PANDORA PX5D", */
2404		.ifnum = 3,
2405		.type = QUIRK_MIDI_STANDARD_INTERFACE,
2406	}
2407},
2408
2409{
2410	USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2411	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2412		.vendor_name = "KORG, Inc.",
2413		/* .product_name = "ToneLab ST", */
2414		.ifnum = 3,
2415		.type = QUIRK_MIDI_STANDARD_INTERFACE,
2416	}
2417},
2418
2419/* AKAI devices */
2420{
2421	USB_DEVICE(0x09e8, 0x0062),
2422	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2423		.vendor_name = "AKAI",
2424		.product_name = "MPD16",
2425		.ifnum = 0,
2426		.type = QUIRK_MIDI_AKAI,
2427	}
2428},
2429
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2430/* TerraTec devices */
2431{
2432	USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2433	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2434		.vendor_name = "TerraTec",
2435		.product_name = "PHASE 26",
2436		.ifnum = 3,
2437		.type = QUIRK_MIDI_STANDARD_INTERFACE
2438	}
2439},
2440{
2441	USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2442	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2443		.vendor_name = "TerraTec",
2444		.product_name = "PHASE 26",
2445		.ifnum = 3,
2446		.type = QUIRK_MIDI_STANDARD_INTERFACE
2447	}
2448},
2449{
2450	USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2451	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2452		.vendor_name = "TerraTec",
2453		.product_name = "PHASE 26",
2454		.ifnum = 3,
2455		.type = QUIRK_MIDI_STANDARD_INTERFACE
2456	}
2457},
2458{
2459	USB_DEVICE(0x0ccd, 0x0028),
2460	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2461		.vendor_name = "TerraTec",
2462		.product_name = "Aureon5.1MkII",
2463		.ifnum = QUIRK_NO_INTERFACE
2464	}
2465},
2466{
2467	USB_DEVICE(0x0ccd, 0x0035),
2468	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2469		.vendor_name = "Miditech",
2470		.product_name = "Play'n Roll",
2471		.ifnum = 0,
2472		.type = QUIRK_MIDI_CME
2473	}
2474},
2475
2476/* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2477{
2478	USB_DEVICE(0x103d, 0x0100),
2479		.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2480		.vendor_name = "Stanton",
2481		.product_name = "ScratchAmp",
2482		.ifnum = QUIRK_NO_INTERFACE
2483	}
2484},
2485{
2486	USB_DEVICE(0x103d, 0x0101),
2487		.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2488		.vendor_name = "Stanton",
2489		.product_name = "ScratchAmp",
2490		.ifnum = QUIRK_NO_INTERFACE
2491	}
2492},
2493
2494/* Novation EMS devices */
2495{
2496	USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2497	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2498		.vendor_name = "Novation",
2499		.product_name = "ReMOTE Audio/XStation",
2500		.ifnum = 4,
2501		.type = QUIRK_MIDI_NOVATION
2502	}
2503},
2504{
2505	USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2506	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2507		.vendor_name = "Novation",
2508		.product_name = "Speedio",
2509		.ifnum = 3,
2510		.type = QUIRK_MIDI_NOVATION
2511	}
2512},
2513{
 
 
 
 
 
 
 
 
 
2514	USB_DEVICE(0x1235, 0x000e),
2515	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2516		/* .vendor_name = "Novation", */
2517		/* .product_name = "Launchpad", */
2518		.ifnum = 0,
2519		.type = QUIRK_MIDI_RAW_BYTES
2520	}
2521},
2522{
2523	USB_DEVICE(0x1235, 0x0010),
2524	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2525		.vendor_name = "Focusrite",
2526		.product_name = "Saffire 6 USB",
2527		.ifnum = QUIRK_ANY_INTERFACE,
2528		.type = QUIRK_COMPOSITE,
2529		.data = (const struct snd_usb_audio_quirk[]) {
2530			{
2531				.ifnum = 0,
 
 
 
 
2532				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2533				.data = &(const struct audioformat) {
2534					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2535					.channels = 4,
2536					.iface = 0,
2537					.altsetting = 1,
2538					.altset_idx = 1,
2539					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2540					.endpoint = 0x01,
2541					.ep_attr = USB_ENDPOINT_XFER_ISOC,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2542					.rates = SNDRV_PCM_RATE_44100 |
2543						 SNDRV_PCM_RATE_48000,
2544					.rate_min = 44100,
2545					.rate_max = 48000,
2546					.nr_rates = 2,
2547					.rate_table = (unsigned int[]) {
2548						44100, 48000
2549					}
2550				}
2551			},
2552			{
2553				.ifnum = 1,
2554				.type = QUIRK_MIDI_RAW_BYTES
2555			},
2556			{
2557				.ifnum = -1
2558			}
2559		}
2560	}
2561},
2562{
2563	USB_DEVICE(0x1235, 0x0018),
2564	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2565		.vendor_name = "Novation",
2566		.product_name = "Twitch",
2567		.ifnum = QUIRK_ANY_INTERFACE,
2568		.type = QUIRK_COMPOSITE,
2569		.data = (const struct snd_usb_audio_quirk[]) {
2570			{
2571				.ifnum = 0,
2572				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2573				.data = & (const struct audioformat) {
2574					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2575					.channels = 4,
2576					.iface = 0,
2577					.altsetting = 1,
2578					.altset_idx = 1,
2579					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2580					.endpoint = 0x01,
2581					.ep_attr = USB_ENDPOINT_XFER_ISOC,
2582					.rates = SNDRV_PCM_RATE_44100 |
2583						 SNDRV_PCM_RATE_48000,
2584					.rate_min = 44100,
2585					.rate_max = 48000,
2586					.nr_rates = 2,
2587					.rate_table = (unsigned int[]) {
2588						44100, 48000
2589					}
2590				}
2591			},
2592			{
2593				.ifnum = 1,
2594				.type = QUIRK_MIDI_RAW_BYTES
2595			},
2596			{
2597				.ifnum = -1
2598			}
2599		}
2600	}
2601},
2602{
2603	USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2604	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2605		.vendor_name = "Novation",
2606		.product_name = "ReMOTE25",
2607		.ifnum = 0,
2608		.type = QUIRK_MIDI_NOVATION
2609	}
2610},
2611{
2612	/*
2613	 * Focusrite Scarlett 18i6
2614	 *
2615	 * Avoid mixer creation, which otherwise fails because some of
2616	 * the interface descriptor subtypes for interface 0 are
2617	 * unknown.  That should be fixed or worked-around but this at
2618	 * least allows the device to be used successfully with a DAW
2619	 * and an external mixer.  See comments below about other
2620	 * ignored interfaces.
2621	 */
2622	USB_DEVICE(0x1235, 0x8004),
2623	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2624		.vendor_name = "Focusrite",
2625		.product_name = "Scarlett 18i6",
2626		.ifnum = QUIRK_ANY_INTERFACE,
2627		.type = QUIRK_COMPOSITE,
2628		.data = & (const struct snd_usb_audio_quirk[]) {
2629			{
2630				/* InterfaceSubClass 1 (Control Device) */
2631				.ifnum = 0,
2632				.type = QUIRK_IGNORE_INTERFACE
2633			},
2634			{
2635				.ifnum = 1,
2636				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2637			},
2638			{
2639				.ifnum = 2,
2640				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2641			},
2642			{
2643				/* InterfaceSubClass 1 (Control Device) */
2644				.ifnum = 3,
2645				.type = QUIRK_IGNORE_INTERFACE
2646			},
2647			{
2648				.ifnum = 4,
2649				.type = QUIRK_MIDI_STANDARD_INTERFACE
2650			},
2651			{
2652				/* InterfaceSubClass 1 (Device Firmware Update) */
2653				.ifnum = 5,
2654				.type = QUIRK_IGNORE_INTERFACE
2655			},
2656			{
2657				.ifnum = -1
2658			}
2659		}
2660	}
2661},
2662
2663/* Access Music devices */
2664{
2665	/* VirusTI Desktop */
2666	USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2667	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2668		.ifnum = QUIRK_ANY_INTERFACE,
2669		.type = QUIRK_COMPOSITE,
2670		.data = &(const struct snd_usb_audio_quirk[]) {
2671			{
2672				.ifnum = 3,
2673				.type = QUIRK_MIDI_FIXED_ENDPOINT,
2674				.data = &(const struct snd_usb_midi_endpoint_info) {
2675					.out_cables = 0x0003,
2676					.in_cables  = 0x0003
2677				}
2678			},
2679			{
2680				.ifnum = 4,
2681				.type = QUIRK_IGNORE_INTERFACE
2682			},
2683			{
2684				.ifnum = -1
2685			}
2686		}
2687	}
2688},
2689
2690/* */
2691{
2692	/* aka. Serato Scratch Live DJ Box */
2693	USB_DEVICE(0x13e5, 0x0001),
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2694	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2695		.vendor_name = "Rane",
2696		.product_name = "SL-1",
2697		.ifnum = QUIRK_NO_INTERFACE
 
 
2698	}
2699},
2700
2701/* Native Instruments MK2 series */
2702{
2703	/* Komplete Audio 6 */
2704	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2705	.idVendor = 0x17cc,
2706	.idProduct = 0x1000,
2707},
2708{
2709	/* Traktor Audio 6 */
2710	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2711	.idVendor = 0x17cc,
2712	.idProduct = 0x1010,
2713},
2714{
2715	/* Traktor Audio 10 */
2716	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2717	.idVendor = 0x17cc,
2718	.idProduct = 0x1020,
2719},
2720
 
 
 
 
 
 
 
 
 
 
 
2721/* KeithMcMillen Stringport */
2722{
2723	USB_DEVICE(0x1f38, 0x0001),
2724	.bInterfaceClass = USB_CLASS_AUDIO,
2725},
2726
2727/* Miditech devices */
2728{
2729	USB_DEVICE(0x4752, 0x0011),
2730	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2731		.vendor_name = "Miditech",
2732		.product_name = "Midistart-2",
2733		.ifnum = 0,
2734		.type = QUIRK_MIDI_CME
2735	}
2736},
2737
2738/* Central Music devices */
2739{
2740	/* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2741	USB_DEVICE(0x7104, 0x2202),
2742	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2743		.ifnum = 0,
2744		.type = QUIRK_MIDI_CME
2745	}
2746},
2747
2748/* Hauppauge HVR-950Q and HVR-850 */
2749{
2750	USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
2751	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2752		       USB_DEVICE_ID_MATCH_INT_CLASS |
2753		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2754	.bInterfaceClass = USB_CLASS_AUDIO,
2755	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2756	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2757		.vendor_name = "Hauppauge",
2758		.product_name = "HVR-950Q",
2759		.ifnum = QUIRK_ANY_INTERFACE,
2760		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2761	}
2762},
2763{
2764	USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210),
2765	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2766		       USB_DEVICE_ID_MATCH_INT_CLASS |
2767		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2768	.bInterfaceClass = USB_CLASS_AUDIO,
2769	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2770	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2771		.vendor_name = "Hauppauge",
2772		.product_name = "HVR-950Q",
2773		.ifnum = QUIRK_ANY_INTERFACE,
2774		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2775	}
2776},
2777{
2778	USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217),
2779	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2780		       USB_DEVICE_ID_MATCH_INT_CLASS |
2781		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2782	.bInterfaceClass = USB_CLASS_AUDIO,
2783	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2784	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2785		.vendor_name = "Hauppauge",
2786		.product_name = "HVR-950Q",
2787		.ifnum = QUIRK_ANY_INTERFACE,
2788		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2789	}
2790},
2791{
2792	USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b),
2793	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2794		       USB_DEVICE_ID_MATCH_INT_CLASS |
2795		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2796	.bInterfaceClass = USB_CLASS_AUDIO,
2797	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2798	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2799		.vendor_name = "Hauppauge",
2800		.product_name = "HVR-950Q",
2801		.ifnum = QUIRK_ANY_INTERFACE,
2802		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2803	}
2804},
2805{
2806	USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e),
2807	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2808		       USB_DEVICE_ID_MATCH_INT_CLASS |
2809		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2810	.bInterfaceClass = USB_CLASS_AUDIO,
2811	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2812	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2813		.vendor_name = "Hauppauge",
2814		.product_name = "HVR-950Q",
2815		.ifnum = QUIRK_ANY_INTERFACE,
2816		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2817	}
2818},
2819{
2820	USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f),
2821	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2822		       USB_DEVICE_ID_MATCH_INT_CLASS |
2823		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2824	.bInterfaceClass = USB_CLASS_AUDIO,
2825	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2826	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2827		.vendor_name = "Hauppauge",
2828		.product_name = "HVR-950Q",
2829		.ifnum = QUIRK_ANY_INTERFACE,
2830		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2831	}
2832},
2833{
2834	USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240),
2835	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2836		       USB_DEVICE_ID_MATCH_INT_CLASS |
2837		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2838	.bInterfaceClass = USB_CLASS_AUDIO,
2839	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2840	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2841		.vendor_name = "Hauppauge",
2842		.product_name = "HVR-850",
2843		.ifnum = QUIRK_ANY_INTERFACE,
2844		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2845	}
2846},
2847{
2848	USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280),
2849	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2850		       USB_DEVICE_ID_MATCH_INT_CLASS |
2851		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2852	.bInterfaceClass = USB_CLASS_AUDIO,
2853	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2854	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2855		.vendor_name = "Hauppauge",
2856		.product_name = "HVR-950Q",
2857		.ifnum = QUIRK_ANY_INTERFACE,
2858		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2859	}
2860},
2861{
2862	USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008),
2863	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2864		       USB_DEVICE_ID_MATCH_INT_CLASS |
2865		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 
 
2866	.bInterfaceClass = USB_CLASS_AUDIO,
2867	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2868	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2869		.vendor_name = "Hauppauge",
2870		.product_name = "HVR-950Q",
2871		.ifnum = QUIRK_ANY_INTERFACE,
2872		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2873	}
2874},
2875
2876/* Digidesign Mbox */
2877{
2878	/* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2879	USB_DEVICE(0x0dba, 0x1000),
2880	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2881		.vendor_name = "Digidesign",
2882		.product_name = "MBox",
2883		.ifnum = QUIRK_ANY_INTERFACE,
2884		.type = QUIRK_COMPOSITE,
2885		.data = (const struct snd_usb_audio_quirk[]){
2886			{
2887				.ifnum = 0,
2888				.type = QUIRK_IGNORE_INTERFACE,
2889			},
2890			{
2891				.ifnum = 1,
2892				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2893				.data = &(const struct audioformat) {
2894					.formats = SNDRV_PCM_FMTBIT_S24_3BE,
2895					.channels = 2,
2896					.iface = 1,
2897					.altsetting = 1,
2898					.altset_idx = 1,
2899					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2900					.endpoint = 0x02,
2901					.ep_attr = 0x01,
2902					.rates = SNDRV_PCM_RATE_44100 |
2903						 SNDRV_PCM_RATE_48000,
2904					.rate_min = 44100,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2905					.rate_max = 48000,
2906					.nr_rates = 2,
2907					.rate_table = (unsigned int[]) {
2908						44100, 48000
2909					}
2910				}
2911			},
2912			{
2913				.ifnum = -1
2914			}
2915		}
2916
2917	}
2918},
2919
2920/* DIGIDESIGN MBOX 2 */
2921{
2922	USB_DEVICE(0x0dba, 0x3000),
2923	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2924		.vendor_name = "Digidesign",
2925		.product_name = "Mbox 2",
2926		.ifnum = QUIRK_ANY_INTERFACE,
2927		.type = QUIRK_COMPOSITE,
2928		.data = (const struct snd_usb_audio_quirk[]) {
2929			{
2930				.ifnum = 0,
2931				.type = QUIRK_IGNORE_INTERFACE
2932			},
2933			{
2934				.ifnum = 1,
2935				.type = QUIRK_IGNORE_INTERFACE
2936			},
2937			{
2938				.ifnum = 2,
2939				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2940				.data = &(const struct audioformat) {
2941					.formats = SNDRV_PCM_FMTBIT_S24_3BE,
2942					.channels = 2,
2943					.iface = 2,
2944					.altsetting = 2,
2945					.altset_idx = 1,
2946					.attributes = 0x00,
2947					.endpoint = 0x03,
2948					.ep_attr = USB_ENDPOINT_SYNC_ASYNC,
2949					.rates = SNDRV_PCM_RATE_48000,
2950					.rate_min = 48000,
2951					.rate_max = 48000,
2952					.nr_rates = 1,
2953					.rate_table = (unsigned int[]) {
2954						48000
2955					}
2956				}
2957			},
2958			{
2959				.ifnum = 3,
2960				.type = QUIRK_IGNORE_INTERFACE
2961			},
2962			{
2963				.ifnum = 4,
2964				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2965				.data = &(const struct audioformat) {
2966				.formats = SNDRV_PCM_FMTBIT_S24_3BE,
2967					.channels = 2,
2968					.iface = 4,
2969					.altsetting = 2,
2970					.altset_idx = 1,
2971					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2972					.endpoint = 0x85,
2973					.ep_attr = USB_ENDPOINT_SYNC_SYNC,
2974					.rates = SNDRV_PCM_RATE_48000,
2975					.rate_min = 48000,
2976					.rate_max = 48000,
2977					.nr_rates = 1,
2978					.rate_table = (unsigned int[]) {
2979						48000
2980					}
2981				}
2982			},
2983			{
2984				.ifnum = 5,
2985				.type = QUIRK_IGNORE_INTERFACE
2986			},
2987			{
2988				.ifnum = 6,
2989				.type = QUIRK_MIDI_MIDIMAN,
2990				.data = &(const struct snd_usb_midi_endpoint_info) {
2991					.out_ep =  0x02,
2992					.out_cables = 0x0001,
2993					.in_ep = 0x81,
2994					.in_interval = 0x01,
2995					.in_cables = 0x0001
2996				}
2997			},
2998			{
2999				.ifnum = -1
3000			}
3001		}
3002	}
3003},
3004{
3005	/* Tascam US122 MKII - playback-only support */
3006	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
3007	.idVendor = 0x0644,
3008	.idProduct = 0x8021,
3009	.bInterfaceClass = USB_CLASS_AUDIO,
3010	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3011		.vendor_name = "TASCAM",
3012		.product_name = "US122 MKII",
3013		.ifnum = QUIRK_ANY_INTERFACE,
3014		.type = QUIRK_COMPOSITE,
3015		.data = (const struct snd_usb_audio_quirk[]) {
3016			{
3017				.ifnum = 0,
3018				.type = QUIRK_IGNORE_INTERFACE
3019			},
3020			{
3021				.ifnum = 1,
3022				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3023				.data = &(const struct audioformat) {
3024					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
3025					.channels = 2,
3026					.iface = 1,
3027					.altsetting = 1,
3028					.altset_idx = 1,
3029					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3030					.endpoint = 0x02,
3031					.ep_attr = USB_ENDPOINT_XFER_ISOC,
3032					.rates = SNDRV_PCM_RATE_44100 |
3033						 SNDRV_PCM_RATE_48000 |
3034						 SNDRV_PCM_RATE_88200 |
3035						 SNDRV_PCM_RATE_96000,
3036					.rate_min = 44100,
3037					.rate_max = 96000,
3038					.nr_rates = 4,
3039					.rate_table = (unsigned int[]) {
3040						44100, 48000, 88200, 96000
3041					}
3042				}
3043			},
3044			{
3045				.ifnum = -1
3046			}
3047		}
3048	}
3049},
3050
3051/* Microsoft XboxLive Headset/Xbox Communicator */
3052{
3053	USB_DEVICE(0x045e, 0x0283),
3054	.bInterfaceClass = USB_CLASS_PER_INTERFACE,
3055	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3056		.vendor_name = "Microsoft",
3057		.product_name = "XboxLive Headset/Xbox Communicator",
3058		.ifnum = QUIRK_ANY_INTERFACE,
3059		.type = QUIRK_COMPOSITE,
3060		.data = &(const struct snd_usb_audio_quirk[]) {
3061			{
3062				/* playback */
3063				.ifnum = 0,
3064				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3065				.data = &(const struct audioformat) {
3066					.formats = SNDRV_PCM_FMTBIT_S16_LE,
3067					.channels = 1,
3068					.iface = 0,
3069					.altsetting = 0,
3070					.altset_idx = 0,
3071					.attributes = 0,
3072					.endpoint = 0x04,
3073					.ep_attr = 0x05,
3074					.rates = SNDRV_PCM_RATE_CONTINUOUS,
3075					.rate_min = 22050,
3076					.rate_max = 22050
3077				}
3078			},
3079			{
3080				/* capture */
3081				.ifnum = 1,
3082				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3083				.data = &(const struct audioformat) {
3084					.formats = SNDRV_PCM_FMTBIT_S16_LE,
3085					.channels = 1,
3086					.iface = 1,
3087					.altsetting = 0,
3088					.altset_idx = 0,
3089					.attributes = 0,
3090					.endpoint = 0x85,
3091					.ep_attr = 0x05,
3092					.rates = SNDRV_PCM_RATE_CONTINUOUS,
3093					.rate_min = 16000,
3094					.rate_max = 16000
3095				}
3096			},
3097			{
3098				.ifnum = -1
3099			}
3100		}
3101	}
3102},
3103
3104/* Reloop Play */
3105{
3106	USB_DEVICE(0x200c, 0x100b),
3107	.bInterfaceClass = USB_CLASS_PER_INTERFACE,
3108	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3109		.ifnum = QUIRK_ANY_INTERFACE,
3110		.type = QUIRK_COMPOSITE,
3111		.data = &(const struct snd_usb_audio_quirk[]) {
3112			{
3113				.ifnum = 0,
3114				.type = QUIRK_AUDIO_STANDARD_MIXER,
3115			},
3116			{
3117				.ifnum = 1,
3118				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
3119				.data = &(const struct audioformat) {
3120					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
3121					.channels = 4,
3122					.iface = 1,
3123					.altsetting = 1,
3124					.altset_idx = 1,
3125					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3126					.endpoint = 0x01,
3127					.ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3128					.rates = SNDRV_PCM_RATE_44100 |
3129						 SNDRV_PCM_RATE_48000,
3130					.rate_min = 44100,
3131					.rate_max = 48000,
3132					.nr_rates = 2,
3133					.rate_table = (unsigned int[]) {
3134						44100, 48000
3135					}
3136				}
3137			},
3138			{
3139				.ifnum = -1
3140			}
3141		}
3142	}
3143},
3144
3145{
3146	/*
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3147	 * Some USB MIDI devices don't have an audio control interface,
3148	 * so we have to grab MIDI streaming interfaces here.
3149	 */
3150	.match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3151		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3152	.bInterfaceClass = USB_CLASS_AUDIO,
3153	.bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3154	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3155		.ifnum = QUIRK_ANY_INTERFACE,
3156		.type = QUIRK_MIDI_STANDARD_INTERFACE
3157	}
3158},
3159
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3160{
3161	/*
3162	 * The original product_name is "USB Sound Device", however this name
3163	 * is also used by the CM106 based cards, so make it unique.
3164	 */
3165	USB_DEVICE(0x0d8c, 0x0103),
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3166	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3167		.product_name = "Audio Advantage MicroII",
3168		.ifnum = QUIRK_NO_INTERFACE
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3169	}
3170},
3171
3172#undef USB_DEVICE_VENDOR_SPEC