locking: Rename __RAW_SPIN_LOCK_UNLOCKED to __ARCH_SPIN_LOCK_UNLOCKED
[linux-2.6.git] / sound / usb / usbquirks.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 /* Creative/Toshiba Multimedia Center SB-0500 */
43 {
44         USB_DEVICE(0x041e, 0x3048),
45         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
46                 .vendor_name = "Toshiba",
47                 .product_name = "SB-0500",
48                 .ifnum = QUIRK_NO_INTERFACE
49         }
50 },
51
52 /* Creative/E-Mu devices */
53 {
54         USB_DEVICE(0x041e, 0x3010),
55         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
56                 .vendor_name = "Creative Labs",
57                 .product_name = "Sound Blaster MP3+",
58                 .ifnum = QUIRK_NO_INTERFACE
59         }
60 },
61 {
62         /* E-Mu 0202 USB */
63         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
64         .idVendor = 0x041e,
65         .idProduct = 0x3f02,
66         .bInterfaceClass = USB_CLASS_AUDIO,
67 },
68 {
69         /* E-Mu 0404 USB */
70         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
71         .idVendor = 0x041e,
72         .idProduct = 0x3f04,
73         .bInterfaceClass = USB_CLASS_AUDIO,
74 },
75 {
76         /* E-Mu Tracker Pre */
77         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
78         .idVendor = 0x041e,
79         .idProduct = 0x3f0a,
80         .bInterfaceClass = USB_CLASS_AUDIO,
81 },
82
83 /*
84  * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
85  * class matches do not take effect without an explicit ID match.
86  */
87 {
88         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
89                        USB_DEVICE_ID_MATCH_INT_CLASS |
90                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
91         .idVendor = 0x046d,
92         .idProduct = 0x0850,
93         .bInterfaceClass = USB_CLASS_AUDIO,
94         .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
95 },
96 {
97         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
98                        USB_DEVICE_ID_MATCH_INT_CLASS |
99                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
100         .idVendor = 0x046d,
101         .idProduct = 0x08ae,
102         .bInterfaceClass = USB_CLASS_AUDIO,
103         .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
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 = 0x08c6,
111         .bInterfaceClass = USB_CLASS_AUDIO,
112         .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
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 = 0x08f0,
120         .bInterfaceClass = USB_CLASS_AUDIO,
121         .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
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 = 0x08f5,
129         .bInterfaceClass = USB_CLASS_AUDIO,
130         .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
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 = 0x08f6,
138         .bInterfaceClass = USB_CLASS_AUDIO,
139         .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
140 },
141 {
142         USB_DEVICE(0x046d, 0x0990),
143         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
144                 .vendor_name = "Logitech, Inc.",
145                 .product_name = "QuickCam Pro 9000",
146                 .ifnum = QUIRK_NO_INTERFACE
147         }
148 },
149
150 /*
151  * Yamaha devices
152  */
153
154 #define YAMAHA_DEVICE(id, name) { \
155         USB_DEVICE(0x0499, id), \
156         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
157                 .vendor_name = "Yamaha", \
158                 .product_name = name, \
159                 .ifnum = QUIRK_ANY_INTERFACE, \
160                 .type = QUIRK_MIDI_YAMAHA \
161         } \
162 }
163 #define YAMAHA_INTERFACE(id, intf, name) { \
164         USB_DEVICE_VENDOR_SPEC(0x0499, id), \
165         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
166                 .vendor_name = "Yamaha", \
167                 .product_name = name, \
168                 .ifnum = intf, \
169                 .type = QUIRK_MIDI_YAMAHA \
170         } \
171 }
172 YAMAHA_DEVICE(0x1000, "UX256"),
173 YAMAHA_DEVICE(0x1001, "MU1000"),
174 YAMAHA_DEVICE(0x1002, "MU2000"),
175 YAMAHA_DEVICE(0x1003, "MU500"),
176 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
177 YAMAHA_DEVICE(0x1005, "MOTIF6"),
178 YAMAHA_DEVICE(0x1006, "MOTIF7"),
179 YAMAHA_DEVICE(0x1007, "MOTIF8"),
180 YAMAHA_DEVICE(0x1008, "UX96"),
181 YAMAHA_DEVICE(0x1009, "UX16"),
182 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
183 YAMAHA_DEVICE(0x100c, "UC-MX"),
184 YAMAHA_DEVICE(0x100d, "UC-KX"),
185 YAMAHA_DEVICE(0x100e, "S08"),
186 YAMAHA_DEVICE(0x100f, "CLP-150"),
187 YAMAHA_DEVICE(0x1010, "CLP-170"),
188 YAMAHA_DEVICE(0x1011, "P-250"),
189 YAMAHA_DEVICE(0x1012, "TYROS"),
190 YAMAHA_DEVICE(0x1013, "PF-500"),
191 YAMAHA_DEVICE(0x1014, "S90"),
192 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
193 YAMAHA_DEVICE(0x1016, "MDP-5"),
194 YAMAHA_DEVICE(0x1017, "CVP-204"),
195 YAMAHA_DEVICE(0x1018, "CVP-206"),
196 YAMAHA_DEVICE(0x1019, "CVP-208"),
197 YAMAHA_DEVICE(0x101a, "CVP-210"),
198 YAMAHA_DEVICE(0x101b, "PSR-1100"),
199 YAMAHA_DEVICE(0x101c, "PSR-2100"),
200 YAMAHA_DEVICE(0x101d, "CLP-175"),
201 YAMAHA_DEVICE(0x101e, "PSR-K1"),
202 YAMAHA_DEVICE(0x101f, "EZ-J24"),
203 YAMAHA_DEVICE(0x1020, "EZ-250i"),
204 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
205 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
206 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
207 YAMAHA_DEVICE(0x1024, "CVP-301"),
208 YAMAHA_DEVICE(0x1025, "CVP-303"),
209 YAMAHA_DEVICE(0x1026, "CVP-305"),
210 YAMAHA_DEVICE(0x1027, "CVP-307"),
211 YAMAHA_DEVICE(0x1028, "CVP-309"),
212 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
213 YAMAHA_DEVICE(0x102a, "PSR-1500"),
214 YAMAHA_DEVICE(0x102b, "PSR-3000"),
215 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
216 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
217 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
218 YAMAHA_DEVICE(0x1032, "DGX-305"),
219 YAMAHA_DEVICE(0x1033, "DGX-505"),
220 YAMAHA_DEVICE(0x1034, NULL),
221 YAMAHA_DEVICE(0x1035, NULL),
222 YAMAHA_DEVICE(0x1036, NULL),
223 YAMAHA_DEVICE(0x1037, NULL),
224 YAMAHA_DEVICE(0x1038, NULL),
225 YAMAHA_DEVICE(0x1039, NULL),
226 YAMAHA_DEVICE(0x103a, NULL),
227 YAMAHA_DEVICE(0x103b, NULL),
228 YAMAHA_DEVICE(0x103c, NULL),
229 YAMAHA_DEVICE(0x103d, NULL),
230 YAMAHA_DEVICE(0x103e, NULL),
231 YAMAHA_DEVICE(0x103f, NULL),
232 YAMAHA_DEVICE(0x1040, NULL),
233 YAMAHA_DEVICE(0x1041, NULL),
234 YAMAHA_DEVICE(0x1042, NULL),
235 YAMAHA_DEVICE(0x1043, NULL),
236 YAMAHA_DEVICE(0x1044, NULL),
237 YAMAHA_DEVICE(0x1045, NULL),
238 YAMAHA_INTERFACE(0x104e, 0, NULL),
239 YAMAHA_DEVICE(0x104f, NULL),
240 YAMAHA_DEVICE(0x1050, NULL),
241 YAMAHA_DEVICE(0x1051, NULL),
242 YAMAHA_DEVICE(0x1052, NULL),
243 YAMAHA_DEVICE(0x2000, "DGP-7"),
244 YAMAHA_DEVICE(0x2001, "DGP-5"),
245 YAMAHA_DEVICE(0x2002, NULL),
246 YAMAHA_DEVICE(0x5000, "CS1D"),
247 YAMAHA_DEVICE(0x5001, "DSP1D"),
248 YAMAHA_DEVICE(0x5002, "DME32"),
249 YAMAHA_DEVICE(0x5003, "DM2000"),
250 YAMAHA_DEVICE(0x5004, "02R96"),
251 YAMAHA_DEVICE(0x5005, "ACU16-C"),
252 YAMAHA_DEVICE(0x5006, "NHB32-C"),
253 YAMAHA_DEVICE(0x5007, "DM1000"),
254 YAMAHA_DEVICE(0x5008, "01V96"),
255 YAMAHA_DEVICE(0x5009, "SPX2000"),
256 YAMAHA_DEVICE(0x500a, "PM5D"),
257 YAMAHA_DEVICE(0x500b, "DME64N"),
258 YAMAHA_DEVICE(0x500c, "DME24N"),
259 YAMAHA_DEVICE(0x500d, NULL),
260 YAMAHA_DEVICE(0x500e, NULL),
261 YAMAHA_DEVICE(0x500f, NULL),
262 YAMAHA_DEVICE(0x7000, "DTX"),
263 YAMAHA_DEVICE(0x7010, "UB99"),
264 #undef YAMAHA_DEVICE
265 #undef YAMAHA_INTERFACE
266
267 /*
268  * Roland/RolandED/Edirol/BOSS devices
269  */
270 {
271         USB_DEVICE(0x0582, 0x0000),
272         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
273                 .vendor_name = "Roland",
274                 .product_name = "UA-100",
275                 .ifnum = QUIRK_ANY_INTERFACE,
276                 .type = QUIRK_COMPOSITE,
277                 .data = (const struct snd_usb_audio_quirk[]) {
278                         {
279                                 .ifnum = 0,
280                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
281                                 .data = & (const struct audioformat) {
282                                         .format = SNDRV_PCM_FORMAT_S16_LE,
283                                         .channels = 4,
284                                         .iface = 0,
285                                         .altsetting = 1,
286                                         .altset_idx = 1,
287                                         .attributes = 0,
288                                         .endpoint = 0x01,
289                                         .ep_attr = 0x09,
290                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
291                                         .rate_min = 44100,
292                                         .rate_max = 44100,
293                                 }
294                         },
295                         {
296                                 .ifnum = 1,
297                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
298                                 .data = & (const struct audioformat) {
299                                         .format = SNDRV_PCM_FORMAT_S16_LE,
300                                         .channels = 2,
301                                         .iface = 1,
302                                         .altsetting = 1,
303                                         .altset_idx = 1,
304                                         .attributes = EP_CS_ATTR_FILL_MAX,
305                                         .endpoint = 0x81,
306                                         .ep_attr = 0x05,
307                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
308                                         .rate_min = 44100,
309                                         .rate_max = 44100,
310                                 }
311                         },
312                         {
313                                 .ifnum = 2,
314                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
315                                 .data = & (const struct snd_usb_midi_endpoint_info) {
316                                         .out_cables = 0x0007,
317                                         .in_cables  = 0x0007
318                                 }
319                         },
320                         {
321                                 .ifnum = -1
322                         }
323                 }
324         }
325 },
326 {
327         USB_DEVICE(0x0582, 0x0002),
328         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
329                 .vendor_name = "EDIROL",
330                 .product_name = "UM-4",
331                 .ifnum = QUIRK_ANY_INTERFACE,
332                 .type = QUIRK_COMPOSITE,
333                 .data = (const struct snd_usb_audio_quirk[]) {
334                         {
335                                 .ifnum = 0,
336                                 .type = QUIRK_IGNORE_INTERFACE
337                         },
338                         {
339                                 .ifnum = 1,
340                                 .type = QUIRK_IGNORE_INTERFACE
341                         },
342                         {
343                                 .ifnum = 2,
344                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
345                                 .data = & (const struct snd_usb_midi_endpoint_info) {
346                                         .out_cables = 0x000f,
347                                         .in_cables  = 0x000f
348                                 }
349                         },
350                         {
351                                 .ifnum = -1
352                         }
353                 }
354         }
355 },
356 {
357         USB_DEVICE(0x0582, 0x0003),
358         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
359                 .vendor_name = "Roland",
360                 .product_name = "SC-8850",
361                 .ifnum = QUIRK_ANY_INTERFACE,
362                 .type = QUIRK_COMPOSITE,
363                 .data = (const struct snd_usb_audio_quirk[]) {
364                         {
365                                 .ifnum = 0,
366                                 .type = QUIRK_IGNORE_INTERFACE
367                         },
368                         {
369                                 .ifnum = 1,
370                                 .type = QUIRK_IGNORE_INTERFACE
371                         },
372                         {
373                                 .ifnum = 2,
374                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
375                                 .data = & (const struct snd_usb_midi_endpoint_info) {
376                                         .out_cables = 0x003f,
377                                         .in_cables  = 0x003f
378                                 }
379                         },
380                         {
381                                 .ifnum = -1
382                         }
383                 }
384         }
385 },
386 {
387         USB_DEVICE(0x0582, 0x0004),
388         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
389                 .vendor_name = "Roland",
390                 .product_name = "U-8",
391                 .ifnum = QUIRK_ANY_INTERFACE,
392                 .type = QUIRK_COMPOSITE,
393                 .data = (const struct snd_usb_audio_quirk[]) {
394                         {
395                                 .ifnum = 0,
396                                 .type = QUIRK_IGNORE_INTERFACE
397                         },
398                         {
399                                 .ifnum = 1,
400                                 .type = QUIRK_IGNORE_INTERFACE
401                         },
402                         {
403                                 .ifnum = 2,
404                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
405                                 .data = & (const struct snd_usb_midi_endpoint_info) {
406                                         .out_cables = 0x0005,
407                                         .in_cables  = 0x0005
408                                 }
409                         },
410                         {
411                                 .ifnum = -1
412                         }
413                 }
414         }
415 },
416 {
417         /* Has ID 0x0099 when not in "Advanced Driver" mode.
418          * The UM-2EX has only one input, but we cannot detect this. */
419         USB_DEVICE(0x0582, 0x0005),
420         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
421                 .vendor_name = "EDIROL",
422                 .product_name = "UM-2",
423                 .ifnum = QUIRK_ANY_INTERFACE,
424                 .type = QUIRK_COMPOSITE,
425                 .data = (const struct snd_usb_audio_quirk[]) {
426                         {
427                                 .ifnum = 0,
428                                 .type = QUIRK_IGNORE_INTERFACE
429                         },
430                         {
431                                 .ifnum = 1,
432                                 .type = QUIRK_IGNORE_INTERFACE
433                         },
434                         {
435                                 .ifnum = 2,
436                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
437                                 .data = & (const struct snd_usb_midi_endpoint_info) {
438                                         .out_cables = 0x0003,
439                                         .in_cables  = 0x0003
440                                 }
441                         },
442                         {
443                                 .ifnum = -1
444                         }
445                 }
446         }
447 },
448 {
449         USB_DEVICE(0x0582, 0x0007),
450         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
451                 .vendor_name = "Roland",
452                 .product_name = "SC-8820",
453                 .ifnum = QUIRK_ANY_INTERFACE,
454                 .type = QUIRK_COMPOSITE,
455                 .data = (const struct snd_usb_audio_quirk[]) {
456                         {
457                                 .ifnum = 0,
458                                 .type = QUIRK_IGNORE_INTERFACE
459                         },
460                         {
461                                 .ifnum = 1,
462                                 .type = QUIRK_IGNORE_INTERFACE
463                         },
464                         {
465                                 .ifnum = 2,
466                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
467                                 .data = & (const struct snd_usb_midi_endpoint_info) {
468                                         .out_cables = 0x0013,
469                                         .in_cables  = 0x0013
470                                 }
471                         },
472                         {
473                                 .ifnum = -1
474                         }
475                 }
476         }
477 },
478 {
479         USB_DEVICE(0x0582, 0x0008),
480         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
481                 .vendor_name = "Roland",
482                 .product_name = "PC-300",
483                 .ifnum = QUIRK_ANY_INTERFACE,
484                 .type = QUIRK_COMPOSITE,
485                 .data = (const struct snd_usb_audio_quirk[]) {
486                         {
487                                 .ifnum = 0,
488                                 .type = QUIRK_IGNORE_INTERFACE
489                         },
490                         {
491                                 .ifnum = 1,
492                                 .type = QUIRK_IGNORE_INTERFACE
493                         },
494                         {
495                                 .ifnum = 2,
496                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
497                                 .data = & (const struct snd_usb_midi_endpoint_info) {
498                                         .out_cables = 0x0001,
499                                         .in_cables  = 0x0001
500                                 }
501                         },
502                         {
503                                 .ifnum = -1
504                         }
505                 }
506         }
507 },
508 {
509         /* has ID 0x009d when not in "Advanced Driver" mode */
510         USB_DEVICE(0x0582, 0x0009),
511         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
512                 .vendor_name = "EDIROL",
513                 .product_name = "UM-1",
514                 .ifnum = QUIRK_ANY_INTERFACE,
515                 .type = QUIRK_COMPOSITE,
516                 .data = (const struct snd_usb_audio_quirk[]) {
517                         {
518                                 .ifnum = 0,
519                                 .type = QUIRK_IGNORE_INTERFACE
520                         },
521                         {
522                                 .ifnum = 1,
523                                 .type = QUIRK_IGNORE_INTERFACE
524                         },
525                         {
526                                 .ifnum = 2,
527                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
528                                 .data = & (const struct snd_usb_midi_endpoint_info) {
529                                         .out_cables = 0x0001,
530                                         .in_cables  = 0x0001
531                                 }
532                         },
533                         {
534                                 .ifnum = -1
535                         }
536                 }
537         }
538 },
539 {
540         USB_DEVICE(0x0582, 0x000b),
541         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
542                 .vendor_name = "Roland",
543                 .product_name = "SK-500",
544                 .ifnum = QUIRK_ANY_INTERFACE,
545                 .type = QUIRK_COMPOSITE,
546                 .data = (const struct snd_usb_audio_quirk[]) {
547                         {
548                                 .ifnum = 0,
549                                 .type = QUIRK_IGNORE_INTERFACE
550                         },
551                         {
552                                 .ifnum = 1,
553                                 .type = QUIRK_IGNORE_INTERFACE
554                         },
555                         {
556                                 .ifnum = 2,
557                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
558                                 .data = & (const struct snd_usb_midi_endpoint_info) {
559                                         .out_cables = 0x0013,
560                                         .in_cables  = 0x0013
561                                 }
562                         },
563                         {
564                                 .ifnum = -1
565                         }
566                 }
567         }
568 },
569 {
570         /* thanks to Emiliano Grilli <emillo@libero.it>
571          * for helping researching this data */
572         USB_DEVICE(0x0582, 0x000c),
573         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
574                 .vendor_name = "Roland",
575                 .product_name = "SC-D70",
576                 .ifnum = QUIRK_ANY_INTERFACE,
577                 .type = QUIRK_COMPOSITE,
578                 .data = (const struct snd_usb_audio_quirk[]) {
579                         {
580                                 .ifnum = 0,
581                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
582                                 .data = & (const struct audioformat) {
583                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
584                                         .channels = 2,
585                                         .iface = 0,
586                                         .altsetting = 1,
587                                         .altset_idx = 1,
588                                         .attributes = 0,
589                                         .endpoint = 0x01,
590                                         .ep_attr = 0x01,
591                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
592                                         .rate_min = 44100,
593                                         .rate_max = 44100,
594                                 }
595                         },
596                         {
597                                 .ifnum = 1,
598                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
599                                 .data = & (const struct audioformat) {
600                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
601                                         .channels = 2,
602                                         .iface = 1,
603                                         .altsetting = 1,
604                                         .altset_idx = 1,
605                                         .attributes = 0,
606                                         .endpoint = 0x81,
607                                         .ep_attr = 0x01,
608                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
609                                         .rate_min = 44100,
610                                         .rate_max = 44100,
611                                 }
612                         },
613                         {
614                                 .ifnum = 2,
615                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
616                                 .data = & (const struct snd_usb_midi_endpoint_info) {
617                                         .out_cables = 0x0007,
618                                         .in_cables  = 0x0007
619                                 }
620                         },
621                         {
622                                 .ifnum = -1
623                         }
624                 }
625         }
626 },
627 {       /*
628          * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
629          * If the advanced mode switch at the back of the unit is off, the
630          * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
631          * but offers only 16-bit PCM.
632          * In advanced mode, the UA-5 will output S24_3LE samples (two
633          * channels) at the rate indicated on the front switch, including
634          * the 96kHz sample rate.
635          */
636         USB_DEVICE(0x0582, 0x0010),
637         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
638                 .vendor_name = "EDIROL",
639                 .product_name = "UA-5",
640                 .ifnum = QUIRK_ANY_INTERFACE,
641                 .type = QUIRK_COMPOSITE,
642                 .data = (const struct snd_usb_audio_quirk[]) {
643                         {
644                                 .ifnum = 1,
645                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
646                         },
647                         {
648                                 .ifnum = 2,
649                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
650                         },
651                         {
652                                 .ifnum = -1
653                         }
654                 }
655         }
656 },
657 {
658         /* has ID 0x0013 when not in "Advanced Driver" mode */
659         USB_DEVICE(0x0582, 0x0012),
660         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
661                 .vendor_name = "Roland",
662                 .product_name = "XV-5050",
663                 .ifnum = 0,
664                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
665                 .data = & (const struct snd_usb_midi_endpoint_info) {
666                         .out_cables = 0x0001,
667                         .in_cables  = 0x0001
668                 }
669         }
670 },
671 {
672         /* has ID 0x0015 when not in "Advanced Driver" mode */
673         USB_DEVICE(0x0582, 0x0014),
674         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
675                 .vendor_name = "EDIROL",
676                 .product_name = "UM-880",
677                 .ifnum = 0,
678                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
679                 .data = & (const struct snd_usb_midi_endpoint_info) {
680                         .out_cables = 0x01ff,
681                         .in_cables  = 0x01ff
682                 }
683         }
684 },
685 {
686         /* has ID 0x0017 when not in "Advanced Driver" mode */
687         USB_DEVICE(0x0582, 0x0016),
688         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
689                 .vendor_name = "EDIROL",
690                 .product_name = "SD-90",
691                 .ifnum = QUIRK_ANY_INTERFACE,
692                 .type = QUIRK_COMPOSITE,
693                 .data = (const struct snd_usb_audio_quirk[]) {
694                         {
695                                 .ifnum = 0,
696                                 .type = QUIRK_IGNORE_INTERFACE
697                         },
698                         {
699                                 .ifnum = 1,
700                                 .type = QUIRK_IGNORE_INTERFACE
701                         },
702                         {
703                                 .ifnum = 2,
704                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
705                                 .data = & (const struct snd_usb_midi_endpoint_info) {
706                                         .out_cables = 0x000f,
707                                         .in_cables  = 0x000f
708                                 }
709                         },
710                         {
711                                 .ifnum = -1
712                         }
713                 }
714         }
715 },
716 {
717         /* has ID 0x001c when not in "Advanced Driver" mode */
718         USB_DEVICE(0x0582, 0x001b),
719         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
720                 .vendor_name = "Roland",
721                 .product_name = "MMP-2",
722                 .ifnum = QUIRK_ANY_INTERFACE,
723                 .type = QUIRK_COMPOSITE,
724                 .data = (const struct snd_usb_audio_quirk[]) {
725                         {
726                                 .ifnum = 0,
727                                 .type = QUIRK_IGNORE_INTERFACE
728                         },
729                         {
730                                 .ifnum = 1,
731                                 .type = QUIRK_IGNORE_INTERFACE
732                         },
733                         {
734                                 .ifnum = 2,
735                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
736                                 .data = & (const struct snd_usb_midi_endpoint_info) {
737                                         .out_cables = 0x0001,
738                                         .in_cables  = 0x0001
739                                 }
740                         },
741                         {
742                                 .ifnum = -1
743                         }
744                 }
745         }
746 },
747 {
748         /* has ID 0x001e when not in "Advanced Driver" mode */
749         USB_DEVICE(0x0582, 0x001d),
750         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
751                 .vendor_name = "Roland",
752                 .product_name = "V-SYNTH",
753                 .ifnum = 0,
754                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
755                 .data = & (const struct snd_usb_midi_endpoint_info) {
756                         .out_cables = 0x0001,
757                         .in_cables  = 0x0001
758                 }
759         }
760 },
761 {
762         /* has ID 0x0024 when not in "Advanced Driver" mode */
763         USB_DEVICE(0x0582, 0x0023),
764         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
765                 .vendor_name = "EDIROL",
766                 .product_name = "UM-550",
767                 .ifnum = 0,
768                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
769                 .data = & (const struct snd_usb_midi_endpoint_info) {
770                         .out_cables = 0x003f,
771                         .in_cables  = 0x003f
772                 }
773         }
774 },
775 {
776         /*
777          * This quirk is for the "Advanced Driver" mode. If off, the UA-20
778          * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
779          * and no MIDI.
780          */
781         USB_DEVICE(0x0582, 0x0025),
782         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
783                 .vendor_name = "EDIROL",
784                 .product_name = "UA-20",
785                 .ifnum = QUIRK_ANY_INTERFACE,
786                 .type = QUIRK_COMPOSITE,
787                 .data = (const struct snd_usb_audio_quirk[]) {
788                         {
789                                 .ifnum = 0,
790                                 .type = QUIRK_IGNORE_INTERFACE
791                         },
792                         {
793                                 .ifnum = 1,
794                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
795                                 .data = & (const struct audioformat) {
796                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
797                                         .channels = 2,
798                                         .iface = 1,
799                                         .altsetting = 1,
800                                         .altset_idx = 1,
801                                         .attributes = 0,
802                                         .endpoint = 0x01,
803                                         .ep_attr = 0x01,
804                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
805                                         .rate_min = 44100,
806                                         .rate_max = 44100,
807                                 }
808                         },
809                         {
810                                 .ifnum = 2,
811                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
812                                 .data = & (const struct audioformat) {
813                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
814                                         .channels = 2,
815                                         .iface = 2,
816                                         .altsetting = 1,
817                                         .altset_idx = 1,
818                                         .attributes = 0,
819                                         .endpoint = 0x82,
820                                         .ep_attr = 0x01,
821                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
822                                         .rate_min = 44100,
823                                         .rate_max = 44100,
824                                 }
825                         },
826                         {
827                                 .ifnum = 3,
828                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
829                                 .data = & (const struct snd_usb_midi_endpoint_info) {
830                                         .out_cables = 0x0001,
831                                         .in_cables  = 0x0001
832                                 }
833                         },
834                         {
835                                 .ifnum = -1
836                         }
837                 }
838         }
839 },
840 {
841         /* has ID 0x0028 when not in "Advanced Driver" mode */
842         USB_DEVICE(0x0582, 0x0027),
843         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
844                 .vendor_name = "EDIROL",
845                 .product_name = "SD-20",
846                 .ifnum = 0,
847                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
848                 .data = & (const struct snd_usb_midi_endpoint_info) {
849                         .out_cables = 0x0003,
850                         .in_cables  = 0x0007
851                 }
852         }
853 },
854 {
855         /* has ID 0x002a when not in "Advanced Driver" mode */
856         USB_DEVICE(0x0582, 0x0029),
857         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
858                 .vendor_name = "EDIROL",
859                 .product_name = "SD-80",
860                 .ifnum = 0,
861                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
862                 .data = & (const struct snd_usb_midi_endpoint_info) {
863                         .out_cables = 0x000f,
864                         .in_cables  = 0x000f
865                 }
866         }
867 },
868 {       /*
869          * This quirk is for the "Advanced" modes of the Edirol UA-700.
870          * If the sample format switch is not in an advanced setting, the
871          * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
872          * but offers only 16-bit PCM and no MIDI.
873          */
874         USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
875         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
876                 .vendor_name = "EDIROL",
877                 .product_name = "UA-700",
878                 .ifnum = QUIRK_ANY_INTERFACE,
879                 .type = QUIRK_COMPOSITE,
880                 .data = (const struct snd_usb_audio_quirk[]) {
881                         {
882                                 .ifnum = 1,
883                                 .type = QUIRK_AUDIO_EDIROL_UAXX
884                         },
885                         {
886                                 .ifnum = 2,
887                                 .type = QUIRK_AUDIO_EDIROL_UAXX
888                         },
889                         {
890                                 .ifnum = 3,
891                                 .type = QUIRK_AUDIO_EDIROL_UAXX
892                         },
893                         {
894                                 .ifnum = -1
895                         }
896                 }
897         }
898 },
899 {
900         /* has ID 0x002e when not in "Advanced Driver" mode */
901         USB_DEVICE(0x0582, 0x002d),
902         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
903                 .vendor_name = "Roland",
904                 .product_name = "XV-2020",
905                 .ifnum = 0,
906                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
907                 .data = & (const struct snd_usb_midi_endpoint_info) {
908                         .out_cables = 0x0001,
909                         .in_cables  = 0x0001
910                 }
911         }
912 },
913 {
914         /* has ID 0x0030 when not in "Advanced Driver" mode */
915         USB_DEVICE(0x0582, 0x002f),
916         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
917                 .vendor_name = "Roland",
918                 .product_name = "VariOS",
919                 .ifnum = 0,
920                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
921                 .data = & (const struct snd_usb_midi_endpoint_info) {
922                         .out_cables = 0x0007,
923                         .in_cables  = 0x0007
924                 }
925         }
926 },
927 {
928         /* has ID 0x0034 when not in "Advanced Driver" mode */
929         USB_DEVICE(0x0582, 0x0033),
930         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
931                 .vendor_name = "EDIROL",
932                 .product_name = "PCR",
933                 .ifnum = 0,
934                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
935                 .data = & (const struct snd_usb_midi_endpoint_info) {
936                         .out_cables = 0x0003,
937                         .in_cables  = 0x0007
938                 }
939         }
940 },
941         /* TODO: add Roland M-1000 support */
942 {
943         /*
944          * Has ID 0x0038 when not in "Advanced Driver" mode;
945          * later revisions use IDs 0x0054 and 0x00a2.
946          */
947         USB_DEVICE(0x0582, 0x0037),
948         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
949                 .vendor_name = "Roland",
950                 .product_name = "Digital Piano",
951                 .ifnum = 0,
952                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
953                 .data = & (const struct snd_usb_midi_endpoint_info) {
954                         .out_cables = 0x0001,
955                         .in_cables  = 0x0001
956                 }
957         }
958 },
959 {
960         /*
961          * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
962          * has ID 0x003c and is standard compliant, but has only 16-bit PCM
963          * and no MIDI.
964          */
965         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
966         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
967                 .vendor_name = "BOSS",
968                 .product_name = "GS-10",
969                 .ifnum = QUIRK_ANY_INTERFACE,
970                 .type = QUIRK_COMPOSITE,
971                 .data = & (const struct snd_usb_audio_quirk[]) {
972                         {
973                                 .ifnum = 1,
974                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
975                         },
976                         {
977                                 .ifnum = 2,
978                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
979                         },
980                         {
981                                 .ifnum = 3,
982                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
983                         },
984                         {
985                                 .ifnum = -1
986                         }
987                 }
988         }
989 },
990 {
991         /* has ID 0x0041 when not in "Advanced Driver" mode */
992         USB_DEVICE(0x0582, 0x0040),
993         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
994                 .vendor_name = "Roland",
995                 .product_name = "GI-20",
996                 .ifnum = 0,
997                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
998                 .data = & (const struct snd_usb_midi_endpoint_info) {
999                         .out_cables = 0x0001,
1000                         .in_cables  = 0x0001
1001                 }
1002         }
1003 },
1004 {
1005         /* has ID 0x0043 when not in "Advanced Driver" mode */
1006         USB_DEVICE(0x0582, 0x0042),
1007         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1008                 .vendor_name = "Roland",
1009                 .product_name = "RS-70",
1010                 .ifnum = 0,
1011                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1012                 .data = & (const struct snd_usb_midi_endpoint_info) {
1013                         .out_cables = 0x0001,
1014                         .in_cables  = 0x0001
1015                 }
1016         }
1017 },
1018 {
1019         USB_DEVICE(0x0582, 0x0044),
1020         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1021                 .vendor_name = "Roland",
1022                 .product_name = "UA-1000",
1023                 .ifnum = QUIRK_ANY_INTERFACE,
1024                 .type = QUIRK_COMPOSITE,
1025                 .data = (const struct snd_usb_audio_quirk[]) {
1026                         {
1027                                 .ifnum = 1,
1028                                 .type = QUIRK_AUDIO_EDIROL_UA1000
1029                         },
1030                         {
1031                                 .ifnum = 2,
1032                                 .type = QUIRK_AUDIO_EDIROL_UA1000
1033                         },
1034                         {
1035                                 .ifnum = 3,
1036                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1037                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1038                                         .out_cables = 0x0003,
1039                                         .in_cables  = 0x0003
1040                                 }
1041                         },
1042                         {
1043                                 .ifnum = -1
1044                         }
1045                 }
1046         }
1047 },
1048 {
1049         /* has ID 0x0049 when not in "Advanced Driver" mode */
1050         USB_DEVICE(0x0582, 0x0047),
1051         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1052                 /* .vendor_name = "EDIROL", */
1053                 /* .product_name = "UR-80", */
1054                 .ifnum = QUIRK_ANY_INTERFACE,
1055                 .type = QUIRK_COMPOSITE,
1056                 .data = (const struct snd_usb_audio_quirk[]) {
1057                         /* in the 96 kHz modes, only interface 1 is there */
1058                         {
1059                                 .ifnum = 1,
1060                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1061                         },
1062                         {
1063                                 .ifnum = 2,
1064                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1065                         },
1066                         {
1067                                 .ifnum = -1
1068                         }
1069                 }
1070         }
1071 },
1072 {
1073         /* has ID 0x004a when not in "Advanced Driver" mode */
1074         USB_DEVICE(0x0582, 0x0048),
1075         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1076                 /* .vendor_name = "EDIROL", */
1077                 /* .product_name = "UR-80", */
1078                 .ifnum = 0,
1079                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1080                 .data = & (const struct snd_usb_midi_endpoint_info) {
1081                         .out_cables = 0x0003,
1082                         .in_cables  = 0x0007
1083                 }
1084         }
1085 },
1086         /* TODO: add Edirol M-100FX support */
1087 {
1088         /* has ID 0x004e when not in "Advanced Driver" mode */
1089         USB_DEVICE(0x0582, 0x004c),
1090         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1091                 .vendor_name = "EDIROL",
1092                 .product_name = "PCR-A",
1093                 .ifnum = QUIRK_ANY_INTERFACE,
1094                 .type = QUIRK_COMPOSITE,
1095                 .data = (const struct snd_usb_audio_quirk[]) {
1096                         {
1097                                 .ifnum = 1,
1098                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1099                         },
1100                         {
1101                                 .ifnum = 2,
1102                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1103                         },
1104                         {
1105                                 .ifnum = -1
1106                         }
1107                 }
1108         }
1109 },
1110 {
1111         /* has ID 0x004f when not in "Advanced Driver" mode */
1112         USB_DEVICE(0x0582, 0x004d),
1113         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1114                 .vendor_name = "EDIROL",
1115                 .product_name = "PCR-A",
1116                 .ifnum = 0,
1117                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1118                 .data = & (const struct snd_usb_midi_endpoint_info) {
1119                         .out_cables = 0x0003,
1120                         .in_cables  = 0x0007
1121                 }
1122         }
1123 },
1124 {
1125         /*
1126          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1127          * is standard compliant, but has only 16-bit PCM.
1128          */
1129         USB_DEVICE(0x0582, 0x0050),
1130         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1131                 .vendor_name = "EDIROL",
1132                 .product_name = "UA-3FX",
1133                 .ifnum = QUIRK_ANY_INTERFACE,
1134                 .type = QUIRK_COMPOSITE,
1135                 .data = (const struct snd_usb_audio_quirk[]) {
1136                         {
1137                                 .ifnum = 1,
1138                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1139                         },
1140                         {
1141                                 .ifnum = 2,
1142                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1143                         },
1144                         {
1145                                 .ifnum = -1
1146                         }
1147                 }
1148         }
1149 },
1150 {
1151         USB_DEVICE(0x0582, 0x0052),
1152         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1153                 .vendor_name = "EDIROL",
1154                 .product_name = "UM-1SX",
1155                 .ifnum = 0,
1156                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1157         }
1158 },
1159 {
1160         USB_DEVICE(0x0582, 0x0060),
1161         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1162                 .vendor_name = "Roland",
1163                 .product_name = "EXR Series",
1164                 .ifnum = 0,
1165                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1166         }
1167 },
1168 {
1169         /* has ID 0x0067 when not in "Advanced Driver" mode */
1170         USB_DEVICE(0x0582, 0x0065),
1171         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1172                 .vendor_name = "EDIROL",
1173                 .product_name = "PCR-1",
1174                 .ifnum = 0,
1175                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1176                 .data = & (const struct snd_usb_midi_endpoint_info) {
1177                         .out_cables = 0x0001,
1178                         .in_cables  = 0x0003
1179                 }
1180         }
1181 },
1182 {
1183         /* has ID 0x006b when not in "Advanced Driver" mode */
1184         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1185         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1186                 .vendor_name = "Roland",
1187                 .product_name = "SP-606",
1188                 .ifnum = 3,
1189                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1190                 .data = & (const struct snd_usb_midi_endpoint_info) {
1191                         .out_cables = 0x0001,
1192                         .in_cables  = 0x0001
1193                 }
1194         }
1195 },
1196 {
1197         /* has ID 0x006e when not in "Advanced Driver" mode */
1198         USB_DEVICE(0x0582, 0x006d),
1199         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1200                 .vendor_name = "Roland",
1201                 .product_name = "FANTOM-X",
1202                 .ifnum = 0,
1203                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1204                 .data = & (const struct snd_usb_midi_endpoint_info) {
1205                         .out_cables = 0x0001,
1206                         .in_cables  = 0x0001
1207                 }
1208         }
1209 },
1210 {       /*
1211          * This quirk is for the "Advanced" modes of the Edirol UA-25.
1212          * If the switch is not in an advanced setting, the UA-25 has
1213          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1214          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1215          */
1216         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1217         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1218                 .vendor_name = "EDIROL",
1219                 .product_name = "UA-25",
1220                 .ifnum = QUIRK_ANY_INTERFACE,
1221                 .type = QUIRK_COMPOSITE,
1222                 .data = (const struct snd_usb_audio_quirk[]) {
1223                         {
1224                                 .ifnum = 0,
1225                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1226                         },
1227                         {
1228                                 .ifnum = 1,
1229                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1230                         },
1231                         {
1232                                 .ifnum = 2,
1233                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1234                         },
1235                         {
1236                                 .ifnum = -1
1237                         }
1238                 }
1239         }
1240 },
1241 {
1242         /* has ID 0x0076 when not in "Advanced Driver" mode */
1243         USB_DEVICE(0x0582, 0x0075),
1244         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1245                 .vendor_name = "BOSS",
1246                 .product_name = "DR-880",
1247                 .ifnum = 0,
1248                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1249                 .data = & (const struct snd_usb_midi_endpoint_info) {
1250                         .out_cables = 0x0001,
1251                         .in_cables  = 0x0001
1252                 }
1253         }
1254 },
1255 {
1256         /* has ID 0x007b when not in "Advanced Driver" mode */
1257         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1258         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1259                 .vendor_name = "Roland",
1260                 /* "RD" or "RD-700SX"? */
1261                 .ifnum = 0,
1262                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1263                 .data = & (const struct snd_usb_midi_endpoint_info) {
1264                         .out_cables = 0x0003,
1265                         .in_cables  = 0x0003
1266                 }
1267         }
1268 },
1269 /* Roland UA-101 in High-Speed Mode only */
1270 {
1271         USB_DEVICE(0x0582, 0x007d),
1272         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1273                 .vendor_name = "Roland",
1274                 .product_name = "UA-101",
1275                 .ifnum = QUIRK_ANY_INTERFACE,
1276                 .type = QUIRK_COMPOSITE,
1277                 .data = (const struct snd_usb_audio_quirk[]) {
1278                         {
1279                                 .ifnum = 0,
1280                                 .type = QUIRK_AUDIO_EDIROL_UA101
1281                         },
1282                         {
1283                                 .ifnum = 1,
1284                                 .type = QUIRK_AUDIO_EDIROL_UA101
1285                         },
1286                         {
1287                                 .ifnum = 2,
1288                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1289                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1290                                         .out_cables = 0x0001,
1291                                         .in_cables  = 0x0001
1292                                 }
1293                         },
1294                         {
1295                                 .ifnum = -1
1296                         }
1297                 }
1298         }
1299 },
1300 {
1301         /* has ID 0x0081 when not in "Advanced Driver" mode */
1302         USB_DEVICE(0x0582, 0x0080),
1303         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1304                 .vendor_name = "Roland",
1305                 .product_name = "G-70",
1306                 .ifnum = 0,
1307                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1308                 .data = & (const struct snd_usb_midi_endpoint_info) {
1309                         .out_cables = 0x0001,
1310                         .in_cables  = 0x0001
1311                 }
1312         }
1313 },
1314         /* TODO: add Roland V-SYNTH XT support */
1315         /* TODO: add BOSS GT-PRO support */
1316 {
1317         /* has ID 0x008c when not in "Advanced Driver" mode */
1318         USB_DEVICE(0x0582, 0x008b),
1319         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1320                 .vendor_name = "EDIROL",
1321                 .product_name = "PC-50",
1322                 .ifnum = 0,
1323                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1324                 .data = & (const struct snd_usb_midi_endpoint_info) {
1325                         .out_cables = 0x0001,
1326                         .in_cables  = 0x0001
1327                 }
1328         }
1329 },
1330         /* TODO: add Edirol PC-80 support */
1331 {
1332         USB_DEVICE(0x0582, 0x0096),
1333         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1334                 .vendor_name = "EDIROL",
1335                 .product_name = "UA-1EX",
1336                 .ifnum = QUIRK_ANY_INTERFACE,
1337                 .type = QUIRK_COMPOSITE,
1338                 .data = (const struct snd_usb_audio_quirk[]) {
1339                         {
1340                                 .ifnum = 0,
1341                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1342                         },
1343                         {
1344                                 .ifnum = 1,
1345                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1346                         },
1347                         {
1348                                 .ifnum = -1
1349                         }
1350                 }
1351         }
1352 },
1353 {
1354         USB_DEVICE(0x0582, 0x009a),
1355         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1356                 .vendor_name = "EDIROL",
1357                 .product_name = "UM-3EX",
1358                 .ifnum = 0,
1359                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1360                 .data = & (const struct snd_usb_midi_endpoint_info) {
1361                         .out_cables = 0x000f,
1362                         .in_cables  = 0x000f
1363                 }
1364         }
1365 },
1366 {
1367         /*
1368          * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1369          * is standard compliant, but has only 16-bit PCM and no MIDI.
1370          */
1371         USB_DEVICE(0x0582, 0x00a3),
1372         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1373                 .vendor_name = "EDIROL",
1374                 .product_name = "UA-4FX",
1375                 .ifnum = QUIRK_ANY_INTERFACE,
1376                 .type = QUIRK_COMPOSITE,
1377                 .data = (const struct snd_usb_audio_quirk[]) {
1378                         {
1379                                 .ifnum = 0,
1380                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1381                         },
1382                         {
1383                                 .ifnum = 1,
1384                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1385                         },
1386                         {
1387                                 .ifnum = 2,
1388                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1389                         },
1390                         {
1391                                 .ifnum = -1
1392                         }
1393                 }
1394         }
1395 },
1396         /* TODO: add Edirol MD-P1 support */
1397 {
1398         USB_DEVICE(0x582, 0x00a6),
1399         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1400                 .vendor_name = "Roland",
1401                 .product_name = "Juno-G",
1402                 .ifnum = 0,
1403                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1404                 .data = & (const struct snd_usb_midi_endpoint_info) {
1405                         .out_cables = 0x0001,
1406                         .in_cables  = 0x0001
1407                 }
1408         }
1409 },
1410 {
1411         /* Roland SH-201 */
1412         USB_DEVICE(0x0582, 0x00ad),
1413         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1414                 .vendor_name = "Roland",
1415                 .product_name = "SH-201",
1416                 .ifnum = QUIRK_ANY_INTERFACE,
1417                 .type = QUIRK_COMPOSITE,
1418                 .data = (const struct snd_usb_audio_quirk[]) {
1419                         {
1420                                 .ifnum = 0,
1421                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1422                         },
1423                         {
1424                                 .ifnum = 1,
1425                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1426                         },
1427                         {
1428                                 .ifnum = 2,
1429                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1430                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1431                                         .out_cables = 0x0001,
1432                                         .in_cables  = 0x0001
1433                                 }
1434                         },
1435                         {
1436                                 .ifnum = -1
1437                         }
1438                 }
1439         }
1440 },
1441 {
1442         /* Roland SonicCell */
1443         USB_DEVICE(0x0582, 0x00c2),
1444         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1445                 .vendor_name = "Roland",
1446                 .product_name = "SonicCell",
1447                 .ifnum = QUIRK_ANY_INTERFACE,
1448                 .type = QUIRK_COMPOSITE,
1449                 .data = (const struct snd_usb_audio_quirk[]) {
1450                         {
1451                                 .ifnum = 0,
1452                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1453                         },
1454                         {
1455                                 .ifnum = 1,
1456                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1457                         },
1458                         {
1459                                 .ifnum = 2,
1460                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1461                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1462                                         .out_cables = 0x0001,
1463                                         .in_cables  = 0x0001
1464                                 }
1465                         },
1466                         {
1467                                 .ifnum = -1
1468                         }
1469                 }
1470         }
1471 },
1472 {
1473         /* Edirol M-16DX */
1474         /* FIXME: This quirk gives a good-working capture stream but the
1475          *        playback seems problematic because of lacking of sync
1476          *        with capture stream.  It needs to sync with the capture
1477          *        clock.  As now, you'll get frequent sound distortions
1478          *        via the playback.
1479          */
1480         USB_DEVICE(0x0582, 0x00c4),
1481         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1482                 .ifnum = QUIRK_ANY_INTERFACE,
1483                 .type = QUIRK_COMPOSITE,
1484                 .data = (const struct snd_usb_audio_quirk[]) {
1485                         {
1486                                 .ifnum = 0,
1487                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1488                         },
1489                         {
1490                                 .ifnum = 1,
1491                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1492                         },
1493                         {
1494                                 .ifnum = 2,
1495                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1496                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1497                                         .out_cables = 0x0001,
1498                                         .in_cables  = 0x0001
1499                                 }
1500                         },
1501                         {
1502                                 .ifnum = -1
1503                         }
1504                 }
1505         }
1506 },
1507 {
1508         /* BOSS GT-10 */
1509         USB_DEVICE(0x0582, 0x00da),
1510         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1511                 .ifnum = QUIRK_ANY_INTERFACE,
1512                 .type = QUIRK_COMPOSITE,
1513                 .data = (const struct snd_usb_audio_quirk[]) {
1514                         {
1515                                 .ifnum = 0,
1516                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1517                         },
1518                         {
1519                                 .ifnum = 1,
1520                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1521                         },
1522                         {
1523                                 .ifnum = 2,
1524                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1525                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1526                                         .out_cables = 0x0001,
1527                                         .in_cables  = 0x0001
1528                                 }
1529                         },
1530                         {
1531                                 .ifnum = -1
1532                         }
1533                 }
1534         }
1535 },
1536 {
1537         /* Advanced modes of the Edirol UA-25EX.
1538          * For the standard mode, UA-25EX has ID 0582:00e7, which
1539          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1540          */
1541         USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1542         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1543                 .vendor_name = "EDIROL",
1544                 .product_name = "UA-25EX",
1545                 .ifnum = QUIRK_ANY_INTERFACE,
1546                 .type = QUIRK_COMPOSITE,
1547                 .data = (const struct snd_usb_audio_quirk[]) {
1548                         {
1549                                 .ifnum = 0,
1550                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1551                         },
1552                         {
1553                                 .ifnum = 1,
1554                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1555                         },
1556                         {
1557                                 .ifnum = 2,
1558                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1559                         },
1560                         {
1561                                 .ifnum = -1
1562                         }
1563                 }
1564         }
1565 },
1566 {
1567         /* has ID 0x00ea when not in Advanced Driver mode */
1568         USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9),
1569         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1570                 /* .vendor_name = "Roland", */
1571                 /* .product_name = "UA-1G", */
1572                 .ifnum = QUIRK_ANY_INTERFACE,
1573                 .type = QUIRK_COMPOSITE,
1574                 .data = (const struct snd_usb_audio_quirk[]) {
1575                         {
1576                                 .ifnum = 0,
1577                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1578                         },
1579                         {
1580                                 .ifnum = 1,
1581                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1582                         },
1583                         {
1584                                 .ifnum = -1
1585                         }
1586                 }
1587         }
1588 },
1589
1590 /* Guillemot devices */
1591 {
1592         /*
1593          * This is for the "Windows Edition" where the external MIDI ports are
1594          * the only MIDI ports; the control data is reported through HID
1595          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1596          * compliant USB MIDI ports for external MIDI and controls.
1597          */
1598         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1599         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1600                 .vendor_name = "Hercules",
1601                 .product_name = "DJ Console (WE)",
1602                 .ifnum = 4,
1603                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1604                 .data = & (const struct snd_usb_midi_endpoint_info) {
1605                         .out_cables = 0x0001,
1606                         .in_cables = 0x0001
1607                 }
1608         }
1609 },
1610
1611 /* Midiman/M-Audio devices */
1612 {
1613         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1614         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1615                 .vendor_name = "M-Audio",
1616                 .product_name = "MidiSport 2x2",
1617                 .ifnum = QUIRK_ANY_INTERFACE,
1618                 .type = QUIRK_MIDI_MIDIMAN,
1619                 .data = & (const struct snd_usb_midi_endpoint_info) {
1620                         .out_cables = 0x0003,
1621                         .in_cables  = 0x0003
1622                 }
1623         }
1624 },
1625 {
1626         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1627         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1628                 .vendor_name = "M-Audio",
1629                 .product_name = "MidiSport 1x1",
1630                 .ifnum = QUIRK_ANY_INTERFACE,
1631                 .type = QUIRK_MIDI_MIDIMAN,
1632                 .data = & (const struct snd_usb_midi_endpoint_info) {
1633                         .out_cables = 0x0001,
1634                         .in_cables  = 0x0001
1635                 }
1636         }
1637 },
1638 {
1639         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1640         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1641                 .vendor_name = "M-Audio",
1642                 .product_name = "Keystation",
1643                 .ifnum = QUIRK_ANY_INTERFACE,
1644                 .type = QUIRK_MIDI_MIDIMAN,
1645                 .data = & (const struct snd_usb_midi_endpoint_info) {
1646                         .out_cables = 0x0001,
1647                         .in_cables  = 0x0001
1648                 }
1649         }
1650 },
1651 {
1652         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1653         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1654                 .vendor_name = "M-Audio",
1655                 .product_name = "MidiSport 4x4",
1656                 .ifnum = QUIRK_ANY_INTERFACE,
1657                 .type = QUIRK_MIDI_MIDIMAN,
1658                 .data = & (const struct snd_usb_midi_endpoint_info) {
1659                         .out_cables = 0x000f,
1660                         .in_cables  = 0x000f
1661                 }
1662         }
1663 },
1664 {
1665         /*
1666          * For hardware revision 1.05; in the later revisions (1.10 and
1667          * 1.21), 0x1031 is the ID for the device without firmware.
1668          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1669          */
1670         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1671         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1672                 .vendor_name = "M-Audio",
1673                 .product_name = "MidiSport 8x8",
1674                 .ifnum = QUIRK_ANY_INTERFACE,
1675                 .type = QUIRK_MIDI_MIDIMAN,
1676                 .data = & (const struct snd_usb_midi_endpoint_info) {
1677                         .out_cables = 0x01ff,
1678                         .in_cables  = 0x01ff
1679                 }
1680         }
1681 },
1682 {
1683         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1684         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1685                 .vendor_name = "M-Audio",
1686                 .product_name = "MidiSport 8x8",
1687                 .ifnum = QUIRK_ANY_INTERFACE,
1688                 .type = QUIRK_MIDI_MIDIMAN,
1689                 .data = & (const struct snd_usb_midi_endpoint_info) {
1690                         .out_cables = 0x01ff,
1691                         .in_cables  = 0x01ff
1692                 }
1693         }
1694 },
1695 {
1696         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1697         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1698                 .vendor_name = "M-Audio",
1699                 .product_name = "MidiSport 2x4",
1700                 .ifnum = QUIRK_ANY_INTERFACE,
1701                 .type = QUIRK_MIDI_MIDIMAN,
1702                 .data = & (const struct snd_usb_midi_endpoint_info) {
1703                         .out_cables = 0x000f,
1704                         .in_cables  = 0x0003
1705                 }
1706         }
1707 },
1708 {
1709         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1710         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1711                 .vendor_name = "M-Audio",
1712                 .product_name = "Quattro",
1713                 .ifnum = QUIRK_ANY_INTERFACE,
1714                 .type = QUIRK_COMPOSITE,
1715                 .data = & (const struct snd_usb_audio_quirk[]) {
1716                         /*
1717                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1718                          * and share endpoints with the other interfaces.
1719                          * Ignore them.  The other interfaces can do 24 bits,
1720                          * but captured samples are big-endian (see usbaudio.c).
1721                          */
1722                         {
1723                                 .ifnum = 0,
1724                                 .type = QUIRK_IGNORE_INTERFACE
1725                         },
1726                         {
1727                                 .ifnum = 1,
1728                                 .type = QUIRK_IGNORE_INTERFACE
1729                         },
1730                         {
1731                                 .ifnum = 2,
1732                                 .type = QUIRK_IGNORE_INTERFACE
1733                         },
1734                         {
1735                                 .ifnum = 3,
1736                                 .type = QUIRK_IGNORE_INTERFACE
1737                         },
1738                         {
1739                                 .ifnum = 4,
1740                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1741                         },
1742                         {
1743                                 .ifnum = 5,
1744                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1745                         },
1746                         {
1747                                 .ifnum = 6,
1748                                 .type = QUIRK_IGNORE_INTERFACE
1749                         },
1750                         {
1751                                 .ifnum = 7,
1752                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1753                         },
1754                         {
1755                                 .ifnum = 8,
1756                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1757                         },
1758                         {
1759                                 .ifnum = 9,
1760                                 .type = QUIRK_MIDI_MIDIMAN,
1761                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1762                                         .out_cables = 0x0001,
1763                                         .in_cables  = 0x0001
1764                                 }
1765                         },
1766                         {
1767                                 .ifnum = -1
1768                         }
1769                 }
1770         }
1771 },
1772 {
1773         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1774         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1775                 .vendor_name = "M-Audio",
1776                 .product_name = "AudioPhile",
1777                 .ifnum = 6,
1778                 .type = QUIRK_MIDI_MIDIMAN,
1779                 .data = & (const struct snd_usb_midi_endpoint_info) {
1780                         .out_cables = 0x0001,
1781                         .in_cables  = 0x0001
1782                 }
1783         }
1784 },
1785 {
1786         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1787         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1788                 .vendor_name = "M-Audio",
1789                 .product_name = "Ozone",
1790                 .ifnum = 3,
1791                 .type = QUIRK_MIDI_MIDIMAN,
1792                 .data = & (const struct snd_usb_midi_endpoint_info) {
1793                         .out_cables = 0x0001,
1794                         .in_cables  = 0x0001
1795                 }
1796         }
1797 },
1798 {
1799         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1800         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1801                 .vendor_name = "M-Audio",
1802                 .product_name = "OmniStudio",
1803                 .ifnum = QUIRK_ANY_INTERFACE,
1804                 .type = QUIRK_COMPOSITE,
1805                 .data = & (const struct snd_usb_audio_quirk[]) {
1806                         {
1807                                 .ifnum = 0,
1808                                 .type = QUIRK_IGNORE_INTERFACE
1809                         },
1810                         {
1811                                 .ifnum = 1,
1812                                 .type = QUIRK_IGNORE_INTERFACE
1813                         },
1814                         {
1815                                 .ifnum = 2,
1816                                 .type = QUIRK_IGNORE_INTERFACE
1817                         },
1818                         {
1819                                 .ifnum = 3,
1820                                 .type = QUIRK_IGNORE_INTERFACE
1821                         },
1822                         {
1823                                 .ifnum = 4,
1824                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1825                         },
1826                         {
1827                                 .ifnum = 5,
1828                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1829                         },
1830                         {
1831                                 .ifnum = 6,
1832                                 .type = QUIRK_IGNORE_INTERFACE
1833                         },
1834                         {
1835                                 .ifnum = 7,
1836                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1837                         },
1838                         {
1839                                 .ifnum = 8,
1840                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1841                         },
1842                         {
1843                                 .ifnum = 9,
1844                                 .type = QUIRK_MIDI_MIDIMAN,
1845                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1846                                         .out_cables = 0x0001,
1847                                         .in_cables  = 0x0001
1848                                 }
1849                         },
1850                         {
1851                                 .ifnum = -1
1852                         }
1853                 }
1854         }
1855 },
1856 {
1857         USB_DEVICE(0x0763, 0x2019),
1858         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1859                 /* .vendor_name = "M-Audio", */
1860                 /* .product_name = "Ozone Academic", */
1861                 .ifnum = QUIRK_ANY_INTERFACE,
1862                 .type = QUIRK_COMPOSITE,
1863                 .data = & (const struct snd_usb_audio_quirk[]) {
1864                         {
1865                                 .ifnum = 0,
1866                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1867                         },
1868                         {
1869                                 .ifnum = 1,
1870                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1871                         },
1872                         {
1873                                 .ifnum = 2,
1874                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1875                         },
1876                         {
1877                                 .ifnum = 3,
1878                                 .type = QUIRK_MIDI_MIDIMAN,
1879                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1880                                         .out_cables = 0x0001,
1881                                         .in_cables  = 0x0001
1882                                 }
1883                         },
1884                         {
1885                                 .ifnum = -1
1886                         }
1887                 }
1888         }
1889 },
1890
1891 /* Casio devices */
1892 {
1893         USB_DEVICE(0x07cf, 0x6801),
1894         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1895                 .vendor_name = "Casio",
1896                 .product_name = "PL-40R",
1897                 .ifnum = 0,
1898                 .type = QUIRK_MIDI_YAMAHA
1899         }
1900 },
1901 {
1902         /* this ID is used by several devices without a product ID */
1903         USB_DEVICE(0x07cf, 0x6802),
1904         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1905                 .vendor_name = "Casio",
1906                 .product_name = "Keyboard",
1907                 .ifnum = 0,
1908                 .type = QUIRK_MIDI_YAMAHA
1909         }
1910 },
1911
1912 /* Mark of the Unicorn devices */
1913 {
1914         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1915         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1916                        USB_DEVICE_ID_MATCH_PRODUCT |
1917                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
1918         .idVendor = 0x07fd,
1919         .idProduct = 0x0001,
1920         .bDeviceSubClass = 2,
1921         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1922                 .vendor_name = "MOTU",
1923                 .product_name = "Fastlane",
1924                 .ifnum = QUIRK_ANY_INTERFACE,
1925                 .type = QUIRK_COMPOSITE,
1926                 .data = & (const struct snd_usb_audio_quirk[]) {
1927                         {
1928                                 .ifnum = 0,
1929                                 .type = QUIRK_MIDI_FASTLANE
1930                         },
1931                         {
1932                                 .ifnum = 1,
1933                                 .type = QUIRK_IGNORE_INTERFACE
1934                         },
1935                         {
1936                                 .ifnum = -1
1937                         }
1938                 }
1939         }
1940 },
1941
1942 /* Emagic devices */
1943 {
1944         USB_DEVICE(0x086a, 0x0001),
1945         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1946                 .vendor_name = "Emagic",
1947                 /* .product_name = "Unitor8", */
1948                 .ifnum = 2,
1949                 .type = QUIRK_MIDI_EMAGIC,
1950                 .data = & (const struct snd_usb_midi_endpoint_info) {
1951                         .out_cables = 0x80ff,
1952                         .in_cables  = 0x80ff
1953                 }
1954         }
1955 },
1956 {
1957         USB_DEVICE(0x086a, 0x0002),
1958         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1959                 .vendor_name = "Emagic",
1960                 /* .product_name = "AMT8", */
1961                 .ifnum = 2,
1962                 .type = QUIRK_MIDI_EMAGIC,
1963                 .data = & (const struct snd_usb_midi_endpoint_info) {
1964                         .out_cables = 0x80ff,
1965                         .in_cables  = 0x80ff
1966                 }
1967         }
1968 },
1969 {
1970         USB_DEVICE(0x086a, 0x0003),
1971         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1972                 .vendor_name = "Emagic",
1973                 /* .product_name = "MT4", */
1974                 .ifnum = 2,
1975                 .type = QUIRK_MIDI_EMAGIC,
1976                 .data = & (const struct snd_usb_midi_endpoint_info) {
1977                         .out_cables = 0x800f,
1978                         .in_cables  = 0x8003
1979                 }
1980         }
1981 },
1982
1983 /* TerraTec devices */
1984 {
1985         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
1986         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1987                 .vendor_name = "TerraTec",
1988                 .product_name = "PHASE 26",
1989                 .ifnum = 3,
1990                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1991         }
1992 },
1993 {
1994         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1995         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1996                 .vendor_name = "TerraTec",
1997                 .product_name = "PHASE 26",
1998                 .ifnum = 3,
1999                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2000         }
2001 },
2002 {
2003         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2004         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2005                 .vendor_name = "TerraTec",
2006                 .product_name = "PHASE 26",
2007                 .ifnum = 3,
2008                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2009         }
2010 },
2011 {
2012         USB_DEVICE(0x0ccd, 0x0028),
2013         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2014                 .vendor_name = "TerraTec",
2015                 .product_name = "Aureon5.1MkII",
2016                 .ifnum = QUIRK_NO_INTERFACE
2017         }
2018 },
2019 {
2020         USB_DEVICE(0x0ccd, 0x0035),
2021         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2022                 .vendor_name = "Miditech",
2023                 .product_name = "Play'n Roll",
2024                 .ifnum = 0,
2025                 .type = QUIRK_MIDI_CME
2026         }
2027 },
2028
2029 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2030 {
2031         USB_DEVICE(0x103d, 0x0100),
2032                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2033                 .vendor_name = "Stanton",
2034                 .product_name = "ScratchAmp",
2035                 .ifnum = QUIRK_NO_INTERFACE
2036         }
2037 },
2038 {
2039         USB_DEVICE(0x103d, 0x0101),
2040                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2041                 .vendor_name = "Stanton",
2042                 .product_name = "ScratchAmp",
2043                 .ifnum = QUIRK_NO_INTERFACE
2044         }
2045 },
2046
2047 /* Novation EMS devices */
2048 {
2049         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2050         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2051                 .vendor_name = "Novation",
2052                 .product_name = "ReMOTE Audio/XStation",
2053                 .ifnum = 4,
2054                 .type = QUIRK_MIDI_NOVATION
2055         }
2056 },
2057 {
2058         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2059         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2060                 .vendor_name = "Novation",
2061                 .product_name = "Speedio",
2062                 .ifnum = 3,
2063                 .type = QUIRK_MIDI_NOVATION
2064         }
2065 },
2066 {
2067         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2068         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2069                 .vendor_name = "Novation",
2070                 .product_name = "ReMOTE25",
2071                 .ifnum = 0,
2072                 .type = QUIRK_MIDI_NOVATION
2073         }
2074 },
2075
2076 /* */
2077 {
2078         /* aka. Serato Scratch Live DJ Box */
2079         USB_DEVICE(0x13e5, 0x0001),
2080         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2081                 .vendor_name = "Rane",
2082                 .product_name = "SL-1",
2083                 .ifnum = QUIRK_NO_INTERFACE
2084         }
2085 },
2086
2087 /* Miditech devices */
2088 {
2089         USB_DEVICE(0x4752, 0x0011),
2090         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2091                 .vendor_name = "Miditech",
2092                 .product_name = "Midistart-2",
2093                 .ifnum = 0,
2094                 .type = QUIRK_MIDI_CME
2095         }
2096 },
2097
2098 /* Central Music devices */
2099 {
2100         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2101         USB_DEVICE(0x7104, 0x2202),
2102         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2103                 .ifnum = 0,
2104                 .type = QUIRK_MIDI_CME
2105         }
2106 },
2107
2108 {
2109         /*
2110          * Some USB MIDI devices don't have an audio control interface,
2111          * so we have to grab MIDI streaming interfaces here.
2112          */
2113         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
2114                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2115         .bInterfaceClass = USB_CLASS_AUDIO,
2116         .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
2117         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2118                 .ifnum = QUIRK_ANY_INTERFACE,
2119                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2120         }
2121 },
2122
2123 #undef USB_DEVICE_VENDOR_SPEC