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