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