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