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