ALSA: snd-usb-audio: support for Edirol UA-4FX device
[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_MIDI_FIXED_ENDPOINT,
874                                 .data = & (const struct snd_usb_midi_endpoint_info) {
875                                         .out_cables = 0x0003,
876                                         .in_cables  = 0x0003
877                                 }
878                         },
879                         {
880                                 .ifnum = -1
881                         }
882                 }
883         }
884 },
885 {
886         /* has ID 0x002e when not in "Advanced Driver" mode */
887         USB_DEVICE(0x0582, 0x002d),
888         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
889                 .vendor_name = "Roland",
890                 .product_name = "XV-2020",
891                 .ifnum = 0,
892                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
893                 .data = & (const struct snd_usb_midi_endpoint_info) {
894                         .out_cables = 0x0001,
895                         .in_cables  = 0x0001
896                 }
897         }
898 },
899 {
900         /* has ID 0x0030 when not in "Advanced Driver" mode */
901         USB_DEVICE(0x0582, 0x002f),
902         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
903                 .vendor_name = "Roland",
904                 .product_name = "VariOS",
905                 .ifnum = 0,
906                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
907                 .data = & (const struct snd_usb_midi_endpoint_info) {
908                         .out_cables = 0x0007,
909                         .in_cables  = 0x0007
910                 }
911         }
912 },
913 {
914         /* has ID 0x0034 when not in "Advanced Driver" mode */
915         USB_DEVICE(0x0582, 0x0033),
916         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
917                 .vendor_name = "EDIROL",
918                 .product_name = "PCR",
919                 .ifnum = 0,
920                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
921                 .data = & (const struct snd_usb_midi_endpoint_info) {
922                         .out_cables = 0x0003,
923                         .in_cables  = 0x0007
924                 }
925         }
926 },
927         /* TODO: add Roland M-1000 support */
928 {
929         /*
930          * Has ID 0x0038 when not in "Advanced Driver" mode;
931          * later revisions use IDs 0x0054 and 0x00a2.
932          */
933         USB_DEVICE(0x0582, 0x0037),
934         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
935                 .vendor_name = "Roland",
936                 .product_name = "Digital Piano",
937                 .ifnum = 0,
938                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
939                 .data = & (const struct snd_usb_midi_endpoint_info) {
940                         .out_cables = 0x0001,
941                         .in_cables  = 0x0001
942                 }
943         }
944 },
945 {
946         /*
947          * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
948          * has ID 0x003c and is standard compliant, but has only 16-bit PCM
949          * and no MIDI.
950          */
951         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
952         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
953                 .vendor_name = "BOSS",
954                 .product_name = "GS-10",
955                 .ifnum = QUIRK_ANY_INTERFACE,
956                 .type = QUIRK_COMPOSITE,
957                 .data = & (const struct snd_usb_audio_quirk[]) {
958                         {
959                                 .ifnum = 1,
960                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
961                         },
962                         {
963                                 .ifnum = 2,
964                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
965                         },
966                         {
967                                 .ifnum = 3,
968                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
969                         },
970                         {
971                                 .ifnum = -1
972                         }
973                 }
974         }
975 },
976 {
977         /* has ID 0x0041 when not in "Advanced Driver" mode */
978         USB_DEVICE(0x0582, 0x0040),
979         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
980                 .vendor_name = "Roland",
981                 .product_name = "GI-20",
982                 .ifnum = 0,
983                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
984                 .data = & (const struct snd_usb_midi_endpoint_info) {
985                         .out_cables = 0x0001,
986                         .in_cables  = 0x0001
987                 }
988         }
989 },
990 {
991         /* has ID 0x0043 when not in "Advanced Driver" mode */
992         USB_DEVICE(0x0582, 0x0042),
993         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
994                 .vendor_name = "Roland",
995                 .product_name = "RS-70",
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         USB_DEVICE(0x0582, 0x0044),
1006         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1007                 .vendor_name = "Roland",
1008                 .product_name = "UA-1000",
1009                 .ifnum = QUIRK_ANY_INTERFACE,
1010                 .type = QUIRK_COMPOSITE,
1011                 .data = (const struct snd_usb_audio_quirk[]) {
1012                         {
1013                                 .ifnum = 1,
1014                                 .type = QUIRK_AUDIO_EDIROL_UA1000
1015                         },
1016                         {
1017                                 .ifnum = 2,
1018                                 .type = QUIRK_AUDIO_EDIROL_UA1000
1019                         },
1020                         {
1021                                 .ifnum = 3,
1022                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1023                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1024                                         .out_cables = 0x0003,
1025                                         .in_cables  = 0x0003
1026                                 }
1027                         },
1028                         {
1029                                 .ifnum = -1
1030                         }
1031                 }
1032         }
1033 },
1034 {
1035         /* has ID 0x0049 when not in "Advanced Driver" mode */
1036         USB_DEVICE(0x0582, 0x0047),
1037         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1038                 /* .vendor_name = "EDIROL", */
1039                 /* .product_name = "UR-80", */
1040                 .ifnum = QUIRK_ANY_INTERFACE,
1041                 .type = QUIRK_COMPOSITE,
1042                 .data = (const struct snd_usb_audio_quirk[]) {
1043                         /* in the 96 kHz modes, only interface 1 is there */
1044                         {
1045                                 .ifnum = 1,
1046                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1047                         },
1048                         {
1049                                 .ifnum = 2,
1050                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1051                         },
1052                         {
1053                                 .ifnum = -1
1054                         }
1055                 }
1056         }
1057 },
1058 {
1059         /* has ID 0x004a when not in "Advanced Driver" mode */
1060         USB_DEVICE(0x0582, 0x0048),
1061         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1062                 /* .vendor_name = "EDIROL", */
1063                 /* .product_name = "UR-80", */
1064                 .ifnum = 0,
1065                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1066                 .data = & (const struct snd_usb_midi_endpoint_info) {
1067                         .out_cables = 0x0003,
1068                         .in_cables  = 0x0007
1069                 }
1070         }
1071 },
1072         /* TODO: add Edirol M-100FX support */
1073 {
1074         /* has ID 0x004e when not in "Advanced Driver" mode */
1075         USB_DEVICE(0x0582, 0x004c),
1076         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1077                 .vendor_name = "EDIROL",
1078                 .product_name = "PCR-A",
1079                 .ifnum = QUIRK_ANY_INTERFACE,
1080                 .type = QUIRK_COMPOSITE,
1081                 .data = (const struct snd_usb_audio_quirk[]) {
1082                         {
1083                                 .ifnum = 1,
1084                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1085                         },
1086                         {
1087                                 .ifnum = 2,
1088                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1089                         },
1090                         {
1091                                 .ifnum = -1
1092                         }
1093                 }
1094         }
1095 },
1096 {
1097         /* has ID 0x004f when not in "Advanced Driver" mode */
1098         USB_DEVICE(0x0582, 0x004d),
1099         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1100                 .vendor_name = "EDIROL",
1101                 .product_name = "PCR-A",
1102                 .ifnum = 0,
1103                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1104                 .data = & (const struct snd_usb_midi_endpoint_info) {
1105                         .out_cables = 0x0003,
1106                         .in_cables  = 0x0007
1107                 }
1108         }
1109 },
1110 {
1111         /*
1112          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1113          * is standard compliant, but has only 16-bit PCM.
1114          */
1115         USB_DEVICE(0x0582, 0x0050),
1116         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1117                 .vendor_name = "EDIROL",
1118                 .product_name = "UA-3FX",
1119                 .ifnum = QUIRK_ANY_INTERFACE,
1120                 .type = QUIRK_COMPOSITE,
1121                 .data = (const struct snd_usb_audio_quirk[]) {
1122                         {
1123                                 .ifnum = 1,
1124                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1125                         },
1126                         {
1127                                 .ifnum = 2,
1128                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1129                         },
1130                         {
1131                                 .ifnum = -1
1132                         }
1133                 }
1134         }
1135 },
1136 {
1137         USB_DEVICE(0x0582, 0x0052),
1138         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1139                 .vendor_name = "EDIROL",
1140                 .product_name = "UM-1SX",
1141                 .ifnum = 0,
1142                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1143         }
1144 },
1145 {
1146         USB_DEVICE(0x0582, 0x0060),
1147         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1148                 .vendor_name = "Roland",
1149                 .product_name = "EXR Series",
1150                 .ifnum = 0,
1151                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1152         }
1153 },
1154 {
1155         /* has ID 0x0067 when not in "Advanced Driver" mode */
1156         USB_DEVICE(0x0582, 0x0065),
1157         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1158                 .vendor_name = "EDIROL",
1159                 .product_name = "PCR-1",
1160                 .ifnum = 0,
1161                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1162                 .data = & (const struct snd_usb_midi_endpoint_info) {
1163                         .out_cables = 0x0001,
1164                         .in_cables  = 0x0003
1165                 }
1166         }
1167 },
1168 {
1169         /* has ID 0x006b when not in "Advanced Driver" mode */
1170         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1171         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1172                 .vendor_name = "Roland",
1173                 .product_name = "SP-606",
1174                 .ifnum = 3,
1175                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1176                 .data = & (const struct snd_usb_midi_endpoint_info) {
1177                         .out_cables = 0x0001,
1178                         .in_cables  = 0x0001
1179                 }
1180         }
1181 },
1182 {
1183         /* has ID 0x006e when not in "Advanced Driver" mode */
1184         USB_DEVICE(0x0582, 0x006d),
1185         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1186                 .vendor_name = "Roland",
1187                 .product_name = "FANTOM-X",
1188                 .ifnum = 0,
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          * This quirk is for the "Advanced" modes of the Edirol UA-25.
1198          * If the switch is not in an advanced setting, the UA-25 has
1199          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1200          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1201          */
1202         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1203         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1204                 .vendor_name = "EDIROL",
1205                 .product_name = "UA-25",
1206                 .ifnum = QUIRK_ANY_INTERFACE,
1207                 .type = QUIRK_COMPOSITE,
1208                 .data = (const struct snd_usb_audio_quirk[]) {
1209                         {
1210                                 .ifnum = 0,
1211                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1212                         },
1213                         {
1214                                 .ifnum = 1,
1215                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1216                         },
1217                         {
1218                                 .ifnum = 2,
1219                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1220                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1221                                         .out_cables = 0x0001,
1222                                         .in_cables  = 0x0001
1223                                 }
1224                         },
1225                         {
1226                                 .ifnum = -1
1227                         }
1228                 }
1229         }
1230 },
1231 {
1232         /* has ID 0x0076 when not in "Advanced Driver" mode */
1233         USB_DEVICE(0x0582, 0x0075),
1234         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1235                 .vendor_name = "BOSS",
1236                 .product_name = "DR-880",
1237                 .ifnum = 0,
1238                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1239                 .data = & (const struct snd_usb_midi_endpoint_info) {
1240                         .out_cables = 0x0001,
1241                         .in_cables  = 0x0001
1242                 }
1243         }
1244 },
1245 {
1246         /* has ID 0x007b when not in "Advanced Driver" mode */
1247         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1248         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1249                 .vendor_name = "Roland",
1250                 /* "RD" or "RD-700SX"? */
1251                 .ifnum = 0,
1252                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1253                 .data = & (const struct snd_usb_midi_endpoint_info) {
1254                         .out_cables = 0x0003,
1255                         .in_cables  = 0x0003
1256                 }
1257         }
1258 },
1259 /* Roland UA-101 in High-Speed Mode only */
1260 {
1261         USB_DEVICE(0x0582, 0x007d),
1262         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1263                 .vendor_name = "Roland",
1264                 .product_name = "UA-101",
1265                 .ifnum = QUIRK_ANY_INTERFACE,
1266                 .type = QUIRK_COMPOSITE,
1267                 .data = (const struct snd_usb_audio_quirk[]) {
1268                         {
1269                                 .ifnum = 0,
1270                                 .type = QUIRK_AUDIO_EDIROL_UA101
1271                         },
1272                         {
1273                                 .ifnum = 1,
1274                                 .type = QUIRK_AUDIO_EDIROL_UA101
1275                         },
1276                         {
1277                                 .ifnum = 2,
1278                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1279                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1280                                         .out_cables = 0x0001,
1281                                         .in_cables  = 0x0001
1282                                 }
1283                         },
1284                         {
1285                                 .ifnum = -1
1286                         }
1287                 }
1288         }
1289 },
1290 {
1291         /* has ID 0x0081 when not in "Advanced Driver" mode */
1292         USB_DEVICE(0x0582, 0x0080),
1293         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1294                 .vendor_name = "Roland",
1295                 .product_name = "G-70",
1296                 .ifnum = 0,
1297                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1298                 .data = & (const struct snd_usb_midi_endpoint_info) {
1299                         .out_cables = 0x0001,
1300                         .in_cables  = 0x0001
1301                 }
1302         }
1303 },
1304         /* TODO: add Roland V-SYNTH XT support */
1305         /* TODO: add BOSS GT-PRO support */
1306 {
1307         /* has ID 0x008c when not in "Advanced Driver" mode */
1308         USB_DEVICE(0x0582, 0x008b),
1309         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1310                 .vendor_name = "EDIROL",
1311                 .product_name = "PC-50",
1312                 .ifnum = 0,
1313                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1314                 .data = & (const struct snd_usb_midi_endpoint_info) {
1315                         .out_cables = 0x0001,
1316                         .in_cables  = 0x0001
1317                 }
1318         }
1319 },
1320         /* TODO: add Edirol PC-80 support */
1321 {
1322         USB_DEVICE(0x0582, 0x0096),
1323         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1324                 .vendor_name = "EDIROL",
1325                 .product_name = "UA-1EX",
1326                 .ifnum = QUIRK_ANY_INTERFACE,
1327                 .type = QUIRK_COMPOSITE,
1328                 .data = (const struct snd_usb_audio_quirk[]) {
1329                         {
1330                                 .ifnum = 0,
1331                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1332                         },
1333                         {
1334                                 .ifnum = 1,
1335                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1336                         },
1337                         {
1338                                 .ifnum = -1
1339                         }
1340                 }
1341         }
1342 },
1343 {
1344         USB_DEVICE(0x0582, 0x009a),
1345         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1346                 .vendor_name = "EDIROL",
1347                 .product_name = "UM-3EX",
1348                 .ifnum = 0,
1349                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1350                 .data = & (const struct snd_usb_midi_endpoint_info) {
1351                         .out_cables = 0x000f,
1352                         .in_cables  = 0x000f
1353                 }
1354         }
1355 },
1356 {
1357         /*
1358          * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1359          * is standard compliant, but has only 16-bit PCM and no MIDI.
1360          */
1361         USB_DEVICE(0x0582, 0x00a3),
1362         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1363                 .vendor_name = "EDIROL",
1364                 .product_name = "UA-4FX",
1365                 .ifnum = QUIRK_ANY_INTERFACE,
1366                 .type = QUIRK_COMPOSITE,
1367                 .data = (const struct snd_usb_audio_quirk[]) {
1368                         {
1369                                 .ifnum = 0,
1370                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1371                         },
1372                         {
1373                                 .ifnum = 1,
1374                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1375                         },
1376                         {
1377                                 .ifnum = 2,
1378                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1379                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1380                                         .out_cables = 0x0001,
1381                                         .in_cables  = 0x0001
1382                                 }
1383                         },
1384                         {
1385                                 .ifnum = -1
1386                         }
1387                 }
1388         }
1389 },
1390         /* TODO: add Edirol MD-P1 support */
1391 {
1392         USB_DEVICE(0x582, 0x00a6),
1393         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1394                 .vendor_name = "Roland",
1395                 .product_name = "Juno-G",
1396                 .ifnum = 0,
1397                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1398                 .data = & (const struct snd_usb_midi_endpoint_info) {
1399                         .out_cables = 0x0001,
1400                         .in_cables  = 0x0001
1401                 }
1402         }
1403 },
1404 {
1405         /* Roland SH-201 */
1406         USB_DEVICE(0x0582, 0x00ad),
1407         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1408                 .vendor_name = "Roland",
1409                 .product_name = "SH-201",
1410                 .ifnum = QUIRK_ANY_INTERFACE,
1411                 .type = QUIRK_COMPOSITE,
1412                 .data = (const struct snd_usb_audio_quirk[]) {
1413                         {
1414                                 .ifnum = 0,
1415                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1416                         },
1417                         {
1418                                 .ifnum = 1,
1419                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1420                         },
1421                         {
1422                                 .ifnum = 2,
1423                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1424                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1425                                         .out_cables = 0x0001,
1426                                         .in_cables  = 0x0001
1427                                 }
1428                         },
1429                         {
1430                                 .ifnum = -1
1431                         }
1432                 }
1433         }
1434 },
1435 {
1436         /* Roland SonicCell */
1437         USB_DEVICE(0x0582, 0x00c2),
1438         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1439                 .vendor_name = "Roland",
1440                 .product_name = "SonicCell",
1441                 .ifnum = QUIRK_ANY_INTERFACE,
1442                 .type = QUIRK_COMPOSITE,
1443                 .data = (const struct snd_usb_audio_quirk[]) {
1444                         {
1445                                 .ifnum = 0,
1446                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1447                         },
1448                         {
1449                                 .ifnum = 1,
1450                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1451                         },
1452                         {
1453                                 .ifnum = 2,
1454                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1455                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1456                                         .out_cables = 0x0001,
1457                                         .in_cables  = 0x0001
1458                                 }
1459                         },
1460                         {
1461                                 .ifnum = -1
1462                         }
1463                 }
1464         }
1465 },
1466 {
1467         /* BOSS GT-10 */
1468         USB_DEVICE(0x0582, 0x00da),
1469         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1470                 .ifnum = QUIRK_ANY_INTERFACE,
1471                 .type = QUIRK_COMPOSITE,
1472                 .data = (const struct snd_usb_audio_quirk[]) {
1473                         {
1474                                 .ifnum = 0,
1475                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1476                         },
1477                         {
1478                                 .ifnum = 1,
1479                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1480                         },
1481                         {
1482                                 .ifnum = 2,
1483                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1484                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1485                                         .out_cables = 0x0001,
1486                                         .in_cables  = 0x0001
1487                                 }
1488                         },
1489                         {
1490                                 .ifnum = -1
1491                         }
1492                 }
1493         }
1494 },
1495
1496 /* Guillemot devices */
1497 {
1498         /*
1499          * This is for the "Windows Edition" where the external MIDI ports are
1500          * the only MIDI ports; the control data is reported through HID
1501          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1502          * compliant USB MIDI ports for external MIDI and controls.
1503          */
1504         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1505         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1506                 .vendor_name = "Hercules",
1507                 .product_name = "DJ Console (WE)",
1508                 .ifnum = 4,
1509                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1510                 .data = & (const struct snd_usb_midi_endpoint_info) {
1511                         .out_cables = 0x0001,
1512                         .in_cables = 0x0001
1513                 }
1514         }
1515 },
1516
1517 /* Midiman/M-Audio devices */
1518 {
1519         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1520         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1521                 .vendor_name = "M-Audio",
1522                 .product_name = "MidiSport 2x2",
1523                 .ifnum = QUIRK_ANY_INTERFACE,
1524                 .type = QUIRK_MIDI_MIDIMAN,
1525                 .data = & (const struct snd_usb_midi_endpoint_info) {
1526                         .out_cables = 0x0003,
1527                         .in_cables  = 0x0003
1528                 }
1529         }
1530 },
1531 {
1532         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1533         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1534                 .vendor_name = "M-Audio",
1535                 .product_name = "MidiSport 1x1",
1536                 .ifnum = QUIRK_ANY_INTERFACE,
1537                 .type = QUIRK_MIDI_MIDIMAN,
1538                 .data = & (const struct snd_usb_midi_endpoint_info) {
1539                         .out_cables = 0x0001,
1540                         .in_cables  = 0x0001
1541                 }
1542         }
1543 },
1544 {
1545         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1546         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1547                 .vendor_name = "M-Audio",
1548                 .product_name = "Keystation",
1549                 .ifnum = QUIRK_ANY_INTERFACE,
1550                 .type = QUIRK_MIDI_MIDIMAN,
1551                 .data = & (const struct snd_usb_midi_endpoint_info) {
1552                         .out_cables = 0x0001,
1553                         .in_cables  = 0x0001
1554                 }
1555         }
1556 },
1557 {
1558         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1559         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1560                 .vendor_name = "M-Audio",
1561                 .product_name = "MidiSport 4x4",
1562                 .ifnum = QUIRK_ANY_INTERFACE,
1563                 .type = QUIRK_MIDI_MIDIMAN,
1564                 .data = & (const struct snd_usb_midi_endpoint_info) {
1565                         .out_cables = 0x000f,
1566                         .in_cables  = 0x000f
1567                 }
1568         }
1569 },
1570 {
1571         /*
1572          * For hardware revision 1.05; in the later revisions (1.10 and
1573          * 1.21), 0x1031 is the ID for the device without firmware.
1574          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1575          */
1576         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1577         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1578                 .vendor_name = "M-Audio",
1579                 .product_name = "MidiSport 8x8",
1580                 .ifnum = QUIRK_ANY_INTERFACE,
1581                 .type = QUIRK_MIDI_MIDIMAN,
1582                 .data = & (const struct snd_usb_midi_endpoint_info) {
1583                         .out_cables = 0x01ff,
1584                         .in_cables  = 0x01ff
1585                 }
1586         }
1587 },
1588 {
1589         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1590         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1591                 .vendor_name = "M-Audio",
1592                 .product_name = "MidiSport 8x8",
1593                 .ifnum = QUIRK_ANY_INTERFACE,
1594                 .type = QUIRK_MIDI_MIDIMAN,
1595                 .data = & (const struct snd_usb_midi_endpoint_info) {
1596                         .out_cables = 0x01ff,
1597                         .in_cables  = 0x01ff
1598                 }
1599         }
1600 },
1601 {
1602         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1603         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1604                 .vendor_name = "M-Audio",
1605                 .product_name = "MidiSport 2x4",
1606                 .ifnum = QUIRK_ANY_INTERFACE,
1607                 .type = QUIRK_MIDI_MIDIMAN,
1608                 .data = & (const struct snd_usb_midi_endpoint_info) {
1609                         .out_cables = 0x000f,
1610                         .in_cables  = 0x0003
1611                 }
1612         }
1613 },
1614 {
1615         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1616         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1617                 .vendor_name = "M-Audio",
1618                 .product_name = "Quattro",
1619                 .ifnum = QUIRK_ANY_INTERFACE,
1620                 .type = QUIRK_COMPOSITE,
1621                 .data = & (const struct snd_usb_audio_quirk[]) {
1622                         /*
1623                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1624                          * and share endpoints with the other interfaces.
1625                          * Ignore them.  The other interfaces can do 24 bits,
1626                          * but captured samples are big-endian (see usbaudio.c).
1627                          */
1628                         {
1629                                 .ifnum = 0,
1630                                 .type = QUIRK_IGNORE_INTERFACE
1631                         },
1632                         {
1633                                 .ifnum = 1,
1634                                 .type = QUIRK_IGNORE_INTERFACE
1635                         },
1636                         {
1637                                 .ifnum = 2,
1638                                 .type = QUIRK_IGNORE_INTERFACE
1639                         },
1640                         {
1641                                 .ifnum = 3,
1642                                 .type = QUIRK_IGNORE_INTERFACE
1643                         },
1644                         {
1645                                 .ifnum = 4,
1646                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1647                         },
1648                         {
1649                                 .ifnum = 5,
1650                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1651                         },
1652                         {
1653                                 .ifnum = 6,
1654                                 .type = QUIRK_IGNORE_INTERFACE
1655                         },
1656                         {
1657                                 .ifnum = 7,
1658                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1659                         },
1660                         {
1661                                 .ifnum = 8,
1662                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1663                         },
1664                         {
1665                                 .ifnum = 9,
1666                                 .type = QUIRK_MIDI_MIDIMAN,
1667                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1668                                         .out_cables = 0x0001,
1669                                         .in_cables  = 0x0001
1670                                 }
1671                         },
1672                         {
1673                                 .ifnum = -1
1674                         }
1675                 }
1676         }
1677 },
1678 {
1679         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1680         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1681                 .vendor_name = "M-Audio",
1682                 .product_name = "AudioPhile",
1683                 .ifnum = 6,
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 {
1692         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1693         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1694                 .vendor_name = "M-Audio",
1695                 .product_name = "Ozone",
1696                 .ifnum = 3,
1697                 .type = QUIRK_MIDI_MIDIMAN,
1698                 .data = & (const struct snd_usb_midi_endpoint_info) {
1699                         .out_cables = 0x0001,
1700                         .in_cables  = 0x0001
1701                 }
1702         }
1703 },
1704 {
1705         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1706         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1707                 .vendor_name = "M-Audio",
1708                 .product_name = "OmniStudio",
1709                 .ifnum = QUIRK_ANY_INTERFACE,
1710                 .type = QUIRK_COMPOSITE,
1711                 .data = & (const struct snd_usb_audio_quirk[]) {
1712                         {
1713                                 .ifnum = 0,
1714                                 .type = QUIRK_IGNORE_INTERFACE
1715                         },
1716                         {
1717                                 .ifnum = 1,
1718                                 .type = QUIRK_IGNORE_INTERFACE
1719                         },
1720                         {
1721                                 .ifnum = 2,
1722                                 .type = QUIRK_IGNORE_INTERFACE
1723                         },
1724                         {
1725                                 .ifnum = 3,
1726                                 .type = QUIRK_IGNORE_INTERFACE
1727                         },
1728                         {
1729                                 .ifnum = 4,
1730                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1731                         },
1732                         {
1733                                 .ifnum = 5,
1734                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1735                         },
1736                         {
1737                                 .ifnum = 6,
1738                                 .type = QUIRK_IGNORE_INTERFACE
1739                         },
1740                         {
1741                                 .ifnum = 7,
1742                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1743                         },
1744                         {
1745                                 .ifnum = 8,
1746                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1747                         },
1748                         {
1749                                 .ifnum = 9,
1750                                 .type = QUIRK_MIDI_MIDIMAN,
1751                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1752                                         .out_cables = 0x0001,
1753                                         .in_cables  = 0x0001
1754                                 }
1755                         },
1756                         {
1757                                 .ifnum = -1
1758                         }
1759                 }
1760         }
1761 },
1762 {
1763         USB_DEVICE(0x0763, 0x2019),
1764         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1765                 /* .vendor_name = "M-Audio", */
1766                 /* .product_name = "Ozone Academic", */
1767                 .ifnum = QUIRK_ANY_INTERFACE,
1768                 .type = QUIRK_COMPOSITE,
1769                 .data = & (const struct snd_usb_audio_quirk[]) {
1770                         {
1771                                 .ifnum = 0,
1772                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1773                         },
1774                         {
1775                                 .ifnum = 1,
1776                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1777                         },
1778                         {
1779                                 .ifnum = 2,
1780                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1781                         },
1782                         {
1783                                 .ifnum = 3,
1784                                 .type = QUIRK_MIDI_MIDIMAN,
1785                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1786                                         .out_cables = 0x0001,
1787                                         .in_cables  = 0x0001
1788                                 }
1789                         },
1790                         {
1791                                 .ifnum = -1
1792                         }
1793                 }
1794         }
1795 },
1796
1797 /* Casio devices */
1798 {
1799         USB_DEVICE(0x07cf, 0x6801),
1800         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1801                 .vendor_name = "Casio",
1802                 .product_name = "PL-40R",
1803                 .ifnum = 0,
1804                 .type = QUIRK_MIDI_YAMAHA
1805         }
1806 },
1807 {
1808         /* this ID is used by several devices without a product ID */
1809         USB_DEVICE(0x07cf, 0x6802),
1810         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1811                 .vendor_name = "Casio",
1812                 .product_name = "Keyboard",
1813                 .ifnum = 0,
1814                 .type = QUIRK_MIDI_YAMAHA
1815         }
1816 },
1817
1818 /* Mark of the Unicorn devices */
1819 {
1820         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1821         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1822                        USB_DEVICE_ID_MATCH_PRODUCT |
1823                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
1824         .idVendor = 0x07fd,
1825         .idProduct = 0x0001,
1826         .bDeviceSubClass = 2,
1827         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1828                 .vendor_name = "MOTU",
1829                 .product_name = "Fastlane",
1830                 .ifnum = QUIRK_ANY_INTERFACE,
1831                 .type = QUIRK_COMPOSITE,
1832                 .data = & (const struct snd_usb_audio_quirk[]) {
1833                         {
1834                                 .ifnum = 0,
1835                                 .type = QUIRK_MIDI_RAW
1836                         },
1837                         {
1838                                 .ifnum = 1,
1839                                 .type = QUIRK_IGNORE_INTERFACE
1840                         },
1841                         {
1842                                 .ifnum = -1
1843                         }
1844                 }
1845         }
1846 },
1847
1848 /* Emagic devices */
1849 {
1850         USB_DEVICE(0x086a, 0x0001),
1851         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1852                 .vendor_name = "Emagic",
1853                 /* .product_name = "Unitor8", */
1854                 .ifnum = 2,
1855                 .type = QUIRK_MIDI_EMAGIC,
1856                 .data = & (const struct snd_usb_midi_endpoint_info) {
1857                         .out_cables = 0x80ff,
1858                         .in_cables  = 0x80ff
1859                 }
1860         }
1861 },
1862 {
1863         USB_DEVICE(0x086a, 0x0002),
1864         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1865                 .vendor_name = "Emagic",
1866                 /* .product_name = "AMT8", */
1867                 .ifnum = 2,
1868                 .type = QUIRK_MIDI_EMAGIC,
1869                 .data = & (const struct snd_usb_midi_endpoint_info) {
1870                         .out_cables = 0x80ff,
1871                         .in_cables  = 0x80ff
1872                 }
1873         }
1874 },
1875 {
1876         USB_DEVICE(0x086a, 0x0003),
1877         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1878                 .vendor_name = "Emagic",
1879                 /* .product_name = "MT4", */
1880                 .ifnum = 2,
1881                 .type = QUIRK_MIDI_EMAGIC,
1882                 .data = & (const struct snd_usb_midi_endpoint_info) {
1883                         .out_cables = 0x800f,
1884                         .in_cables  = 0x8003
1885                 }
1886         }
1887 },
1888
1889 /* TerraTec devices */
1890 {
1891         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
1892         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1893                 .vendor_name = "TerraTec",
1894                 .product_name = "PHASE 26",
1895                 .ifnum = 3,
1896                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1897         }
1898 },
1899 {
1900         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1901         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1902                 .vendor_name = "TerraTec",
1903                 .product_name = "PHASE 26",
1904                 .ifnum = 3,
1905                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1906         }
1907 },
1908 {
1909         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
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(0x0ccd, 0x0035),
1919         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1920                 .vendor_name = "Miditech",
1921                 .product_name = "Play'n Roll",
1922                 .ifnum = 0,
1923                 .type = QUIRK_MIDI_CME
1924         }
1925 },
1926
1927 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
1928 {
1929         USB_DEVICE(0x103d, 0x0100),
1930                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1931                 .vendor_name = "Stanton",
1932                 .product_name = "ScratchAmp",
1933                 .ifnum = QUIRK_NO_INTERFACE
1934         }
1935 },
1936 {
1937         USB_DEVICE(0x103d, 0x0101),
1938                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1939                 .vendor_name = "Stanton",
1940                 .product_name = "ScratchAmp",
1941                 .ifnum = QUIRK_NO_INTERFACE
1942         }
1943 },
1944
1945 /* Novation EMS devices */
1946 {
1947         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
1948         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1949                 .vendor_name = "Novation",
1950                 .product_name = "ReMOTE Audio/XStation",
1951                 .ifnum = 4,
1952                 .type = QUIRK_MIDI_NOVATION
1953         }
1954 },
1955 {
1956         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
1957         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1958                 .vendor_name = "Novation",
1959                 .product_name = "Speedio",
1960                 .ifnum = 3,
1961                 .type = QUIRK_MIDI_NOVATION
1962         }
1963 },
1964 {
1965         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
1966         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1967                 .vendor_name = "Novation",
1968                 .product_name = "ReMOTE25",
1969                 .ifnum = 0,
1970                 .type = QUIRK_MIDI_NOVATION
1971         }
1972 },
1973
1974 /* */
1975 {
1976         /* aka. Serato Scratch Live DJ Box */
1977         USB_DEVICE(0x13e5, 0x0001),
1978         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1979                 .vendor_name = "Rane",
1980                 .product_name = "SL-1",
1981                 .ifnum = QUIRK_NO_INTERFACE
1982         }
1983 },
1984
1985 /* Miditech devices */
1986 {
1987         USB_DEVICE(0x4752, 0x0011),
1988         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1989                 .vendor_name = "Miditech",
1990                 .product_name = "Midistart-2",
1991                 .ifnum = 0,
1992                 .type = QUIRK_MIDI_CME
1993         }
1994 },
1995
1996 /* Central Music devices */
1997 {
1998         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
1999         USB_DEVICE(0x7104, 0x2202),
2000         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2001                 .ifnum = 0,
2002                 .type = QUIRK_MIDI_CME
2003         }
2004 },
2005
2006 {
2007         /*
2008          * Some USB MIDI devices don't have an audio control interface,
2009          * so we have to grab MIDI streaming interfaces here.
2010          */
2011         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
2012                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2013         .bInterfaceClass = USB_CLASS_AUDIO,
2014         .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
2015         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2016                 .ifnum = QUIRK_ANY_INTERFACE,
2017                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2018         }
2019 },
2020
2021 #undef USB_DEVICE_VENDOR_SPEC