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