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