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