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