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