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