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