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