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