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/* Creative/Toshiba Multimedia Center SB-0500 */
  54{
  55	USB_DEVICE(0x041e, 0x3048),
  56	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  57		.vendor_name = "Toshiba",
  58		.product_name = "SB-0500",
  59		.ifnum = QUIRK_NO_INTERFACE
  60	}
  61},
  62
  63/* Creative/E-Mu devices */
  64{
  65	USB_DEVICE(0x041e, 0x3010),
  66	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  67		.vendor_name = "Creative Labs",
  68		.product_name = "Sound Blaster MP3+",
  69		.ifnum = QUIRK_NO_INTERFACE
  70	}
  71},
  72{
  73	/* E-Mu 0202 USB */
  74	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  75	.idVendor = 0x041e,
  76	.idProduct = 0x3f02,
  77	.bInterfaceClass = USB_CLASS_AUDIO,
  78},
  79{
  80	/* E-Mu 0404 USB */
  81	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  82	.idVendor = 0x041e,
  83	.idProduct = 0x3f04,
  84	.bInterfaceClass = USB_CLASS_AUDIO,
  85},
  86{
  87	/* E-Mu Tracker Pre */
  88	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  89	.idVendor = 0x041e,
  90	.idProduct = 0x3f0a,
  91	.bInterfaceClass = USB_CLASS_AUDIO,
  92},
  93{
  94	/* E-Mu 0204 USB */
  95	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  96	.idVendor = 0x041e,
  97	.idProduct = 0x3f19,
  98	.bInterfaceClass = USB_CLASS_AUDIO,
  99},
 100
 101/*
 102 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
 103 * class matches do not take effect without an explicit ID match.
 104 */
 105{
 106	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 107		       USB_DEVICE_ID_MATCH_INT_CLASS |
 108		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 109	.idVendor = 0x046d,
 110	.idProduct = 0x0850,
 111	.bInterfaceClass = USB_CLASS_AUDIO,
 112	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 113},
 114{
 115	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 116		       USB_DEVICE_ID_MATCH_INT_CLASS |
 117		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 118	.idVendor = 0x046d,
 119	.idProduct = 0x08ae,
 120	.bInterfaceClass = USB_CLASS_AUDIO,
 121	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 122},
 123{
 124	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 125		       USB_DEVICE_ID_MATCH_INT_CLASS |
 126		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 127	.idVendor = 0x046d,
 128	.idProduct = 0x08c6,
 129	.bInterfaceClass = USB_CLASS_AUDIO,
 130	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 131},
 132{
 133	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 134		       USB_DEVICE_ID_MATCH_INT_CLASS |
 135		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 136	.idVendor = 0x046d,
 137	.idProduct = 0x08f0,
 138	.bInterfaceClass = USB_CLASS_AUDIO,
 139	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 140},
 141{
 142	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 143		       USB_DEVICE_ID_MATCH_INT_CLASS |
 144		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 145	.idVendor = 0x046d,
 146	.idProduct = 0x08f5,
 147	.bInterfaceClass = USB_CLASS_AUDIO,
 148	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 149},
 150{
 151	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 152		       USB_DEVICE_ID_MATCH_INT_CLASS |
 153		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 154	.idVendor = 0x046d,
 155	.idProduct = 0x08f6,
 156	.bInterfaceClass = USB_CLASS_AUDIO,
 157	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 158},
 159{
 160	USB_DEVICE(0x046d, 0x0990),
 161	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 162		.vendor_name = "Logitech, Inc.",
 163		.product_name = "QuickCam Pro 9000",
 164		.ifnum = QUIRK_NO_INTERFACE
 165	}
 166},
 167
 168/*
 169 * Yamaha devices
 170 */
 171
 172#define YAMAHA_DEVICE(id, name) { \
 173	USB_DEVICE(0x0499, id), \
 174	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 175		.vendor_name = "Yamaha", \
 176		.product_name = name, \
 177		.ifnum = QUIRK_ANY_INTERFACE, \
 178		.type = QUIRK_MIDI_YAMAHA \
 179	} \
 180}
 181#define YAMAHA_INTERFACE(id, intf, name) { \
 182	USB_DEVICE_VENDOR_SPEC(0x0499, id), \
 183	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 184		.vendor_name = "Yamaha", \
 185		.product_name = name, \
 186		.ifnum = intf, \
 187		.type = QUIRK_MIDI_YAMAHA \
 188	} \
 189}
 190YAMAHA_DEVICE(0x1000, "UX256"),
 191YAMAHA_DEVICE(0x1001, "MU1000"),
 192YAMAHA_DEVICE(0x1002, "MU2000"),
 193YAMAHA_DEVICE(0x1003, "MU500"),
 194YAMAHA_INTERFACE(0x1004, 3, "UW500"),
 195YAMAHA_DEVICE(0x1005, "MOTIF6"),
 196YAMAHA_DEVICE(0x1006, "MOTIF7"),
 197YAMAHA_DEVICE(0x1007, "MOTIF8"),
 198YAMAHA_DEVICE(0x1008, "UX96"),
 199YAMAHA_DEVICE(0x1009, "UX16"),
 200YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
 201YAMAHA_DEVICE(0x100c, "UC-MX"),
 202YAMAHA_DEVICE(0x100d, "UC-KX"),
 203YAMAHA_DEVICE(0x100e, "S08"),
 204YAMAHA_DEVICE(0x100f, "CLP-150"),
 205YAMAHA_DEVICE(0x1010, "CLP-170"),
 206YAMAHA_DEVICE(0x1011, "P-250"),
 207YAMAHA_DEVICE(0x1012, "TYROS"),
 208YAMAHA_DEVICE(0x1013, "PF-500"),
 209YAMAHA_DEVICE(0x1014, "S90"),
 210YAMAHA_DEVICE(0x1015, "MOTIF-R"),
 211YAMAHA_DEVICE(0x1016, "MDP-5"),
 212YAMAHA_DEVICE(0x1017, "CVP-204"),
 213YAMAHA_DEVICE(0x1018, "CVP-206"),
 214YAMAHA_DEVICE(0x1019, "CVP-208"),
 215YAMAHA_DEVICE(0x101a, "CVP-210"),
 216YAMAHA_DEVICE(0x101b, "PSR-1100"),
 217YAMAHA_DEVICE(0x101c, "PSR-2100"),
 218YAMAHA_DEVICE(0x101d, "CLP-175"),
 219YAMAHA_DEVICE(0x101e, "PSR-K1"),
 220YAMAHA_DEVICE(0x101f, "EZ-J24"),
 221YAMAHA_DEVICE(0x1020, "EZ-250i"),
 222YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
 223YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
 224YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
 225YAMAHA_DEVICE(0x1024, "CVP-301"),
 226YAMAHA_DEVICE(0x1025, "CVP-303"),
 227YAMAHA_DEVICE(0x1026, "CVP-305"),
 228YAMAHA_DEVICE(0x1027, "CVP-307"),
 229YAMAHA_DEVICE(0x1028, "CVP-309"),
 230YAMAHA_DEVICE(0x1029, "CVP-309GP"),
 231YAMAHA_DEVICE(0x102a, "PSR-1500"),
 232YAMAHA_DEVICE(0x102b, "PSR-3000"),
 233YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
 234YAMAHA_DEVICE(0x1030, "PSR-295/293"),
 235YAMAHA_DEVICE(0x1031, "DGX-205/203"),
 236YAMAHA_DEVICE(0x1032, "DGX-305"),
 237YAMAHA_DEVICE(0x1033, "DGX-505"),
 238YAMAHA_DEVICE(0x1034, NULL),
 239YAMAHA_DEVICE(0x1035, NULL),
 240YAMAHA_DEVICE(0x1036, NULL),
 241YAMAHA_DEVICE(0x1037, NULL),
 242YAMAHA_DEVICE(0x1038, NULL),
 243YAMAHA_DEVICE(0x1039, NULL),
 244YAMAHA_DEVICE(0x103a, NULL),
 245YAMAHA_DEVICE(0x103b, NULL),
 246YAMAHA_DEVICE(0x103c, NULL),
 247YAMAHA_DEVICE(0x103d, NULL),
 248YAMAHA_DEVICE(0x103e, NULL),
 249YAMAHA_DEVICE(0x103f, NULL),
 250YAMAHA_DEVICE(0x1040, NULL),
 251YAMAHA_DEVICE(0x1041, NULL),
 252YAMAHA_DEVICE(0x1042, NULL),
 253YAMAHA_DEVICE(0x1043, NULL),
 254YAMAHA_DEVICE(0x1044, NULL),
 255YAMAHA_DEVICE(0x1045, NULL),
 256YAMAHA_INTERFACE(0x104e, 0, NULL),
 257YAMAHA_DEVICE(0x104f, NULL),
 258YAMAHA_DEVICE(0x1050, NULL),
 259YAMAHA_DEVICE(0x1051, NULL),
 260YAMAHA_DEVICE(0x1052, NULL),
 261YAMAHA_INTERFACE(0x1053, 0, NULL),
 262YAMAHA_INTERFACE(0x1054, 0, NULL),
 263YAMAHA_DEVICE(0x1055, NULL),
 264YAMAHA_DEVICE(0x1056, NULL),
 265YAMAHA_DEVICE(0x1057, NULL),
 266YAMAHA_DEVICE(0x1058, NULL),
 267YAMAHA_DEVICE(0x1059, NULL),
 268YAMAHA_DEVICE(0x105a, NULL),
 269YAMAHA_DEVICE(0x105b, NULL),
 270YAMAHA_DEVICE(0x105c, NULL),
 271YAMAHA_DEVICE(0x105d, NULL),
 272{
 273	USB_DEVICE(0x0499, 0x1503),
 274	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 275		/* .vendor_name = "Yamaha", */
 276		/* .product_name = "MOX6/MOX8", */
 277		.ifnum = QUIRK_ANY_INTERFACE,
 278		.type = QUIRK_COMPOSITE,
 279		.data = (const struct snd_usb_audio_quirk[]) {
 280			{
 281				.ifnum = 1,
 282				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 283			},
 284			{
 285				.ifnum = 2,
 286				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 287			},
 288			{
 289				.ifnum = 3,
 290				.type = QUIRK_MIDI_YAMAHA
 291			},
 292			{
 293				.ifnum = -1
 294			}
 295		}
 296	}
 297},
 298YAMAHA_DEVICE(0x2000, "DGP-7"),
 299YAMAHA_DEVICE(0x2001, "DGP-5"),
 300YAMAHA_DEVICE(0x2002, NULL),
 301YAMAHA_DEVICE(0x2003, NULL),
 302YAMAHA_DEVICE(0x5000, "CS1D"),
 303YAMAHA_DEVICE(0x5001, "DSP1D"),
 304YAMAHA_DEVICE(0x5002, "DME32"),
 305YAMAHA_DEVICE(0x5003, "DM2000"),
 306YAMAHA_DEVICE(0x5004, "02R96"),
 307YAMAHA_DEVICE(0x5005, "ACU16-C"),
 308YAMAHA_DEVICE(0x5006, "NHB32-C"),
 309YAMAHA_DEVICE(0x5007, "DM1000"),
 310YAMAHA_DEVICE(0x5008, "01V96"),
 311YAMAHA_DEVICE(0x5009, "SPX2000"),
 312YAMAHA_DEVICE(0x500a, "PM5D"),
 313YAMAHA_DEVICE(0x500b, "DME64N"),
 314YAMAHA_DEVICE(0x500c, "DME24N"),
 315YAMAHA_DEVICE(0x500d, NULL),
 316YAMAHA_DEVICE(0x500e, NULL),
 317YAMAHA_DEVICE(0x500f, NULL),
 318YAMAHA_DEVICE(0x7000, "DTX"),
 319YAMAHA_DEVICE(0x7010, "UB99"),
 320#undef YAMAHA_DEVICE
 321#undef YAMAHA_INTERFACE
 322
 323/*
 324 * Roland/RolandED/Edirol/BOSS devices
 325 */
 326{
 327	USB_DEVICE(0x0582, 0x0000),
 328	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 329		.vendor_name = "Roland",
 330		.product_name = "UA-100",
 331		.ifnum = QUIRK_ANY_INTERFACE,
 332		.type = QUIRK_COMPOSITE,
 333		.data = (const struct snd_usb_audio_quirk[]) {
 334			{
 335				.ifnum = 0,
 336				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
 337				.data = & (const struct audioformat) {
 338					.formats = SNDRV_PCM_FMTBIT_S16_LE,
 339					.channels = 4,
 340					.iface = 0,
 341					.altsetting = 1,
 342					.altset_idx = 1,
 343					.attributes = 0,
 344					.endpoint = 0x01,
 345					.ep_attr = 0x09,
 346					.rates = SNDRV_PCM_RATE_CONTINUOUS,
 347					.rate_min = 44100,
 348					.rate_max = 44100,
 349				}
 350			},
 351			{
 352				.ifnum = 1,
 353				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
 354				.data = & (const struct audioformat) {
 355					.formats = SNDRV_PCM_FMTBIT_S16_LE,
 356					.channels = 2,
 357					.iface = 1,
 358					.altsetting = 1,
 359					.altset_idx = 1,
 360					.attributes = UAC_EP_CS_ATTR_FILL_MAX,
 361					.endpoint = 0x81,
 362					.ep_attr = 0x05,
 363					.rates = SNDRV_PCM_RATE_CONTINUOUS,
 364					.rate_min = 44100,
 365					.rate_max = 44100,
 366				}
 367			},
 368			{
 369				.ifnum = 2,
 370				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 371				.data = & (const struct snd_usb_midi_endpoint_info) {
 372					.out_cables = 0x0007,
 373					.in_cables  = 0x0007
 374				}
 375			},
 376			{
 377				.ifnum = -1
 378			}
 379		}
 380	}
 381},
 382{
 383	USB_DEVICE(0x0582, 0x0002),
 384	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 385		.vendor_name = "EDIROL",
 386		.product_name = "UM-4",
 387		.ifnum = QUIRK_ANY_INTERFACE,
 388		.type = QUIRK_COMPOSITE,
 389		.data = (const struct snd_usb_audio_quirk[]) {
 390			{
 391				.ifnum = 0,
 392				.type = QUIRK_IGNORE_INTERFACE
 393			},
 394			{
 395				.ifnum = 1,
 396				.type = QUIRK_IGNORE_INTERFACE
 397			},
 398			{
 399				.ifnum = 2,
 400				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 401				.data = & (const struct snd_usb_midi_endpoint_info) {
 402					.out_cables = 0x000f,
 403					.in_cables  = 0x000f
 404				}
 405			},
 406			{
 407				.ifnum = -1
 408			}
 409		}
 410	}
 411},
 412{
 413	USB_DEVICE(0x0582, 0x0003),
 414	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 415		.vendor_name = "Roland",
 416		.product_name = "SC-8850",
 417		.ifnum = QUIRK_ANY_INTERFACE,
 418		.type = QUIRK_COMPOSITE,
 419		.data = (const struct snd_usb_audio_quirk[]) {
 420			{
 421				.ifnum = 0,
 422				.type = QUIRK_IGNORE_INTERFACE
 423			},
 424			{
 425				.ifnum = 1,
 426				.type = QUIRK_IGNORE_INTERFACE
 427			},
 428			{
 429				.ifnum = 2,
 430				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 431				.data = & (const struct snd_usb_midi_endpoint_info) {
 432					.out_cables = 0x003f,
 433					.in_cables  = 0x003f
 434				}
 435			},
 436			{
 437				.ifnum = -1
 438			}
 439		}
 440	}
 441},
 442{
 443	USB_DEVICE(0x0582, 0x0004),
 444	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 445		.vendor_name = "Roland",
 446		.product_name = "U-8",
 447		.ifnum = QUIRK_ANY_INTERFACE,
 448		.type = QUIRK_COMPOSITE,
 449		.data = (const struct snd_usb_audio_quirk[]) {
 450			{
 451				.ifnum = 0,
 452				.type = QUIRK_IGNORE_INTERFACE
 453			},
 454			{
 455				.ifnum = 1,
 456				.type = QUIRK_IGNORE_INTERFACE
 457			},
 458			{
 459				.ifnum = 2,
 460				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 461				.data = & (const struct snd_usb_midi_endpoint_info) {
 462					.out_cables = 0x0005,
 463					.in_cables  = 0x0005
 464				}
 465			},
 466			{
 467				.ifnum = -1
 468			}
 469		}
 470	}
 471},
 472{
 473	/* Has ID 0x0099 when not in "Advanced Driver" mode.
 474	 * The UM-2EX has only one input, but we cannot detect this. */
 475	USB_DEVICE(0x0582, 0x0005),
 476	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 477		.vendor_name = "EDIROL",
 478		.product_name = "UM-2",
 479		.ifnum = QUIRK_ANY_INTERFACE,
 480		.type = QUIRK_COMPOSITE,
 481		.data = (const struct snd_usb_audio_quirk[]) {
 482			{
 483				.ifnum = 0,
 484				.type = QUIRK_IGNORE_INTERFACE
 485			},
 486			{
 487				.ifnum = 1,
 488				.type = QUIRK_IGNORE_INTERFACE
 489			},
 490			{
 491				.ifnum = 2,
 492				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 493				.data = & (const struct snd_usb_midi_endpoint_info) {
 494					.out_cables = 0x0003,
 495					.in_cables  = 0x0003
 496				}
 497			},
 498			{
 499				.ifnum = -1
 500			}
 501		}
 502	}
 503},
 504{
 505	USB_DEVICE(0x0582, 0x0007),
 506	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 507		.vendor_name = "Roland",
 508		.product_name = "SC-8820",
 509		.ifnum = QUIRK_ANY_INTERFACE,
 510		.type = QUIRK_COMPOSITE,
 511		.data = (const struct snd_usb_audio_quirk[]) {
 512			{
 513				.ifnum = 0,
 514				.type = QUIRK_IGNORE_INTERFACE
 515			},
 516			{
 517				.ifnum = 1,
 518				.type = QUIRK_IGNORE_INTERFACE
 519			},
 520			{
 521				.ifnum = 2,
 522				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 523				.data = & (const struct snd_usb_midi_endpoint_info) {
 524					.out_cables = 0x0013,
 525					.in_cables  = 0x0013
 526				}
 527			},
 528			{
 529				.ifnum = -1
 530			}
 531		}
 532	}
 533},
 534{
 535	USB_DEVICE(0x0582, 0x0008),
 536	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 537		.vendor_name = "Roland",
 538		.product_name = "PC-300",
 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 = 0x0001,
 555					.in_cables  = 0x0001
 556				}
 557			},
 558			{
 559				.ifnum = -1
 560			}
 561		}
 562	}
 563},
 564{
 565	/* has ID 0x009d when not in "Advanced Driver" mode */
 566	USB_DEVICE(0x0582, 0x0009),
 567	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 568		.vendor_name = "EDIROL",
 569		.product_name = "UM-1",
 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 = 0x0001,
 586					.in_cables  = 0x0001
 587				}
 588			},
 589			{
 590				.ifnum = -1
 591			}
 592		}
 593	}
 594},
 595{
 596	USB_DEVICE(0x0582, 0x000b),
 597	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 598		.vendor_name = "Roland",
 599		.product_name = "SK-500",
 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 = 0x0013,
 616					.in_cables  = 0x0013
 617				}
 618			},
 619			{
 620				.ifnum = -1
 621			}
 622		}
 623	}
 624},
 625{
 626	/* thanks to Emiliano Grilli <emillo@libero.it>
 627	 * for helping researching this data */
 628	USB_DEVICE(0x0582, 0x000c),
 629	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 630		.vendor_name = "Roland",
 631		.product_name = "SC-D70",
 632		.ifnum = QUIRK_ANY_INTERFACE,
 633		.type = QUIRK_COMPOSITE,
 634		.data = (const struct snd_usb_audio_quirk[]) {
 635			{
 636				.ifnum = 0,
 637				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
 638				.data = & (const struct audioformat) {
 639					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
 640					.channels = 2,
 641					.iface = 0,
 642					.altsetting = 1,
 643					.altset_idx = 1,
 644					.attributes = 0,
 645					.endpoint = 0x01,
 646					.ep_attr = 0x01,
 647					.rates = SNDRV_PCM_RATE_CONTINUOUS,
 648					.rate_min = 44100,
 649					.rate_max = 44100,
 650				}
 651			},
 652			{
 653				.ifnum = 1,
 654				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
 655				.data = & (const struct audioformat) {
 656					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
 657					.channels = 2,
 658					.iface = 1,
 659					.altsetting = 1,
 660					.altset_idx = 1,
 661					.attributes = 0,
 662					.endpoint = 0x81,
 663					.ep_attr = 0x01,
 664					.rates = SNDRV_PCM_RATE_CONTINUOUS,
 665					.rate_min = 44100,
 666					.rate_max = 44100,
 667				}
 668			},
 669			{
 670				.ifnum = 2,
 671				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 672				.data = & (const struct snd_usb_midi_endpoint_info) {
 673					.out_cables = 0x0007,
 674					.in_cables  = 0x0007
 675				}
 676			},
 677			{
 678				.ifnum = -1
 679			}
 680		}
 681	}
 682},
 683{	/*
 684	 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 685	 * If the advanced mode switch at the back of the unit is off, the
 686	 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 687	 * but offers only 16-bit PCM.
 688	 * In advanced mode, the UA-5 will output S24_3LE samples (two
 689	 * channels) at the rate indicated on the front switch, including
 690	 * the 96kHz sample rate.
 691	 */
 692	USB_DEVICE(0x0582, 0x0010),
 693	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 694		.vendor_name = "EDIROL",
 695		.product_name = "UA-5",
 696		.ifnum = QUIRK_ANY_INTERFACE,
 697		.type = QUIRK_COMPOSITE,
 698		.data = (const struct snd_usb_audio_quirk[]) {
 699			{
 700				.ifnum = 1,
 701				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 702			},
 703			{
 704				.ifnum = 2,
 705				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 706			},
 707			{
 708				.ifnum = -1
 709			}
 710		}
 711	}
 712},
 713{
 714	/* has ID 0x0013 when not in "Advanced Driver" mode */
 715	USB_DEVICE(0x0582, 0x0012),
 716	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 717		.vendor_name = "Roland",
 718		.product_name = "XV-5050",
 719		.ifnum = 0,
 720		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 721		.data = & (const struct snd_usb_midi_endpoint_info) {
 722			.out_cables = 0x0001,
 723			.in_cables  = 0x0001
 724		}
 725	}
 726},
 727{
 728	/* has ID 0x0015 when not in "Advanced Driver" mode */
 729	USB_DEVICE(0x0582, 0x0014),
 730	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 731		.vendor_name = "EDIROL",
 732		.product_name = "UM-880",
 733		.ifnum = 0,
 734		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 735		.data = & (const struct snd_usb_midi_endpoint_info) {
 736			.out_cables = 0x01ff,
 737			.in_cables  = 0x01ff
 738		}
 739	}
 740},
 741{
 742	/* has ID 0x0017 when not in "Advanced Driver" mode */
 743	USB_DEVICE(0x0582, 0x0016),
 744	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 745		.vendor_name = "EDIROL",
 746		.product_name = "SD-90",
 747		.ifnum = QUIRK_ANY_INTERFACE,
 748		.type = QUIRK_COMPOSITE,
 749		.data = (const struct snd_usb_audio_quirk[]) {
 750			{
 751				.ifnum = 0,
 752				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 753			},
 754			{
 755				.ifnum = 1,
 756				.type = QUIRK_AUDIO_STANDARD_INTERFACE
 757			},
 758			{
 759				.ifnum = 2,
 760				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 761				.data = & (const struct snd_usb_midi_endpoint_info) {
 762					.out_cables = 0x000f,
 763					.in_cables  = 0x000f
 764				}
 765			},
 766			{
 767				.ifnum = -1
 768			}
 769		}
 770	}
 771},
 772{
 773	/* has ID 0x001c when not in "Advanced Driver" mode */
 774	USB_DEVICE(0x0582, 0x001b),
 775	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 776		.vendor_name = "Roland",
 777		.product_name = "MMP-2",
 778		.ifnum = QUIRK_ANY_INTERFACE,
 779		.type = QUIRK_COMPOSITE,
 780		.data = (const struct snd_usb_audio_quirk[]) {
 781			{
 782				.ifnum = 0,
 783				.type = QUIRK_IGNORE_INTERFACE
 784			},
 785			{
 786				.ifnum = 1,
 787				.type = QUIRK_IGNORE_INTERFACE
 788			},
 789			{
 790				.ifnum = 2,
 791				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 792				.data = & (const struct snd_usb_midi_endpoint_info) {
 793					.out_cables = 0x0001,
 794					.in_cables  = 0x0001
 795				}
 796			},
 797			{
 798				.ifnum = -1
 799			}
 800		}
 801	}
 802},
 803{
 804	/* has ID 0x001e when not in "Advanced Driver" mode */
 805	USB_DEVICE(0x0582, 0x001d),
 806	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 807		.vendor_name = "Roland",
 808		.product_name = "V-SYNTH",
 809		.ifnum = 0,
 810		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 811		.data = & (const struct snd_usb_midi_endpoint_info) {
 812			.out_cables = 0x0001,
 813			.in_cables  = 0x0001
 814		}
 815	}
 816},
 817{
 818	/* has ID 0x0024 when not in "Advanced Driver" mode */
 819	USB_DEVICE(0x0582, 0x0023),
 820	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 821		.vendor_name = "EDIROL",
 822		.product_name = "UM-550",
 823		.ifnum = 0,
 824		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 825		.data = & (const struct snd_usb_midi_endpoint_info) {
 826			.out_cables = 0x003f,
 827			.in_cables  = 0x003f
 828		}
 829	}
 830},
 831{
 832	/*
 833	 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 834	 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 835	 * and no MIDI.
 836	 */
 837	USB_DEVICE(0x0582, 0x0025),
 838	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 839		.vendor_name = "EDIROL",
 840		.product_name = "UA-20",
 841		.ifnum = QUIRK_ANY_INTERFACE,
 842		.type = QUIRK_COMPOSITE,
 843		.data = (const struct snd_usb_audio_quirk[]) {
 844			{
 845				.ifnum = 0,
 846				.type = QUIRK_IGNORE_INTERFACE
 847			},
 848			{
 849				.ifnum = 1,
 850				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
 851				.data = & (const struct audioformat) {
 852					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
 853					.channels = 2,
 854					.iface = 1,
 855					.altsetting = 1,
 856					.altset_idx = 1,
 857					.attributes = 0,
 858					.endpoint = 0x01,
 859					.ep_attr = 0x01,
 860					.rates = SNDRV_PCM_RATE_CONTINUOUS,
 861					.rate_min = 44100,
 862					.rate_max = 44100,
 863				}
 864			},
 865			{
 866				.ifnum = 2,
 867				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
 868				.data = & (const struct audioformat) {
 869					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
 870					.channels = 2,
 871					.iface = 2,
 872					.altsetting = 1,
 873					.altset_idx = 1,
 874					.attributes = 0,
 875					.endpoint = 0x82,
 876					.ep_attr = 0x01,
 877					.rates = SNDRV_PCM_RATE_CONTINUOUS,
 878					.rate_min = 44100,
 879					.rate_max = 44100,
 880				}
 881			},
 882			{
 883				.ifnum = 3,
 884				.type = QUIRK_MIDI_FIXED_ENDPOINT,
 885				.data = & (const struct snd_usb_midi_endpoint_info) {
 886					.out_cables = 0x0001,
 887					.in_cables  = 0x0001
 888				}
 889			},
 890			{
 891				.ifnum = -1
 892			}
 893		}
 894	}
 895},
 896{
 897	/* has ID 0x0028 when not in "Advanced Driver" mode */
 898	USB_DEVICE(0x0582, 0x0027),
 899	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 900		.vendor_name = "EDIROL",
 901		.product_name = "SD-20",
 902		.ifnum = 0,
 903		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 904		.data = & (const struct snd_usb_midi_endpoint_info) {
 905			.out_cables = 0x0003,
 906			.in_cables  = 0x0007
 907		}
 908	}
 909},
 910{
 911	/* has ID 0x002a when not in "Advanced Driver" mode */
 912	USB_DEVICE(0x0582, 0x0029),
 913	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 914		.vendor_name = "EDIROL",
 915		.product_name = "SD-80",
 916		.ifnum = 0,
 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{	/*
 925	 * This quirk is for the "Advanced" modes of the Edirol UA-700.
 926	 * If the sample format switch is not in an advanced setting, the
 927	 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
 928	 * but offers only 16-bit PCM and no MIDI.
 929	 */
 930	USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
 931	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 932		.vendor_name = "EDIROL",
 933		.product_name = "UA-700",
 934		.ifnum = QUIRK_ANY_INTERFACE,
 935		.type = QUIRK_COMPOSITE,
 936		.data = (const struct snd_usb_audio_quirk[]) {
 937			{
 938				.ifnum = 1,
 939				.type = QUIRK_AUDIO_EDIROL_UAXX
 940			},
 941			{
 942				.ifnum = 2,
 943				.type = QUIRK_AUDIO_EDIROL_UAXX
 944			},
 945			{
 946				.ifnum = 3,
 947				.type = QUIRK_AUDIO_EDIROL_UAXX
 948			},
 949			{
 950				.ifnum = -1
 951			}
 952		}
 953	}
 954},
 955{
 956	/* has ID 0x002e when not in "Advanced Driver" mode */
 957	USB_DEVICE(0x0582, 0x002d),
 958	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 959		.vendor_name = "Roland",
 960		.product_name = "XV-2020",
 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 0x0030 when not in "Advanced Driver" mode */
 971	USB_DEVICE(0x0582, 0x002f),
 972	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 973		.vendor_name = "Roland",
 974		.product_name = "VariOS",
 975		.ifnum = 0,
 976		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 977		.data = & (const struct snd_usb_midi_endpoint_info) {
 978			.out_cables = 0x0007,
 979			.in_cables  = 0x0007
 980		}
 981	}
 982},
 983{
 984	/* has ID 0x0034 when not in "Advanced Driver" mode */
 985	USB_DEVICE(0x0582, 0x0033),
 986	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 987		.vendor_name = "EDIROL",
 988		.product_name = "PCR",
 989		.ifnum = 0,
 990		.type = QUIRK_MIDI_FIXED_ENDPOINT,
 991		.data = & (const struct snd_usb_midi_endpoint_info) {
 992			.out_cables = 0x0003,
 993			.in_cables  = 0x0007
 994		}
 995	}
 996},
 997	/* TODO: add Roland M-1000 support */
 998{
 999	/*
1000	 * Has ID 0x0038 when not in "Advanced Driver" mode;
1001	 * later revisions use IDs 0x0054 and 0x00a2.
1002	 */
1003	USB_DEVICE(0x0582, 0x0037),
1004	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1005		.vendor_name = "Roland",
1006		.product_name = "Digital Piano",
1007		.ifnum = 0,
1008		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1009		.data = & (const struct snd_usb_midi_endpoint_info) {
1010			.out_cables = 0x0001,
1011			.in_cables  = 0x0001
1012		}
1013	}
1014},
1015{
1016	/*
1017	 * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
1018	 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1019	 * and no MIDI.
1020	 */
1021	USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1022	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1023		.vendor_name = "BOSS",
1024		.product_name = "GS-10",
1025		.ifnum = QUIRK_ANY_INTERFACE,
1026		.type = QUIRK_COMPOSITE,
1027		.data = & (const struct snd_usb_audio_quirk[]) {
1028			{
1029				.ifnum = 1,
1030				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1031			},
1032			{
1033				.ifnum = 2,
1034				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1035			},
1036			{
1037				.ifnum = 3,
1038				.type = QUIRK_MIDI_STANDARD_INTERFACE
1039			},
1040			{
1041				.ifnum = -1
1042			}
1043		}
1044	}
1045},
1046{
1047	/* has ID 0x0041 when not in "Advanced Driver" mode */
1048	USB_DEVICE(0x0582, 0x0040),
1049	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1050		.vendor_name = "Roland",
1051		.product_name = "GI-20",
1052		.ifnum = 0,
1053		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1054		.data = & (const struct snd_usb_midi_endpoint_info) {
1055			.out_cables = 0x0001,
1056			.in_cables  = 0x0001
1057		}
1058	}
1059},
1060{
1061	/* has ID 0x0043 when not in "Advanced Driver" mode */
1062	USB_DEVICE(0x0582, 0x0042),
1063	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1064		.vendor_name = "Roland",
1065		.product_name = "RS-70",
1066		.ifnum = 0,
1067		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1068		.data = & (const struct snd_usb_midi_endpoint_info) {
1069			.out_cables = 0x0001,
1070			.in_cables  = 0x0001
1071		}
1072	}
1073},
1074{
1075	/* has ID 0x0049 when not in "Advanced Driver" mode */
1076	USB_DEVICE(0x0582, 0x0047),
1077	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1078		/* .vendor_name = "EDIROL", */
1079		/* .product_name = "UR-80", */
1080		.ifnum = QUIRK_ANY_INTERFACE,
1081		.type = QUIRK_COMPOSITE,
1082		.data = (const struct snd_usb_audio_quirk[]) {
1083			/* in the 96 kHz modes, only interface 1 is there */
1084			{
1085				.ifnum = 1,
1086				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1087			},
1088			{
1089				.ifnum = 2,
1090				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1091			},
1092			{
1093				.ifnum = -1
1094			}
1095		}
1096	}
1097},
1098{
1099	/* has ID 0x004a when not in "Advanced Driver" mode */
1100	USB_DEVICE(0x0582, 0x0048),
1101	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1102		/* .vendor_name = "EDIROL", */
1103		/* .product_name = "UR-80", */
1104		.ifnum = 0,
1105		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1106		.data = & (const struct snd_usb_midi_endpoint_info) {
1107			.out_cables = 0x0003,
1108			.in_cables  = 0x0007
1109		}
1110	}
1111},
1112	/* TODO: add Edirol M-100FX support */
1113{
1114	/* has ID 0x004e when not in "Advanced Driver" mode */
1115	USB_DEVICE(0x0582, 0x004c),
1116	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1117		.vendor_name = "EDIROL",
1118		.product_name = "PCR-A",
1119		.ifnum = QUIRK_ANY_INTERFACE,
1120		.type = QUIRK_COMPOSITE,
1121		.data = (const struct snd_usb_audio_quirk[]) {
1122			{
1123				.ifnum = 1,
1124				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1125			},
1126			{
1127				.ifnum = 2,
1128				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1129			},
1130			{
1131				.ifnum = -1
1132			}
1133		}
1134	}
1135},
1136{
1137	/* has ID 0x004f when not in "Advanced Driver" mode */
1138	USB_DEVICE(0x0582, 0x004d),
1139	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1140		.vendor_name = "EDIROL",
1141		.product_name = "PCR-A",
1142		.ifnum = 0,
1143		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1144		.data = & (const struct snd_usb_midi_endpoint_info) {
1145			.out_cables = 0x0003,
1146			.in_cables  = 0x0007
1147		}
1148	}
1149},
1150{
1151	/*
1152	 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1153	 * is standard compliant, but has only 16-bit PCM.
1154	 */
1155	USB_DEVICE(0x0582, 0x0050),
1156	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1157		.vendor_name = "EDIROL",
1158		.product_name = "UA-3FX",
1159		.ifnum = QUIRK_ANY_INTERFACE,
1160		.type = QUIRK_COMPOSITE,
1161		.data = (const struct snd_usb_audio_quirk[]) {
1162			{
1163				.ifnum = 1,
1164				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1165			},
1166			{
1167				.ifnum = 2,
1168				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1169			},
1170			{
1171				.ifnum = -1
1172			}
1173		}
1174	}
1175},
1176{
1177	USB_DEVICE(0x0582, 0x0052),
1178	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1179		.vendor_name = "EDIROL",
1180		.product_name = "UM-1SX",
1181		.ifnum = 0,
1182		.type = QUIRK_MIDI_STANDARD_INTERFACE
1183	}
1184},
1185{
1186	USB_DEVICE(0x0582, 0x0060),
1187	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1188		.vendor_name = "Roland",
1189		.product_name = "EXR Series",
1190		.ifnum = 0,
1191		.type = QUIRK_MIDI_STANDARD_INTERFACE
1192	}
1193},
1194{
1195	/* has ID 0x0066 when not in "Advanced Driver" mode */
1196	USB_DEVICE(0x0582, 0x0064),
1197	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1198		/* .vendor_name = "EDIROL", */
1199		/* .product_name = "PCR-1", */
1200		.ifnum = QUIRK_ANY_INTERFACE,
1201		.type = QUIRK_COMPOSITE,
1202		.data = (const struct snd_usb_audio_quirk[]) {
1203			{
1204				.ifnum = 1,
1205				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1206			},
1207			{
1208				.ifnum = 2,
1209				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1210			},
1211			{
1212				.ifnum = -1
1213			}
1214		}
1215	}
1216},
1217{
1218	/* has ID 0x0067 when not in "Advanced Driver" mode */
1219	USB_DEVICE(0x0582, 0x0065),
1220	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1221		/* .vendor_name = "EDIROL", */
1222		/* .product_name = "PCR-1", */
1223		.ifnum = 0,
1224		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1225		.data = & (const struct snd_usb_midi_endpoint_info) {
1226			.out_cables = 0x0001,
1227			.in_cables  = 0x0003
1228		}
1229	}
1230},
1231{
1232	/* has ID 0x006b when not in "Advanced Driver" mode */
1233	USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1234	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1235		.vendor_name = "Roland",
1236		.product_name = "SP-606",
1237		.ifnum = 3,
1238		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1239		.data = & (const struct snd_usb_midi_endpoint_info) {
1240			.out_cables = 0x0001,
1241			.in_cables  = 0x0001
1242		}
1243	}
1244},
1245{
1246	/* has ID 0x006e when not in "Advanced Driver" mode */
1247	USB_DEVICE(0x0582, 0x006d),
1248	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1249		.vendor_name = "Roland",
1250		.product_name = "FANTOM-X",
1251		.ifnum = 0,
1252		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1253		.data = & (const struct snd_usb_midi_endpoint_info) {
1254			.out_cables = 0x0001,
1255			.in_cables  = 0x0001
1256		}
1257	}
1258},
1259{	/*
1260	 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1261	 * If the switch is not in an advanced setting, the UA-25 has
1262	 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1263	 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1264	 */
1265	USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1266	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1267		.vendor_name = "EDIROL",
1268		.product_name = "UA-25",
1269		.ifnum = QUIRK_ANY_INTERFACE,
1270		.type = QUIRK_COMPOSITE,
1271		.data = (const struct snd_usb_audio_quirk[]) {
1272			{
1273				.ifnum = 0,
1274				.type = QUIRK_AUDIO_EDIROL_UAXX
1275			},
1276			{
1277				.ifnum = 1,
1278				.type = QUIRK_AUDIO_EDIROL_UAXX
1279			},
1280			{
1281				.ifnum = 2,
1282				.type = QUIRK_AUDIO_EDIROL_UAXX
1283			},
1284			{
1285				.ifnum = -1
1286			}
1287		}
1288	}
1289},
1290{
1291	/* has ID 0x0076 when not in "Advanced Driver" mode */
1292	USB_DEVICE(0x0582, 0x0075),
1293	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1294		.vendor_name = "BOSS",
1295		.product_name = "DR-880",
1296		.ifnum = 0,
1297		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1298		.data = & (const struct snd_usb_midi_endpoint_info) {
1299			.out_cables = 0x0001,
1300			.in_cables  = 0x0001
1301		}
1302	}
1303},
1304{
1305	/* has ID 0x007b when not in "Advanced Driver" mode */
1306	USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1307	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1308		.vendor_name = "Roland",
1309		/* "RD" or "RD-700SX"? */
1310		.ifnum = 0,
1311		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1312		.data = & (const struct snd_usb_midi_endpoint_info) {
1313			.out_cables = 0x0003,
1314			.in_cables  = 0x0003
1315		}
1316	}
1317},
1318{
1319	/* has ID 0x0081 when not in "Advanced Driver" mode */
1320	USB_DEVICE(0x0582, 0x0080),
1321	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1322		.vendor_name = "Roland",
1323		.product_name = "G-70",
1324		.ifnum = 0,
1325		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1326		.data = & (const struct snd_usb_midi_endpoint_info) {
1327			.out_cables = 0x0001,
1328			.in_cables  = 0x0001
1329		}
1330	}
1331},
1332	/* TODO: add Roland V-SYNTH XT support */
1333	/* TODO: add BOSS GT-PRO support */
1334{
1335	/* has ID 0x008c when not in "Advanced Driver" mode */
1336	USB_DEVICE(0x0582, 0x008b),
1337	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1338		.vendor_name = "EDIROL",
1339		.product_name = "PC-50",
1340		.ifnum = 0,
1341		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1342		.data = & (const struct snd_usb_midi_endpoint_info) {
1343			.out_cables = 0x0001,
1344			.in_cables  = 0x0001
1345		}
1346	}
1347},
1348	/* TODO: add Edirol PC-80 support */
1349{
1350	USB_DEVICE(0x0582, 0x0096),
1351	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1352		.vendor_name = "EDIROL",
1353		.product_name = "UA-1EX",
1354		.ifnum = QUIRK_ANY_INTERFACE,
1355		.type = QUIRK_COMPOSITE,
1356		.data = (const struct snd_usb_audio_quirk[]) {
1357			{
1358				.ifnum = 0,
1359				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1360			},
1361			{
1362				.ifnum = 1,
1363				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1364			},
1365			{
1366				.ifnum = -1
1367			}
1368		}
1369	}
1370},
1371{
1372	USB_DEVICE(0x0582, 0x009a),
1373	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1374		.vendor_name = "EDIROL",
1375		.product_name = "UM-3EX",
1376		.ifnum = 0,
1377		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1378		.data = & (const struct snd_usb_midi_endpoint_info) {
1379			.out_cables = 0x000f,
1380			.in_cables  = 0x000f
1381		}
1382	}
1383},
1384{
1385	/*
1386	 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1387	 * is standard compliant, but has only 16-bit PCM and no MIDI.
1388	 */
1389	USB_DEVICE(0x0582, 0x00a3),
1390	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1391		.vendor_name = "EDIROL",
1392		.product_name = "UA-4FX",
1393		.ifnum = QUIRK_ANY_INTERFACE,
1394		.type = QUIRK_COMPOSITE,
1395		.data = (const struct snd_usb_audio_quirk[]) {
1396			{
1397				.ifnum = 0,
1398				.type = QUIRK_AUDIO_EDIROL_UAXX
1399			},
1400			{
1401				.ifnum = 1,
1402				.type = QUIRK_AUDIO_EDIROL_UAXX
1403			},
1404			{
1405				.ifnum = 2,
1406				.type = QUIRK_AUDIO_EDIROL_UAXX
1407			},
1408			{
1409				.ifnum = -1
1410			}
1411		}
1412	}
1413},
1414	/* TODO: add Edirol MD-P1 support */
1415{
1416	USB_DEVICE(0x582, 0x00a6),
1417	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1418		.vendor_name = "Roland",
1419		.product_name = "Juno-G",
1420		.ifnum = 0,
1421		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1422		.data = & (const struct snd_usb_midi_endpoint_info) {
1423			.out_cables = 0x0001,
1424			.in_cables  = 0x0001
1425		}
1426	}
1427},
1428{
1429	/* Roland SH-201 */
1430	USB_DEVICE(0x0582, 0x00ad),
1431	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1432		.vendor_name = "Roland",
1433		.product_name = "SH-201",
1434		.ifnum = QUIRK_ANY_INTERFACE,
1435		.type = QUIRK_COMPOSITE,
1436		.data = (const struct snd_usb_audio_quirk[]) {
1437			{
1438				.ifnum = 0,
1439				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1440			},
1441			{
1442				.ifnum = 1,
1443				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1444			},
1445			{
1446				.ifnum = 2,
1447				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1448				.data = & (const struct snd_usb_midi_endpoint_info) {
1449					.out_cables = 0x0001,
1450					.in_cables  = 0x0001
1451				}
1452			},
1453			{
1454				.ifnum = -1
1455			}
1456		}
1457	}
1458},
1459{
1460	/* Roland SonicCell */
1461	USB_DEVICE(0x0582, 0x00c2),
1462	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1463		.vendor_name = "Roland",
1464		.product_name = "SonicCell",
1465		.ifnum = QUIRK_ANY_INTERFACE,
1466		.type = QUIRK_COMPOSITE,
1467		.data = (const struct snd_usb_audio_quirk[]) {
1468			{
1469				.ifnum = 0,
1470				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1471			},
1472			{
1473				.ifnum = 1,
1474				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1475			},
1476			{
1477				.ifnum = 2,
1478				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1479				.data = & (const struct snd_usb_midi_endpoint_info) {
1480					.out_cables = 0x0001,
1481					.in_cables  = 0x0001
1482				}
1483			},
1484			{
1485				.ifnum = -1
1486			}
1487		}
1488	}
1489},
1490{
1491	/* Edirol M-16DX */
1492	/* FIXME: This quirk gives a good-working capture stream but the
1493	 *        playback seems problematic because of lacking of sync
1494	 *        with capture stream.  It needs to sync with the capture
1495	 *        clock.  As now, you'll get frequent sound distortions
1496	 *        via the playback.
1497	 */
1498	USB_DEVICE(0x0582, 0x00c4),
1499	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1500		.ifnum = QUIRK_ANY_INTERFACE,
1501		.type = QUIRK_COMPOSITE,
1502		.data = (const struct snd_usb_audio_quirk[]) {
1503			{
1504				.ifnum = 0,
1505				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1506			},
1507			{
1508				.ifnum = 1,
1509				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1510			},
1511			{
1512				.ifnum = 2,
1513				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1514				.data = & (const struct snd_usb_midi_endpoint_info) {
1515					.out_cables = 0x0001,
1516					.in_cables  = 0x0001
1517				}
1518			},
1519			{
1520				.ifnum = -1
1521			}
1522		}
1523	}
1524},
1525{
1526	/* BOSS GT-10 */
1527	USB_DEVICE(0x0582, 0x00da),
1528	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1529		.ifnum = QUIRK_ANY_INTERFACE,
1530		.type = QUIRK_COMPOSITE,
1531		.data = (const struct snd_usb_audio_quirk[]) {
1532			{
1533				.ifnum = 0,
1534				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1535			},
1536			{
1537				.ifnum = 1,
1538				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1539			},
1540			{
1541				.ifnum = 2,
1542				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1543				.data = & (const struct snd_usb_midi_endpoint_info) {
1544					.out_cables = 0x0001,
1545					.in_cables  = 0x0001
1546				}
1547			},
1548			{
1549				.ifnum = -1
1550			}
1551		}
1552	}
1553},
1554{
1555	/* Advanced modes of the Edirol UA-25EX.
1556	 * For the standard mode, UA-25EX has ID 0582:00e7, which
1557	 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1558	 */
1559	USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1560	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1561		.vendor_name = "EDIROL",
1562		.product_name = "UA-25EX",
1563		.ifnum = QUIRK_ANY_INTERFACE,
1564		.type = QUIRK_COMPOSITE,
1565		.data = (const struct snd_usb_audio_quirk[]) {
1566			{
1567				.ifnum = 0,
1568				.type = QUIRK_AUDIO_EDIROL_UAXX
1569			},
1570			{
1571				.ifnum = 1,
1572				.type = QUIRK_AUDIO_EDIROL_UAXX
1573			},
1574			{
1575				.ifnum = 2,
1576				.type = QUIRK_AUDIO_EDIROL_UAXX
1577			},
1578			{
1579				.ifnum = -1
1580			}
1581		}
1582	}
1583},
1584{
1585	/* has ID 0x00ea when not in Advanced Driver mode */
1586	USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9),
1587	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1588		/* .vendor_name = "Roland", */
1589		/* .product_name = "UA-1G", */
1590		.ifnum = QUIRK_ANY_INTERFACE,
1591		.type = QUIRK_COMPOSITE,
1592		.data = (const struct snd_usb_audio_quirk[]) {
1593			{
1594				.ifnum = 0,
1595				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1596			},
1597			{
1598				.ifnum = 1,
1599				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1600			},
1601			{
1602				.ifnum = -1
1603			}
1604		}
1605	}
1606},
1607{
1608	USB_DEVICE_VENDOR_SPEC(0x0582, 0x0104),
1609	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1610		/* .vendor_name = "Roland", */
1611		/* .product_name = "UM-1G", */
1612		.ifnum = 0,
1613		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1614		.data = & (const struct snd_usb_midi_endpoint_info) {
1615			.out_cables = 0x0001,
1616			.in_cables  = 0x0001
1617		}
1618	}
1619},
1620{
1621	/* Edirol UM-3G */
1622	USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1623	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1624		.ifnum = 0,
1625		.type = QUIRK_MIDI_STANDARD_INTERFACE
1626	}
1627},
1628{
1629	/* Boss JS-8 Jam Station  */
1630	USB_DEVICE(0x0582, 0x0109),
1631	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1632		/* .vendor_name = "BOSS", */
1633		/* .product_name = "JS-8", */
1634		.ifnum = QUIRK_ANY_INTERFACE,
1635		.type = QUIRK_COMPOSITE,
1636		.data = (const struct snd_usb_audio_quirk[]) {
1637			{
1638				.ifnum = 0,
1639				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1640			},
1641			{
1642				.ifnum = 1,
1643				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1644			},
1645			{
1646				.ifnum = 2,
1647				.type = QUIRK_MIDI_STANDARD_INTERFACE
1648			},
1649			{
1650				.ifnum = -1
1651			}
1652		}
1653	}
1654},
1655{
1656	/* has ID 0x0110 when not in Advanced Driver mode */
1657	USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f),
1658	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1659		/* .vendor_name = "Roland", */
1660		/* .product_name = "A-PRO", */
1661		.ifnum = 1,
1662		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1663		.data = & (const struct snd_usb_midi_endpoint_info) {
1664			.out_cables = 0x0003,
1665			.in_cables  = 0x0007
1666		}
1667	}
1668},
1669{
1670	/* Roland GAIA SH-01 */
1671	USB_DEVICE(0x0582, 0x0111),
1672	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1673		.vendor_name = "Roland",
1674		.product_name = "GAIA",
1675		.ifnum = QUIRK_ANY_INTERFACE,
1676		.type = QUIRK_COMPOSITE,
1677		.data = (const struct snd_usb_audio_quirk[]) {
1678			{
1679				.ifnum = 0,
1680				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1681			},
1682			{
1683				.ifnum = 1,
1684				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1685			},
1686			{
1687				.ifnum = 2,
1688				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1689				.data = &(const struct snd_usb_midi_endpoint_info) {
1690				.out_cables = 0x0003,
1691				.in_cables  = 0x0003
1692				}
1693			},
1694			{
1695				.ifnum = -1
1696			}
1697		}
1698	}
1699},
1700{
1701	USB_DEVICE(0x0582, 0x0113),
1702	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1703		/* .vendor_name = "BOSS", */
1704		/* .product_name = "ME-25", */
1705		.ifnum = QUIRK_ANY_INTERFACE,
1706		.type = QUIRK_COMPOSITE,
1707		.data = (const struct snd_usb_audio_quirk[]) {
1708			{
1709				.ifnum = 0,
1710				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1711			},
1712			{
1713				.ifnum = 1,
1714				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1715			},
1716			{
1717				.ifnum = 2,
1718				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1719				.data = & (const struct snd_usb_midi_endpoint_info) {
1720					.out_cables = 0x0001,
1721					.in_cables  = 0x0001
1722				}
1723			},
1724			{
1725				.ifnum = -1
1726			}
1727		}
1728	}
1729},
1730{
1731	USB_DEVICE(0x0582, 0x0127),
1732	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1733		/* .vendor_name = "Roland", */
1734		/* .product_name = "GR-55", */
1735		.ifnum = QUIRK_ANY_INTERFACE,
1736		.type = QUIRK_COMPOSITE,
1737		.data = (const struct snd_usb_audio_quirk[]) {
1738			{
1739				.ifnum = 0,
1740				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1741			},
1742			{
1743				.ifnum = 1,
1744				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1745			},
1746			{
1747				.ifnum = 2,
1748				.type = QUIRK_MIDI_STANDARD_INTERFACE
1749			},
1750			{
1751				.ifnum = -1
1752			}
1753		}
1754	}
1755},
1756{
1757	/* Added support for Roland UM-ONE which differs from UM-1 */
1758	USB_DEVICE(0x0582, 0x012a),
1759	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1760		/* .vendor_name = "ROLAND", */
1761		/* .product_name = "UM-ONE", */
1762		.ifnum = 0,
1763		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1764		.data = & (const struct snd_usb_midi_endpoint_info) {
1765			.out_cables = 0x0001,
1766			.in_cables  = 0x0003
1767		}
1768	}
1769},
1770{
1771	USB_DEVICE(0x0582, 0x011e),
1772	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1773		/* .vendor_name = "BOSS", */
1774		/* .product_name = "BR-800", */
1775		.ifnum = QUIRK_ANY_INTERFACE,
1776		.type = QUIRK_COMPOSITE,
1777		.data = (const struct snd_usb_audio_quirk[]) {
1778			{
1779				.ifnum = 0,
1780				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1781			},
1782			{
1783				.ifnum = 1,
1784				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1785			},
1786			{
1787				.ifnum = 2,
1788				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1789				.data = & (const struct snd_usb_midi_endpoint_info) {
1790					.out_cables = 0x0001,
1791					.in_cables  = 0x0001
1792				}
1793			},
1794			{
1795				.ifnum = -1
1796			}
1797		}
1798	}
1799},
1800{
1801	USB_DEVICE(0x0582, 0x0130),
1802	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1803		/* .vendor_name = "BOSS", */
1804		/* .product_name = "MICRO BR-80", */
1805		.ifnum = QUIRK_ANY_INTERFACE,
1806		.type = QUIRK_COMPOSITE,
1807		.data = (const struct snd_usb_audio_quirk[]) {
1808			{
1809				.ifnum = 0,
1810				.type = QUIRK_IGNORE_INTERFACE
1811			},
1812			{
1813				.ifnum = 1,
1814				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1815			},
1816			{
1817				.ifnum = 2,
1818				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1819			},
1820			{
1821				.ifnum = 3,
1822				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1823				.data = & (const struct snd_usb_midi_endpoint_info) {
1824					.out_cables = 0x0001,
1825					.in_cables  = 0x0001
1826				}
1827			},
1828			{
1829				.ifnum = -1
1830			}
1831		}
1832	}
1833},
1834{
1835	USB_DEVICE(0x0582, 0x014d),
1836	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1837		/* .vendor_name = "BOSS", */
1838		/* .product_name = "GT-100", */
1839		.ifnum = QUIRK_ANY_INTERFACE,
1840		.type = QUIRK_COMPOSITE,
1841		.data = (const struct snd_usb_audio_quirk[]) {
1842			{
1843				.ifnum = 1,
1844				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1845			},
1846			{
1847				.ifnum = 2,
1848				.type = QUIRK_AUDIO_STANDARD_INTERFACE
1849			},
1850			{
1851				.ifnum = 3,
1852				.type = QUIRK_MIDI_FIXED_ENDPOINT,
1853				.data = & (const struct snd_usb_midi_endpoint_info) {
1854					.out_cables = 0x0001,
1855					.in_cables  = 0x0001
1856				}
1857			},
1858			{
1859				.ifnum = -1
1860			}
1861		}
1862	}
1863},
1864
1865/* Guillemot devices */
1866{
1867	/*
1868	 * This is for the "Windows Edition" where the external MIDI ports are
1869	 * the only MIDI ports; the control data is reported through HID
1870	 * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1871	 * compliant USB MIDI ports for external MIDI and controls.
1872	 */
1873	USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1874	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1875		.vendor_name = "Hercules",
1876		.product_name = "DJ Console (WE)",
1877		.ifnum = 4,
1878		.type = QUIRK_MIDI_FIXED_ENDPOINT,
1879		.data = & (const struct snd_usb_midi_endpoint_info) {
1880			.out_cables = 0x0001,
1881			.in_cables = 0x0001
1882		}
1883	}
1884},
1885
1886/* Midiman/M-Audio devices */
1887{
1888	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1889	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1890		.vendor_name = "M-Audio",
1891		.product_name = "MidiSport 2x2",
1892		.ifnum = QUIRK_ANY_INTERFACE,
1893		.type = QUIRK_MIDI_MIDIMAN,
1894		.data = & (const struct snd_usb_midi_endpoint_info) {
1895			.out_cables = 0x0003,
1896			.in_cables  = 0x0003
1897		}
1898	}
1899},
1900{
1901	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1902	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1903		.vendor_name = "M-Audio",
1904		.product_name = "MidiSport 1x1",
1905		.ifnum = QUIRK_ANY_INTERFACE,
1906		.type = QUIRK_MIDI_MIDIMAN,
1907		.data = & (const struct snd_usb_midi_endpoint_info) {
1908			.out_cables = 0x0001,
1909			.in_cables  = 0x0001
1910		}
1911	}
1912},
1913{
1914	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1915	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1916		.vendor_name = "M-Audio",
1917		.product_name = "Keystation",
1918		.ifnum = QUIRK_ANY_INTERFACE,
1919		.type = QUIRK_MIDI_MIDIMAN,
1920		.data = & (const struct snd_usb_midi_endpoint_info) {
1921			.out_cables = 0x0001,
1922			.in_cables  = 0x0001
1923		}
1924	}
1925},
1926{
1927	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1928	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1929		.vendor_name = "M-Audio",
1930		.product_name = "MidiSport 4x4",
1931		.ifnum = QUIRK_ANY_INTERFACE,
1932		.type = QUIRK_MIDI_MIDIMAN,
1933		.data = & (const struct snd_usb_midi_endpoint_info) {
1934			.out_cables = 0x000f,
1935			.in_cables  = 0x000f
1936		}
1937	}
1938},
1939{
1940	/*
1941	 * For hardware revision 1.05; in the later revisions (1.10 and
1942	 * 1.21), 0x1031 is the ID for the device without firmware.
1943	 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1944	 */
1945	USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1946	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1947		.vendor_name = "M-Audio",
1948		.product_name = "MidiSport 8x8",
1949		.ifnum = QUIRK_ANY_INTERFACE,
1950		.type = QUIRK_MIDI_MIDIMAN,
1951		.data = & (const struct snd_usb_midi_endpoint_info) {
1952			.out_cables = 0x01ff,
1953			.in_cables  = 0x01ff
1954		}
1955	}
1956},
1957{
1958	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1959	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1960		.vendor_name = "M-Audio",
1961		.product_name = "MidiSport 8x8",
1962		.ifnum = QUIRK_ANY_INTERFACE,
1963		.type = QUIRK_MIDI_MIDIMAN,
1964		.data = & (const struct snd_usb_midi_endpoint_info) {
1965			.out_cables = 0x01ff,
1966			.in_cables  = 0x01ff
1967		}
1968	}
1969},
1970{
1971	USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1972	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1973		.vendor_name = "M-Audio",
1974		.product_name = "MidiSport 2x4",
1975		.ifnum = QUIRK_ANY_INTERFACE,
1976		.type = QUIRK_MIDI_MIDIMAN,
1977		.data = & (const struct snd_usb_midi_endpoint_info) {
1978			.out_cables = 0x000f,
1979			.in_cables  = 0x0003
1980		}
1981	}
1982},
1983{
1984	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1985	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1986		.vendor_name = "M-Audio",
1987		.product_name = "Quattro",
1988		.ifnum = QUIRK_ANY_INTERFACE,
1989		.type = QUIRK_COMPOSITE,
1990		.data = & (const struct snd_usb_audio_quirk[]) {
1991			/*
1992			 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1993			 * and share endpoints with the other interfaces.
1994			 * Ignore them.  The other interfaces can do 24 bits,
1995			 * but captured samples are big-endian (see usbaudio.c).
1996			 */
1997			{
1998				.ifnum = 0,
1999				.type = QUIRK_IGNORE_INTERFACE
2000			},
2001			{
2002				.ifnum = 1,
2003				.type = QUIRK_IGNORE_INTERFACE
2004			},
2005			{
2006				.ifnum = 2,
2007				.type = QUIRK_IGNORE_INTERFACE
2008			},
2009			{
2010				.ifnum = 3,
2011				.type = QUIRK_IGNORE_INTERFACE
2012			},
2013			{
2014				.ifnum = 4,
2015				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2016			},
2017			{
2018				.ifnum = 5,
2019				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2020			},
2021			{
2022				.ifnum = 6,
2023				.type = QUIRK_IGNORE_INTERFACE
2024			},
2025			{
2026				.ifnum = 7,
2027				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2028			},
2029			{
2030				.ifnum = 8,
2031				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2032			},
2033			{
2034				.ifnum = 9,
2035				.type = QUIRK_MIDI_MIDIMAN,
2036				.data = & (const struct snd_usb_midi_endpoint_info) {
2037					.out_cables = 0x0001,
2038					.in_cables  = 0x0001
2039				}
2040			},
2041			{
2042				.ifnum = -1
2043			}
2044		}
2045	}
2046},
2047{
2048	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
2049	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2050		.vendor_name = "M-Audio",
2051		.product_name = "AudioPhile",
2052		.ifnum = 6,
2053		.type = QUIRK_MIDI_MIDIMAN,
2054		.data = & (const struct snd_usb_midi_endpoint_info) {
2055			.out_cables = 0x0001,
2056			.in_cables  = 0x0001
2057		}
2058	}
2059},
2060{
2061	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
2062	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2063		.vendor_name = "M-Audio",
2064		.product_name = "Ozone",
2065		.ifnum = 3,
2066		.type = QUIRK_MIDI_MIDIMAN,
2067		.data = & (const struct snd_usb_midi_endpoint_info) {
2068			.out_cables = 0x0001,
2069			.in_cables  = 0x0001
2070		}
2071	}
2072},
2073{
2074	USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
2075	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2076		.vendor_name = "M-Audio",
2077		.product_name = "OmniStudio",
2078		.ifnum = QUIRK_ANY_INTERFACE,
2079		.type = QUIRK_COMPOSITE,
2080		.data = & (const struct snd_usb_audio_quirk[]) {
2081			{
2082				.ifnum = 0,
2083				.type = QUIRK_IGNORE_INTERFACE
2084			},
2085			{
2086				.ifnum = 1,
2087				.type = QUIRK_IGNORE_INTERFACE
2088			},
2089			{
2090				.ifnum = 2,
2091				.type = QUIRK_IGNORE_INTERFACE
2092			},
2093			{
2094				.ifnum = 3,
2095				.type = QUIRK_IGNORE_INTERFACE
2096			},
2097			{
2098				.ifnum = 4,
2099				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2100			},
2101			{
2102				.ifnum = 5,
2103				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2104			},
2105			{
2106				.ifnum = 6,
2107				.type = QUIRK_IGNORE_INTERFACE
2108			},
2109			{
2110				.ifnum = 7,
2111				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2112			},
2113			{
2114				.ifnum = 8,
2115				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2116			},
2117			{
2118				.ifnum = 9,
2119				.type = QUIRK_MIDI_MIDIMAN,
2120				.data = & (const struct snd_usb_midi_endpoint_info) {
2121					.out_cables = 0x0001,
2122					.in_cables  = 0x0001
2123				}
2124			},
2125			{
2126				.ifnum = -1
2127			}
2128		}
2129	}
2130},
2131{
2132	USB_DEVICE(0x0763, 0x2019),
2133	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2134		/* .vendor_name = "M-Audio", */
2135		/* .product_name = "Ozone Academic", */
2136		.ifnum = QUIRK_ANY_INTERFACE,
2137		.type = QUIRK_COMPOSITE,
2138		.data = & (const struct snd_usb_audio_quirk[]) {
2139			{
2140				.ifnum = 0,
2141				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2142			},
2143			{
2144				.ifnum = 1,
2145				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2146			},
2147			{
2148				.ifnum = 2,
2149				.type = QUIRK_AUDIO_STANDARD_INTERFACE
2150			},
2151			{
2152				.ifnum = 3,
2153				.type = QUIRK_MIDI_MIDIMAN,
2154				.data = & (const struct snd_usb_midi_endpoint_info) {
2155					.out_cables = 0x0001,
2156					.in_cables  = 0x0001
2157				}
2158			},
2159			{
2160				.ifnum = -1
2161			}
2162		}
2163	}
2164},
2165{
2166	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2167	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2168		/* .vendor_name = "M-Audio", */
2169		/* .product_name = "Fast Track Ultra", */
2170		.ifnum = QUIRK_ANY_INTERFACE,
2171		.type = QUIRK_COMPOSITE,
2172		.data = & (const struct snd_usb_audio_quirk[]) {
2173			{
2174				.ifnum = 0,
2175				.type = QUIRK_AUDIO_STANDARD_MIXER,
2176			},
2177			{
2178				.ifnum = 1,
2179				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2180				.data = & (const struct audioformat) {
2181					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2182					.channels = 8,
2183					.iface = 1,
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				}
2200			},
2201			{
2202				.ifnum = 2,
2203				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2204				.data = & (const struct audioformat) {
2205					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2206					.channels = 8,
2207					.iface = 2,
2208					.altsetting = 1,
2209					.altset_idx = 1,
2210					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2211					.endpoint = 0x81,
2212					.ep_attr = 0x05,
2213					.rates = SNDRV_PCM_RATE_44100 |
2214						 SNDRV_PCM_RATE_48000 |
2215						 SNDRV_PCM_RATE_88200 |
2216						 SNDRV_PCM_RATE_96000,
2217					.rate_min = 44100,
2218					.rate_max = 96000,
2219					.nr_rates = 4,
2220					.rate_table = (unsigned int[]) {
2221						44100, 48000, 88200, 96000
2222					}
2223				}
2224			},
2225			/* interface 3 (MIDI) is standard compliant */
2226			{
2227				.ifnum = -1
2228			}
2229		}
2230	}
2231},
2232{
2233	USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2234	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2235		/* .vendor_name = "M-Audio", */
2236		/* .product_name = "Fast Track Ultra 8R", */
2237		.ifnum = QUIRK_ANY_INTERFACE,
2238		.type = QUIRK_COMPOSITE,
2239		.data = & (const struct snd_usb_audio_quirk[]) {
2240			{
2241				.ifnum = 0,
2242				.type = QUIRK_AUDIO_STANDARD_MIXER,
2243			},
2244			{
2245				.ifnum = 1,
2246				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2247				.data = & (const struct audioformat) {
2248					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2249					.channels = 8,
2250					.iface = 1,
2251					.altsetting = 1,
2252					.altset_idx = 1,
2253					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2254					.endpoint = 0x01,
2255					.ep_attr = 0x09,
2256					.rates = SNDRV_PCM_RATE_44100 |
2257						 SNDRV_PCM_RATE_48000 |
2258						 SNDRV_PCM_RATE_88200 |
2259						 SNDRV_PCM_RATE_96000,
2260					.rate_min = 44100,
2261					.rate_max = 96000,
2262					.nr_rates = 4,
2263					.rate_table = (unsigned int[]) {
2264							44100, 48000, 88200, 96000
2265					}
2266				}
2267			},
2268			{
2269				.ifnum = 2,
2270				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2271				.data = & (const struct audioformat) {
2272					.formats = SNDRV_PCM_FMTBIT_S24_3LE,
2273					.channels = 8,
2274					.iface = 2,
2275					.altsetting = 1,
2276					.altset_idx = 1,
2277					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2278					.endpoint = 0x81,
2279					.ep_attr = 0x05,
2280					.rates = SNDRV_PCM_RATE_44100 |
2281						 SNDRV_PCM_RATE_48000 |
2282						 SNDRV_PCM_RATE_88200 |
2283						 SNDRV_PCM_RATE_96000,
2284					.rate_min = 44100,
2285					.rate_max = 96000,
2286					.nr_rates = 4,
2287					.rate_table = (unsigned int[]) {
2288						44100, 48000, 88200, 96000
2289					}
2290				}
2291			},
2292			/* interface 3 (MIDI) is standard compliant */
2293			{
2294				.ifnum = -1
2295			}
2296		}
2297	}
2298},
2299
2300/* Casio devices */
2301{
2302	USB_DEVICE(0x07cf, 0x6801),
2303	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2304		.vendor_name = "Casio",
2305		.product_name = "PL-40R",
2306		.ifnum = 0,
2307		.type = QUIRK_MIDI_YAMAHA
2308	}
2309},
2310{
2311	/* this ID is used by several devices without a product ID */
2312	USB_DEVICE(0x07cf, 0x6802),
2313	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2314		.vendor_name = "Casio",
2315		.product_name = "Keyboard",
2316		.ifnum = 0,
2317		.type = QUIRK_MIDI_YAMAHA
2318	}
2319},
2320
2321/* Mark of the Unicorn devices */
2322{
2323	/* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2324	.match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2325		       USB_DEVICE_ID_MATCH_PRODUCT |
2326		       USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2327	.idVendor = 0x07fd,
2328	.idProduct = 0x0001,
2329	.bDeviceSubClass = 2,
2330	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2331		.vendor_name = "MOTU",
2332		.product_name = "Fastlane",
2333		.ifnum = QUIRK_ANY_INTERFACE,
2334		.type = QUIRK_COMPOSITE,
2335		.data = & (const struct snd_usb_audio_quirk[]) {
2336			{
2337				.ifnum = 0,
2338				.type = QUIRK_MIDI_RAW_BYTES
2339			},
2340			{
2341				.ifnum = 1,
2342				.type = QUIRK_IGNORE_INTERFACE
2343			},
2344			{
2345				.ifnum = -1
2346			}
2347		}
2348	}
2349},
2350
2351/* Emagic devices */
2352{
2353	USB_DEVICE(0x086a, 0x0001),
2354	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2355		.vendor_name = "Emagic",
2356		/* .product_name = "Unitor8", */
2357		.ifnum = 2,
2358		.type = QUIRK_MIDI_EMAGIC,
2359		.data = & (const struct snd_usb_midi_endpoint_info) {
2360			.out_cables = 0x80ff,
2361			.in_cables  = 0x80ff
2362		}
2363	}
2364},
2365{
2366	USB_DEVICE(0x086a, 0x0002),
2367	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2368		.vendor_name = "Emagic",
2369		/* .product_name = "AMT8", */
2370		.ifnum = 2,
2371		.type = QUIRK_MIDI_EMAGIC,
2372		.data = & (const struct snd_usb_midi_endpoint_info) {
2373			.out_cables = 0x80ff,
2374			.in_cables  = 0x80ff
2375		}
2376	}
2377},
2378{
2379	USB_DEVICE(0x086a, 0x0003),
2380	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2381		.vendor_name = "Emagic",
2382		/* .product_name = "MT4", */
2383		.ifnum = 2,
2384		.type = QUIRK_MIDI_EMAGIC,
2385		.data = & (const struct snd_usb_midi_endpoint_info) {
2386			.out_cables = 0x800f,
2387			.in_cables  = 0x8003
2388		}
2389	}
2390},
2391
2392/* KORG devices */
2393{
2394	USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2395	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2396		.vendor_name = "KORG, Inc.",
2397		/* .product_name = "PANDORA PX5D", */
2398		.ifnum = 3,
2399		.type = QUIRK_MIDI_STANDARD_INTERFACE,
2400	}
2401},
2402
2403{
2404	USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2405	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2406		.vendor_name = "KORG, Inc.",
2407		/* .product_name = "ToneLab ST", */
2408		.ifnum = 3,
2409		.type = QUIRK_MIDI_STANDARD_INTERFACE,
2410	}
2411},
2412
2413/* AKAI devices */
2414{
2415	USB_DEVICE(0x09e8, 0x0062),
2416	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2417		.vendor_name = "AKAI",
2418		.product_name = "MPD16",
2419		.ifnum = 0,
2420		.type = QUIRK_MIDI_AKAI,
2421	}
2422},
2423
2424/* TerraTec devices */
2425{
2426	USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2427	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2428		.vendor_name = "TerraTec",
2429		.product_name = "PHASE 26",
2430		.ifnum = 3,
2431		.type = QUIRK_MIDI_STANDARD_INTERFACE
2432	}
2433},
2434{
2435	USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2436	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2437		.vendor_name = "TerraTec",
2438		.product_name = "PHASE 26",
2439		.ifnum = 3,
2440		.type = QUIRK_MIDI_STANDARD_INTERFACE
2441	}
2442},
2443{
2444	USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2445	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2446		.vendor_name = "TerraTec",
2447		.product_name = "PHASE 26",
2448		.ifnum = 3,
2449		.type = QUIRK_MIDI_STANDARD_INTERFACE
2450	}
2451},
2452{
2453	USB_DEVICE(0x0ccd, 0x0028),
2454	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2455		.vendor_name = "TerraTec",
2456		.product_name = "Aureon5.1MkII",
2457		.ifnum = QUIRK_NO_INTERFACE
2458	}
2459},
2460{
2461	USB_DEVICE(0x0ccd, 0x0035),
2462	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2463		.vendor_name = "Miditech",
2464		.product_name = "Play'n Roll",
2465		.ifnum = 0,
2466		.type = QUIRK_MIDI_CME
2467	}
2468},
2469
2470/* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2471{
2472	USB_DEVICE(0x103d, 0x0100),
2473		.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2474		.vendor_name = "Stanton",
2475		.product_name = "ScratchAmp",
2476		.ifnum = QUIRK_NO_INTERFACE
2477	}
2478},
2479{
2480	USB_DEVICE(0x103d, 0x0101),
2481		.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2482		.vendor_name = "Stanton",
2483		.product_name = "ScratchAmp",
2484		.ifnum = QUIRK_NO_INTERFACE
2485	}
2486},
2487
2488/* Novation EMS devices */
2489{
2490	USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2491	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2492		.vendor_name = "Novation",
2493		.product_name = "ReMOTE Audio/XStation",
2494		.ifnum = 4,
2495		.type = QUIRK_MIDI_NOVATION
2496	}
2497},
2498{
2499	USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2500	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2501		.vendor_name = "Novation",
2502		.product_name = "Speedio",
2503		.ifnum = 3,
2504		.type = QUIRK_MIDI_NOVATION
2505	}
2506},
2507{
2508	USB_DEVICE(0x1235, 0x000e),
2509	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2510		/* .vendor_name = "Novation", */
2511		/* .product_name = "Launchpad", */
2512		.ifnum = 0,
2513		.type = QUIRK_MIDI_RAW_BYTES
2514	}
2515},
2516{
2517	USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2518	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2519		.vendor_name = "Novation",
2520		.product_name = "ReMOTE25",
2521		.ifnum = 0,
2522		.type = QUIRK_MIDI_NOVATION
2523	}
2524},
2525
2526/* Access Music devices */
2527{
2528	/* VirusTI Desktop */
2529	USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2530	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2531		.ifnum = QUIRK_ANY_INTERFACE,
2532		.type = QUIRK_COMPOSITE,
2533		.data = &(const struct snd_usb_audio_quirk[]) {
2534			{
2535				.ifnum = 3,
2536				.type = QUIRK_MIDI_FIXED_ENDPOINT,
2537				.data = &(const struct snd_usb_midi_endpoint_info) {
2538					.out_cables = 0x0003,
2539					.in_cables  = 0x0003
2540				}
2541			},
2542			{
2543				.ifnum = 4,
2544				.type = QUIRK_IGNORE_INTERFACE
2545			},
2546			{
2547				.ifnum = -1
2548			}
2549		}
2550	}
2551},
2552
2553/* */
2554{
2555	/* aka. Serato Scratch Live DJ Box */
2556	USB_DEVICE(0x13e5, 0x0001),
2557	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2558		.vendor_name = "Rane",
2559		.product_name = "SL-1",
2560		.ifnum = QUIRK_NO_INTERFACE
2561	}
2562},
2563
2564/* Native Instruments MK2 series */
2565{
2566	/* Komplete Audio 6 */
2567	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2568	.idVendor = 0x17cc,
2569	.idProduct = 0x1000,
2570},
2571{
2572	/* Traktor Audio 6 */
2573	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2574	.idVendor = 0x17cc,
2575	.idProduct = 0x1010,
2576},
2577{
2578	/* Traktor Audio 10 */
2579	.match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2580	.idVendor = 0x17cc,
2581	.idProduct = 0x1020,
2582},
2583
2584/* KeithMcMillen Stringport */
2585{
2586	USB_DEVICE(0x1f38, 0x0001),
2587	.bInterfaceClass = USB_CLASS_AUDIO,
2588},
2589
2590/* Miditech devices */
2591{
2592	USB_DEVICE(0x4752, 0x0011),
2593	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2594		.vendor_name = "Miditech",
2595		.product_name = "Midistart-2",
2596		.ifnum = 0,
2597		.type = QUIRK_MIDI_CME
2598	}
2599},
2600
2601/* Central Music devices */
2602{
2603	/* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2604	USB_DEVICE(0x7104, 0x2202),
2605	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2606		.ifnum = 0,
2607		.type = QUIRK_MIDI_CME
2608	}
2609},
2610
2611/* Hauppauge HVR-950Q and HVR-850 */
2612{
2613	USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
2614	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2615		       USB_DEVICE_ID_MATCH_INT_CLASS |
2616		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2617	.bInterfaceClass = USB_CLASS_AUDIO,
2618	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2619	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2620		.vendor_name = "Hauppauge",
2621		.product_name = "HVR-950Q",
2622		.ifnum = QUIRK_ANY_INTERFACE,
2623		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2624	}
2625},
2626{
2627	USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240),
2628	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2629		       USB_DEVICE_ID_MATCH_INT_CLASS |
2630		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2631	.bInterfaceClass = USB_CLASS_AUDIO,
2632	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2633	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2634		.vendor_name = "Hauppauge",
2635		.product_name = "HVR-850",
2636		.ifnum = QUIRK_ANY_INTERFACE,
2637		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2638	}
2639},
2640{
2641	USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210),
2642	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2643		       USB_DEVICE_ID_MATCH_INT_CLASS |
2644		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2645	.bInterfaceClass = USB_CLASS_AUDIO,
2646	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2647	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2648		.vendor_name = "Hauppauge",
2649		.product_name = "HVR-950Q",
2650		.ifnum = QUIRK_ANY_INTERFACE,
2651		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2652	}
2653},
2654{
2655	USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217),
2656	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2657		       USB_DEVICE_ID_MATCH_INT_CLASS |
2658		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2659	.bInterfaceClass = USB_CLASS_AUDIO,
2660	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2661	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2662		.vendor_name = "Hauppauge",
2663		.product_name = "HVR-950Q",
2664		.ifnum = QUIRK_ANY_INTERFACE,
2665		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2666	}
2667},
2668{
2669	USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b),
2670	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2671		       USB_DEVICE_ID_MATCH_INT_CLASS |
2672		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2673	.bInterfaceClass = USB_CLASS_AUDIO,
2674	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2675	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2676		.vendor_name = "Hauppauge",
2677		.product_name = "HVR-950Q",
2678		.ifnum = QUIRK_ANY_INTERFACE,
2679		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2680	}
2681},
2682{
2683	USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e),
2684	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2685		       USB_DEVICE_ID_MATCH_INT_CLASS |
2686		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2687	.bInterfaceClass = USB_CLASS_AUDIO,
2688	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2689	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2690		.vendor_name = "Hauppauge",
2691		.product_name = "HVR-950Q",
2692		.ifnum = QUIRK_ANY_INTERFACE,
2693		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2694	}
2695},
2696{
2697	USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f),
2698	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2699		       USB_DEVICE_ID_MATCH_INT_CLASS |
2700		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2701	.bInterfaceClass = USB_CLASS_AUDIO,
2702	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2703	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2704		.vendor_name = "Hauppauge",
2705		.product_name = "HVR-950Q",
2706		.ifnum = QUIRK_ANY_INTERFACE,
2707		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2708	}
2709},
2710{
2711	USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280),
2712	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2713		       USB_DEVICE_ID_MATCH_INT_CLASS |
2714		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2715	.bInterfaceClass = USB_CLASS_AUDIO,
2716	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2717	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2718		.vendor_name = "Hauppauge",
2719		.product_name = "HVR-950Q",
2720		.ifnum = QUIRK_ANY_INTERFACE,
2721		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2722	}
2723},
2724{
2725	USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008),
2726	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2727		       USB_DEVICE_ID_MATCH_INT_CLASS |
2728		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2729	.bInterfaceClass = USB_CLASS_AUDIO,
2730	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2731	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2732		.vendor_name = "Hauppauge",
2733		.product_name = "HVR-950Q",
2734		.ifnum = QUIRK_ANY_INTERFACE,
2735		.type = QUIRK_AUDIO_ALIGN_TRANSFER,
2736	}
2737},
2738
2739/* Digidesign Mbox */
2740{
2741	/* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2742	USB_DEVICE(0x0dba, 0x1000),
2743	.driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2744		.vendor_name = "Digidesign",
2745		.product_name = "MBox",
2746		.ifnum = QUIRK_ANY_INTERFACE,
2747		.type = QUIRK_COMPOSITE,
2748		.data = (const struct snd_usb_audio_quirk[]){
2749			{
2750				.ifnum = 0,
2751				.type = QUIRK_IGNORE_INTERFACE,
2752			},
2753			{
2754				.ifnum = 1,
2755				.type = QUIRK_AUDIO_FIXED_ENDPOINT,
2756				.data = &(const struct audioformat) {
2757					.formats = SNDRV_PCM_FMTBIT_S24_3BE,
2758					.channels = 2,
2759					.iface = 1,
2760					.altsetting = 1,
2761					.altset_idx = 1,
2762					.attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2763					.endpoint = 0x02,
2764					.ep_attr = 0x01,
2765					.maxpacksize = 0x130,
2766					.rates = SNDRV_PCM_RATE_44100 |
2767						 SNDRV_PCM_RATE_48000,
2768					.rate_min = 44100,
2769					.rate_max = 48000,
2770					.nr_rates = 2,
2771					.rate_table = (unsigned int[]) {
2772						44100, 48000
2773					}
2774				}
2775			},
2776			{
2777				.ifnum = -1
2778			}
2779		}
2780
2781	}
2782},
2783
2784{
2785	/*
2786	 * Some USB MIDI devices don't have an audio control interface,
2787	 * so we have to grab MIDI streaming interfaces here.
2788	 */
2789	.match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
2790		       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2791	.bInterfaceClass = USB_CLASS_AUDIO,
2792	.bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
2793	.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2794		.ifnum = QUIRK_ANY_INTERFACE,
2795		.type = QUIRK_MIDI_STANDARD_INTERFACE
2796	}
2797},
2798
2799#undef USB_DEVICE_VENDOR_SPEC