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