arm: tegra: raise cpu floor when display is on
[linux-2.6.git] / sound / usb / quirks-table.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/Toshiba Multimedia Center SB-0500 */
43 {
44         USB_DEVICE(0x041e, 0x3048),
45         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
46                 .vendor_name = "Toshiba",
47                 .product_name = "SB-0500",
48                 .ifnum = QUIRK_NO_INTERFACE
49         }
50 },
51
52 /* Creative/E-Mu devices */
53 {
54         USB_DEVICE(0x041e, 0x3010),
55         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
56                 .vendor_name = "Creative Labs",
57                 .product_name = "Sound Blaster MP3+",
58                 .ifnum = QUIRK_NO_INTERFACE
59         }
60 },
61 {
62         /* E-Mu 0202 USB */
63         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
64         .idVendor = 0x041e,
65         .idProduct = 0x3f02,
66         .bInterfaceClass = USB_CLASS_AUDIO,
67 },
68 {
69         /* E-Mu 0404 USB */
70         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
71         .idVendor = 0x041e,
72         .idProduct = 0x3f04,
73         .bInterfaceClass = USB_CLASS_AUDIO,
74 },
75 {
76         /* E-Mu Tracker Pre */
77         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
78         .idVendor = 0x041e,
79         .idProduct = 0x3f0a,
80         .bInterfaceClass = USB_CLASS_AUDIO,
81 },
82 {
83         /* E-Mu 0204 USB */
84         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
85         .idVendor = 0x041e,
86         .idProduct = 0x3f19,
87         .bInterfaceClass = USB_CLASS_AUDIO,
88 },
89
90 /*
91  * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
92  * class matches do not take effect without an explicit ID match.
93  */
94 {
95         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
96                        USB_DEVICE_ID_MATCH_INT_CLASS |
97                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
98         .idVendor = 0x046d,
99         .idProduct = 0x0850,
100         .bInterfaceClass = USB_CLASS_AUDIO,
101         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
102 },
103 {
104         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
105                        USB_DEVICE_ID_MATCH_INT_CLASS |
106                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
107         .idVendor = 0x046d,
108         .idProduct = 0x08ae,
109         .bInterfaceClass = USB_CLASS_AUDIO,
110         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
111 },
112 {
113         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
114                        USB_DEVICE_ID_MATCH_INT_CLASS |
115                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
116         .idVendor = 0x046d,
117         .idProduct = 0x08c6,
118         .bInterfaceClass = USB_CLASS_AUDIO,
119         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
120 },
121 {
122         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
123                        USB_DEVICE_ID_MATCH_INT_CLASS |
124                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
125         .idVendor = 0x046d,
126         .idProduct = 0x08f0,
127         .bInterfaceClass = USB_CLASS_AUDIO,
128         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
129 },
130 {
131         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
132                        USB_DEVICE_ID_MATCH_INT_CLASS |
133                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
134         .idVendor = 0x046d,
135         .idProduct = 0x08f5,
136         .bInterfaceClass = USB_CLASS_AUDIO,
137         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
138 },
139 {
140         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
141                        USB_DEVICE_ID_MATCH_INT_CLASS |
142                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
143         .idVendor = 0x046d,
144         .idProduct = 0x08f6,
145         .bInterfaceClass = USB_CLASS_AUDIO,
146         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
147 },
148 {
149         USB_DEVICE(0x046d, 0x0990),
150         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
151                 .vendor_name = "Logitech, Inc.",
152                 .product_name = "QuickCam Pro 9000",
153                 .ifnum = QUIRK_NO_INTERFACE
154         }
155 },
156
157 /*
158  * Yamaha devices
159  */
160
161 #define YAMAHA_DEVICE(id, name) { \
162         USB_DEVICE(0x0499, id), \
163         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
164                 .vendor_name = "Yamaha", \
165                 .product_name = name, \
166                 .ifnum = QUIRK_ANY_INTERFACE, \
167                 .type = QUIRK_MIDI_YAMAHA \
168         } \
169 }
170 #define YAMAHA_INTERFACE(id, intf, name) { \
171         USB_DEVICE_VENDOR_SPEC(0x0499, id), \
172         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
173                 .vendor_name = "Yamaha", \
174                 .product_name = name, \
175                 .ifnum = intf, \
176                 .type = QUIRK_MIDI_YAMAHA \
177         } \
178 }
179 YAMAHA_DEVICE(0x1000, "UX256"),
180 YAMAHA_DEVICE(0x1001, "MU1000"),
181 YAMAHA_DEVICE(0x1002, "MU2000"),
182 YAMAHA_DEVICE(0x1003, "MU500"),
183 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
184 YAMAHA_DEVICE(0x1005, "MOTIF6"),
185 YAMAHA_DEVICE(0x1006, "MOTIF7"),
186 YAMAHA_DEVICE(0x1007, "MOTIF8"),
187 YAMAHA_DEVICE(0x1008, "UX96"),
188 YAMAHA_DEVICE(0x1009, "UX16"),
189 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
190 YAMAHA_DEVICE(0x100c, "UC-MX"),
191 YAMAHA_DEVICE(0x100d, "UC-KX"),
192 YAMAHA_DEVICE(0x100e, "S08"),
193 YAMAHA_DEVICE(0x100f, "CLP-150"),
194 YAMAHA_DEVICE(0x1010, "CLP-170"),
195 YAMAHA_DEVICE(0x1011, "P-250"),
196 YAMAHA_DEVICE(0x1012, "TYROS"),
197 YAMAHA_DEVICE(0x1013, "PF-500"),
198 YAMAHA_DEVICE(0x1014, "S90"),
199 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
200 YAMAHA_DEVICE(0x1016, "MDP-5"),
201 YAMAHA_DEVICE(0x1017, "CVP-204"),
202 YAMAHA_DEVICE(0x1018, "CVP-206"),
203 YAMAHA_DEVICE(0x1019, "CVP-208"),
204 YAMAHA_DEVICE(0x101a, "CVP-210"),
205 YAMAHA_DEVICE(0x101b, "PSR-1100"),
206 YAMAHA_DEVICE(0x101c, "PSR-2100"),
207 YAMAHA_DEVICE(0x101d, "CLP-175"),
208 YAMAHA_DEVICE(0x101e, "PSR-K1"),
209 YAMAHA_DEVICE(0x101f, "EZ-J24"),
210 YAMAHA_DEVICE(0x1020, "EZ-250i"),
211 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
212 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
213 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
214 YAMAHA_DEVICE(0x1024, "CVP-301"),
215 YAMAHA_DEVICE(0x1025, "CVP-303"),
216 YAMAHA_DEVICE(0x1026, "CVP-305"),
217 YAMAHA_DEVICE(0x1027, "CVP-307"),
218 YAMAHA_DEVICE(0x1028, "CVP-309"),
219 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
220 YAMAHA_DEVICE(0x102a, "PSR-1500"),
221 YAMAHA_DEVICE(0x102b, "PSR-3000"),
222 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
223 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
224 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
225 YAMAHA_DEVICE(0x1032, "DGX-305"),
226 YAMAHA_DEVICE(0x1033, "DGX-505"),
227 YAMAHA_DEVICE(0x1034, NULL),
228 YAMAHA_DEVICE(0x1035, NULL),
229 YAMAHA_DEVICE(0x1036, NULL),
230 YAMAHA_DEVICE(0x1037, NULL),
231 YAMAHA_DEVICE(0x1038, NULL),
232 YAMAHA_DEVICE(0x1039, NULL),
233 YAMAHA_DEVICE(0x103a, NULL),
234 YAMAHA_DEVICE(0x103b, NULL),
235 YAMAHA_DEVICE(0x103c, NULL),
236 YAMAHA_DEVICE(0x103d, NULL),
237 YAMAHA_DEVICE(0x103e, NULL),
238 YAMAHA_DEVICE(0x103f, NULL),
239 YAMAHA_DEVICE(0x1040, NULL),
240 YAMAHA_DEVICE(0x1041, NULL),
241 YAMAHA_DEVICE(0x1042, NULL),
242 YAMAHA_DEVICE(0x1043, NULL),
243 YAMAHA_DEVICE(0x1044, NULL),
244 YAMAHA_DEVICE(0x1045, NULL),
245 YAMAHA_INTERFACE(0x104e, 0, NULL),
246 YAMAHA_DEVICE(0x104f, NULL),
247 YAMAHA_DEVICE(0x1050, NULL),
248 YAMAHA_DEVICE(0x1051, NULL),
249 YAMAHA_DEVICE(0x1052, NULL),
250 YAMAHA_INTERFACE(0x1053, 0, NULL),
251 YAMAHA_INTERFACE(0x1054, 0, NULL),
252 YAMAHA_DEVICE(0x1055, NULL),
253 YAMAHA_DEVICE(0x1056, NULL),
254 YAMAHA_DEVICE(0x1057, NULL),
255 YAMAHA_DEVICE(0x1058, NULL),
256 YAMAHA_DEVICE(0x1059, NULL),
257 YAMAHA_DEVICE(0x105a, NULL),
258 YAMAHA_DEVICE(0x105b, NULL),
259 YAMAHA_DEVICE(0x105c, NULL),
260 YAMAHA_DEVICE(0x105d, NULL),
261 YAMAHA_DEVICE(0x2000, "DGP-7"),
262 YAMAHA_DEVICE(0x2001, "DGP-5"),
263 YAMAHA_DEVICE(0x2002, NULL),
264 YAMAHA_DEVICE(0x2003, NULL),
265 YAMAHA_DEVICE(0x5000, "CS1D"),
266 YAMAHA_DEVICE(0x5001, "DSP1D"),
267 YAMAHA_DEVICE(0x5002, "DME32"),
268 YAMAHA_DEVICE(0x5003, "DM2000"),
269 YAMAHA_DEVICE(0x5004, "02R96"),
270 YAMAHA_DEVICE(0x5005, "ACU16-C"),
271 YAMAHA_DEVICE(0x5006, "NHB32-C"),
272 YAMAHA_DEVICE(0x5007, "DM1000"),
273 YAMAHA_DEVICE(0x5008, "01V96"),
274 YAMAHA_DEVICE(0x5009, "SPX2000"),
275 YAMAHA_DEVICE(0x500a, "PM5D"),
276 YAMAHA_DEVICE(0x500b, "DME64N"),
277 YAMAHA_DEVICE(0x500c, "DME24N"),
278 YAMAHA_DEVICE(0x500d, NULL),
279 YAMAHA_DEVICE(0x500e, NULL),
280 YAMAHA_DEVICE(0x500f, NULL),
281 YAMAHA_DEVICE(0x7000, "DTX"),
282 YAMAHA_DEVICE(0x7010, "UB99"),
283 #undef YAMAHA_DEVICE
284 #undef YAMAHA_INTERFACE
285
286 /*
287  * Roland/RolandED/Edirol/BOSS devices
288  */
289 {
290         USB_DEVICE(0x0582, 0x0000),
291         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
292                 .vendor_name = "Roland",
293                 .product_name = "UA-100",
294                 .ifnum = QUIRK_ANY_INTERFACE,
295                 .type = QUIRK_COMPOSITE,
296                 .data = (const struct snd_usb_audio_quirk[]) {
297                         {
298                                 .ifnum = 0,
299                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
300                                 .data = & (const struct audioformat) {
301                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
302                                         .channels = 4,
303                                         .iface = 0,
304                                         .altsetting = 1,
305                                         .altset_idx = 1,
306                                         .attributes = 0,
307                                         .endpoint = 0x01,
308                                         .ep_attr = 0x09,
309                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
310                                         .rate_min = 44100,
311                                         .rate_max = 44100,
312                                 }
313                         },
314                         {
315                                 .ifnum = 1,
316                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
317                                 .data = & (const struct audioformat) {
318                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
319                                         .channels = 2,
320                                         .iface = 1,
321                                         .altsetting = 1,
322                                         .altset_idx = 1,
323                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX,
324                                         .endpoint = 0x81,
325                                         .ep_attr = 0x05,
326                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
327                                         .rate_min = 44100,
328                                         .rate_max = 44100,
329                                 }
330                         },
331                         {
332                                 .ifnum = 2,
333                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
334                                 .data = & (const struct snd_usb_midi_endpoint_info) {
335                                         .out_cables = 0x0007,
336                                         .in_cables  = 0x0007
337                                 }
338                         },
339                         {
340                                 .ifnum = -1
341                         }
342                 }
343         }
344 },
345 {
346         USB_DEVICE(0x0582, 0x0002),
347         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
348                 .vendor_name = "EDIROL",
349                 .product_name = "UM-4",
350                 .ifnum = QUIRK_ANY_INTERFACE,
351                 .type = QUIRK_COMPOSITE,
352                 .data = (const struct snd_usb_audio_quirk[]) {
353                         {
354                                 .ifnum = 0,
355                                 .type = QUIRK_IGNORE_INTERFACE
356                         },
357                         {
358                                 .ifnum = 1,
359                                 .type = QUIRK_IGNORE_INTERFACE
360                         },
361                         {
362                                 .ifnum = 2,
363                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
364                                 .data = & (const struct snd_usb_midi_endpoint_info) {
365                                         .out_cables = 0x000f,
366                                         .in_cables  = 0x000f
367                                 }
368                         },
369                         {
370                                 .ifnum = -1
371                         }
372                 }
373         }
374 },
375 {
376         USB_DEVICE(0x0582, 0x0003),
377         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
378                 .vendor_name = "Roland",
379                 .product_name = "SC-8850",
380                 .ifnum = QUIRK_ANY_INTERFACE,
381                 .type = QUIRK_COMPOSITE,
382                 .data = (const struct snd_usb_audio_quirk[]) {
383                         {
384                                 .ifnum = 0,
385                                 .type = QUIRK_IGNORE_INTERFACE
386                         },
387                         {
388                                 .ifnum = 1,
389                                 .type = QUIRK_IGNORE_INTERFACE
390                         },
391                         {
392                                 .ifnum = 2,
393                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
394                                 .data = & (const struct snd_usb_midi_endpoint_info) {
395                                         .out_cables = 0x003f,
396                                         .in_cables  = 0x003f
397                                 }
398                         },
399                         {
400                                 .ifnum = -1
401                         }
402                 }
403         }
404 },
405 {
406         USB_DEVICE(0x0582, 0x0004),
407         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
408                 .vendor_name = "Roland",
409                 .product_name = "U-8",
410                 .ifnum = QUIRK_ANY_INTERFACE,
411                 .type = QUIRK_COMPOSITE,
412                 .data = (const struct snd_usb_audio_quirk[]) {
413                         {
414                                 .ifnum = 0,
415                                 .type = QUIRK_IGNORE_INTERFACE
416                         },
417                         {
418                                 .ifnum = 1,
419                                 .type = QUIRK_IGNORE_INTERFACE
420                         },
421                         {
422                                 .ifnum = 2,
423                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
424                                 .data = & (const struct snd_usb_midi_endpoint_info) {
425                                         .out_cables = 0x0005,
426                                         .in_cables  = 0x0005
427                                 }
428                         },
429                         {
430                                 .ifnum = -1
431                         }
432                 }
433         }
434 },
435 {
436         /* Has ID 0x0099 when not in "Advanced Driver" mode.
437          * The UM-2EX has only one input, but we cannot detect this. */
438         USB_DEVICE(0x0582, 0x0005),
439         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
440                 .vendor_name = "EDIROL",
441                 .product_name = "UM-2",
442                 .ifnum = QUIRK_ANY_INTERFACE,
443                 .type = QUIRK_COMPOSITE,
444                 .data = (const struct snd_usb_audio_quirk[]) {
445                         {
446                                 .ifnum = 0,
447                                 .type = QUIRK_IGNORE_INTERFACE
448                         },
449                         {
450                                 .ifnum = 1,
451                                 .type = QUIRK_IGNORE_INTERFACE
452                         },
453                         {
454                                 .ifnum = 2,
455                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
456                                 .data = & (const struct snd_usb_midi_endpoint_info) {
457                                         .out_cables = 0x0003,
458                                         .in_cables  = 0x0003
459                                 }
460                         },
461                         {
462                                 .ifnum = -1
463                         }
464                 }
465         }
466 },
467 {
468         USB_DEVICE(0x0582, 0x0007),
469         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
470                 .vendor_name = "Roland",
471                 .product_name = "SC-8820",
472                 .ifnum = QUIRK_ANY_INTERFACE,
473                 .type = QUIRK_COMPOSITE,
474                 .data = (const struct snd_usb_audio_quirk[]) {
475                         {
476                                 .ifnum = 0,
477                                 .type = QUIRK_IGNORE_INTERFACE
478                         },
479                         {
480                                 .ifnum = 1,
481                                 .type = QUIRK_IGNORE_INTERFACE
482                         },
483                         {
484                                 .ifnum = 2,
485                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
486                                 .data = & (const struct snd_usb_midi_endpoint_info) {
487                                         .out_cables = 0x0013,
488                                         .in_cables  = 0x0013
489                                 }
490                         },
491                         {
492                                 .ifnum = -1
493                         }
494                 }
495         }
496 },
497 {
498         USB_DEVICE(0x0582, 0x0008),
499         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
500                 .vendor_name = "Roland",
501                 .product_name = "PC-300",
502                 .ifnum = QUIRK_ANY_INTERFACE,
503                 .type = QUIRK_COMPOSITE,
504                 .data = (const struct snd_usb_audio_quirk[]) {
505                         {
506                                 .ifnum = 0,
507                                 .type = QUIRK_IGNORE_INTERFACE
508                         },
509                         {
510                                 .ifnum = 1,
511                                 .type = QUIRK_IGNORE_INTERFACE
512                         },
513                         {
514                                 .ifnum = 2,
515                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
516                                 .data = & (const struct snd_usb_midi_endpoint_info) {
517                                         .out_cables = 0x0001,
518                                         .in_cables  = 0x0001
519                                 }
520                         },
521                         {
522                                 .ifnum = -1
523                         }
524                 }
525         }
526 },
527 {
528         /* has ID 0x009d when not in "Advanced Driver" mode */
529         USB_DEVICE(0x0582, 0x0009),
530         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
531                 .vendor_name = "EDIROL",
532                 .product_name = "UM-1",
533                 .ifnum = QUIRK_ANY_INTERFACE,
534                 .type = QUIRK_COMPOSITE,
535                 .data = (const struct snd_usb_audio_quirk[]) {
536                         {
537                                 .ifnum = 0,
538                                 .type = QUIRK_IGNORE_INTERFACE
539                         },
540                         {
541                                 .ifnum = 1,
542                                 .type = QUIRK_IGNORE_INTERFACE
543                         },
544                         {
545                                 .ifnum = 2,
546                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
547                                 .data = & (const struct snd_usb_midi_endpoint_info) {
548                                         .out_cables = 0x0001,
549                                         .in_cables  = 0x0001
550                                 }
551                         },
552                         {
553                                 .ifnum = -1
554                         }
555                 }
556         }
557 },
558 {
559         USB_DEVICE(0x0582, 0x000b),
560         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
561                 .vendor_name = "Roland",
562                 .product_name = "SK-500",
563                 .ifnum = QUIRK_ANY_INTERFACE,
564                 .type = QUIRK_COMPOSITE,
565                 .data = (const struct snd_usb_audio_quirk[]) {
566                         {
567                                 .ifnum = 0,
568                                 .type = QUIRK_IGNORE_INTERFACE
569                         },
570                         {
571                                 .ifnum = 1,
572                                 .type = QUIRK_IGNORE_INTERFACE
573                         },
574                         {
575                                 .ifnum = 2,
576                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
577                                 .data = & (const struct snd_usb_midi_endpoint_info) {
578                                         .out_cables = 0x0013,
579                                         .in_cables  = 0x0013
580                                 }
581                         },
582                         {
583                                 .ifnum = -1
584                         }
585                 }
586         }
587 },
588 {
589         /* thanks to Emiliano Grilli <emillo@libero.it>
590          * for helping researching this data */
591         USB_DEVICE(0x0582, 0x000c),
592         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
593                 .vendor_name = "Roland",
594                 .product_name = "SC-D70",
595                 .ifnum = QUIRK_ANY_INTERFACE,
596                 .type = QUIRK_COMPOSITE,
597                 .data = (const struct snd_usb_audio_quirk[]) {
598                         {
599                                 .ifnum = 0,
600                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
601                                 .data = & (const struct audioformat) {
602                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
603                                         .channels = 2,
604                                         .iface = 0,
605                                         .altsetting = 1,
606                                         .altset_idx = 1,
607                                         .attributes = 0,
608                                         .endpoint = 0x01,
609                                         .ep_attr = 0x01,
610                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
611                                         .rate_min = 44100,
612                                         .rate_max = 44100,
613                                 }
614                         },
615                         {
616                                 .ifnum = 1,
617                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
618                                 .data = & (const struct audioformat) {
619                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
620                                         .channels = 2,
621                                         .iface = 1,
622                                         .altsetting = 1,
623                                         .altset_idx = 1,
624                                         .attributes = 0,
625                                         .endpoint = 0x81,
626                                         .ep_attr = 0x01,
627                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
628                                         .rate_min = 44100,
629                                         .rate_max = 44100,
630                                 }
631                         },
632                         {
633                                 .ifnum = 2,
634                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
635                                 .data = & (const struct snd_usb_midi_endpoint_info) {
636                                         .out_cables = 0x0007,
637                                         .in_cables  = 0x0007
638                                 }
639                         },
640                         {
641                                 .ifnum = -1
642                         }
643                 }
644         }
645 },
646 {       /*
647          * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
648          * If the advanced mode switch at the back of the unit is off, the
649          * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
650          * but offers only 16-bit PCM.
651          * In advanced mode, the UA-5 will output S24_3LE samples (two
652          * channels) at the rate indicated on the front switch, including
653          * the 96kHz sample rate.
654          */
655         USB_DEVICE(0x0582, 0x0010),
656         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
657                 .vendor_name = "EDIROL",
658                 .product_name = "UA-5",
659                 .ifnum = QUIRK_ANY_INTERFACE,
660                 .type = QUIRK_COMPOSITE,
661                 .data = (const struct snd_usb_audio_quirk[]) {
662                         {
663                                 .ifnum = 1,
664                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
665                         },
666                         {
667                                 .ifnum = 2,
668                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
669                         },
670                         {
671                                 .ifnum = -1
672                         }
673                 }
674         }
675 },
676 {
677         /* has ID 0x0013 when not in "Advanced Driver" mode */
678         USB_DEVICE(0x0582, 0x0012),
679         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
680                 .vendor_name = "Roland",
681                 .product_name = "XV-5050",
682                 .ifnum = 0,
683                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
684                 .data = & (const struct snd_usb_midi_endpoint_info) {
685                         .out_cables = 0x0001,
686                         .in_cables  = 0x0001
687                 }
688         }
689 },
690 {
691         /* has ID 0x0015 when not in "Advanced Driver" mode */
692         USB_DEVICE(0x0582, 0x0014),
693         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
694                 .vendor_name = "EDIROL",
695                 .product_name = "UM-880",
696                 .ifnum = 0,
697                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
698                 .data = & (const struct snd_usb_midi_endpoint_info) {
699                         .out_cables = 0x01ff,
700                         .in_cables  = 0x01ff
701                 }
702         }
703 },
704 {
705         /* has ID 0x0017 when not in "Advanced Driver" mode */
706         USB_DEVICE(0x0582, 0x0016),
707         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
708                 .vendor_name = "EDIROL",
709                 .product_name = "SD-90",
710                 .ifnum = QUIRK_ANY_INTERFACE,
711                 .type = QUIRK_COMPOSITE,
712                 .data = (const struct snd_usb_audio_quirk[]) {
713                         {
714                                 .ifnum = 0,
715                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
716                         },
717                         {
718                                 .ifnum = 1,
719                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
720                         },
721                         {
722                                 .ifnum = 2,
723                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
724                                 .data = & (const struct snd_usb_midi_endpoint_info) {
725                                         .out_cables = 0x000f,
726                                         .in_cables  = 0x000f
727                                 }
728                         },
729                         {
730                                 .ifnum = -1
731                         }
732                 }
733         }
734 },
735 {
736         /* has ID 0x001c when not in "Advanced Driver" mode */
737         USB_DEVICE(0x0582, 0x001b),
738         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
739                 .vendor_name = "Roland",
740                 .product_name = "MMP-2",
741                 .ifnum = QUIRK_ANY_INTERFACE,
742                 .type = QUIRK_COMPOSITE,
743                 .data = (const struct snd_usb_audio_quirk[]) {
744                         {
745                                 .ifnum = 0,
746                                 .type = QUIRK_IGNORE_INTERFACE
747                         },
748                         {
749                                 .ifnum = 1,
750                                 .type = QUIRK_IGNORE_INTERFACE
751                         },
752                         {
753                                 .ifnum = 2,
754                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
755                                 .data = & (const struct snd_usb_midi_endpoint_info) {
756                                         .out_cables = 0x0001,
757                                         .in_cables  = 0x0001
758                                 }
759                         },
760                         {
761                                 .ifnum = -1
762                         }
763                 }
764         }
765 },
766 {
767         /* has ID 0x001e when not in "Advanced Driver" mode */
768         USB_DEVICE(0x0582, 0x001d),
769         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
770                 .vendor_name = "Roland",
771                 .product_name = "V-SYNTH",
772                 .ifnum = 0,
773                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
774                 .data = & (const struct snd_usb_midi_endpoint_info) {
775                         .out_cables = 0x0001,
776                         .in_cables  = 0x0001
777                 }
778         }
779 },
780 {
781         /* has ID 0x0024 when not in "Advanced Driver" mode */
782         USB_DEVICE(0x0582, 0x0023),
783         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
784                 .vendor_name = "EDIROL",
785                 .product_name = "UM-550",
786                 .ifnum = 0,
787                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
788                 .data = & (const struct snd_usb_midi_endpoint_info) {
789                         .out_cables = 0x003f,
790                         .in_cables  = 0x003f
791                 }
792         }
793 },
794 {
795         /*
796          * This quirk is for the "Advanced Driver" mode. If off, the UA-20
797          * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
798          * and no MIDI.
799          */
800         USB_DEVICE(0x0582, 0x0025),
801         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
802                 .vendor_name = "EDIROL",
803                 .product_name = "UA-20",
804                 .ifnum = QUIRK_ANY_INTERFACE,
805                 .type = QUIRK_COMPOSITE,
806                 .data = (const struct snd_usb_audio_quirk[]) {
807                         {
808                                 .ifnum = 0,
809                                 .type = QUIRK_IGNORE_INTERFACE
810                         },
811                         {
812                                 .ifnum = 1,
813                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
814                                 .data = & (const struct audioformat) {
815                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
816                                         .channels = 2,
817                                         .iface = 1,
818                                         .altsetting = 1,
819                                         .altset_idx = 1,
820                                         .attributes = 0,
821                                         .endpoint = 0x01,
822                                         .ep_attr = 0x01,
823                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
824                                         .rate_min = 44100,
825                                         .rate_max = 44100,
826                                 }
827                         },
828                         {
829                                 .ifnum = 2,
830                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
831                                 .data = & (const struct audioformat) {
832                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
833                                         .channels = 2,
834                                         .iface = 2,
835                                         .altsetting = 1,
836                                         .altset_idx = 1,
837                                         .attributes = 0,
838                                         .endpoint = 0x82,
839                                         .ep_attr = 0x01,
840                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
841                                         .rate_min = 44100,
842                                         .rate_max = 44100,
843                                 }
844                         },
845                         {
846                                 .ifnum = 3,
847                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
848                                 .data = & (const struct snd_usb_midi_endpoint_info) {
849                                         .out_cables = 0x0001,
850                                         .in_cables  = 0x0001
851                                 }
852                         },
853                         {
854                                 .ifnum = -1
855                         }
856                 }
857         }
858 },
859 {
860         /* has ID 0x0028 when not in "Advanced Driver" mode */
861         USB_DEVICE(0x0582, 0x0027),
862         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
863                 .vendor_name = "EDIROL",
864                 .product_name = "SD-20",
865                 .ifnum = 0,
866                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
867                 .data = & (const struct snd_usb_midi_endpoint_info) {
868                         .out_cables = 0x0003,
869                         .in_cables  = 0x0007
870                 }
871         }
872 },
873 {
874         /* has ID 0x002a when not in "Advanced Driver" mode */
875         USB_DEVICE(0x0582, 0x0029),
876         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
877                 .vendor_name = "EDIROL",
878                 .product_name = "SD-80",
879                 .ifnum = 0,
880                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
881                 .data = & (const struct snd_usb_midi_endpoint_info) {
882                         .out_cables = 0x000f,
883                         .in_cables  = 0x000f
884                 }
885         }
886 },
887 {       /*
888          * This quirk is for the "Advanced" modes of the Edirol UA-700.
889          * If the sample format switch is not in an advanced setting, the
890          * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
891          * but offers only 16-bit PCM and no MIDI.
892          */
893         USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
894         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
895                 .vendor_name = "EDIROL",
896                 .product_name = "UA-700",
897                 .ifnum = QUIRK_ANY_INTERFACE,
898                 .type = QUIRK_COMPOSITE,
899                 .data = (const struct snd_usb_audio_quirk[]) {
900                         {
901                                 .ifnum = 1,
902                                 .type = QUIRK_AUDIO_EDIROL_UAXX
903                         },
904                         {
905                                 .ifnum = 2,
906                                 .type = QUIRK_AUDIO_EDIROL_UAXX
907                         },
908                         {
909                                 .ifnum = 3,
910                                 .type = QUIRK_AUDIO_EDIROL_UAXX
911                         },
912                         {
913                                 .ifnum = -1
914                         }
915                 }
916         }
917 },
918 {
919         /* has ID 0x002e when not in "Advanced Driver" mode */
920         USB_DEVICE(0x0582, 0x002d),
921         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
922                 .vendor_name = "Roland",
923                 .product_name = "XV-2020",
924                 .ifnum = 0,
925                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
926                 .data = & (const struct snd_usb_midi_endpoint_info) {
927                         .out_cables = 0x0001,
928                         .in_cables  = 0x0001
929                 }
930         }
931 },
932 {
933         /* has ID 0x0030 when not in "Advanced Driver" mode */
934         USB_DEVICE(0x0582, 0x002f),
935         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
936                 .vendor_name = "Roland",
937                 .product_name = "VariOS",
938                 .ifnum = 0,
939                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
940                 .data = & (const struct snd_usb_midi_endpoint_info) {
941                         .out_cables = 0x0007,
942                         .in_cables  = 0x0007
943                 }
944         }
945 },
946 {
947         /* has ID 0x0034 when not in "Advanced Driver" mode */
948         USB_DEVICE(0x0582, 0x0033),
949         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
950                 .vendor_name = "EDIROL",
951                 .product_name = "PCR",
952                 .ifnum = 0,
953                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
954                 .data = & (const struct snd_usb_midi_endpoint_info) {
955                         .out_cables = 0x0003,
956                         .in_cables  = 0x0007
957                 }
958         }
959 },
960         /* TODO: add Roland M-1000 support */
961 {
962         /*
963          * Has ID 0x0038 when not in "Advanced Driver" mode;
964          * later revisions use IDs 0x0054 and 0x00a2.
965          */
966         USB_DEVICE(0x0582, 0x0037),
967         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
968                 .vendor_name = "Roland",
969                 .product_name = "Digital Piano",
970                 .ifnum = 0,
971                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
972                 .data = & (const struct snd_usb_midi_endpoint_info) {
973                         .out_cables = 0x0001,
974                         .in_cables  = 0x0001
975                 }
976         }
977 },
978 {
979         /*
980          * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
981          * has ID 0x003c and is standard compliant, but has only 16-bit PCM
982          * and no MIDI.
983          */
984         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
985         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
986                 .vendor_name = "BOSS",
987                 .product_name = "GS-10",
988                 .ifnum = QUIRK_ANY_INTERFACE,
989                 .type = QUIRK_COMPOSITE,
990                 .data = & (const struct snd_usb_audio_quirk[]) {
991                         {
992                                 .ifnum = 1,
993                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
994                         },
995                         {
996                                 .ifnum = 2,
997                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
998                         },
999                         {
1000                                 .ifnum = 3,
1001                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1002                         },
1003                         {
1004                                 .ifnum = -1
1005                         }
1006                 }
1007         }
1008 },
1009 {
1010         /* has ID 0x0041 when not in "Advanced Driver" mode */
1011         USB_DEVICE(0x0582, 0x0040),
1012         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1013                 .vendor_name = "Roland",
1014                 .product_name = "GI-20",
1015                 .ifnum = 0,
1016                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1017                 .data = & (const struct snd_usb_midi_endpoint_info) {
1018                         .out_cables = 0x0001,
1019                         .in_cables  = 0x0001
1020                 }
1021         }
1022 },
1023 {
1024         /* has ID 0x0043 when not in "Advanced Driver" mode */
1025         USB_DEVICE(0x0582, 0x0042),
1026         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1027                 .vendor_name = "Roland",
1028                 .product_name = "RS-70",
1029                 .ifnum = 0,
1030                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1031                 .data = & (const struct snd_usb_midi_endpoint_info) {
1032                         .out_cables = 0x0001,
1033                         .in_cables  = 0x0001
1034                 }
1035         }
1036 },
1037 {
1038         /* has ID 0x0049 when not in "Advanced Driver" mode */
1039         USB_DEVICE(0x0582, 0x0047),
1040         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1041                 /* .vendor_name = "EDIROL", */
1042                 /* .product_name = "UR-80", */
1043                 .ifnum = QUIRK_ANY_INTERFACE,
1044                 .type = QUIRK_COMPOSITE,
1045                 .data = (const struct snd_usb_audio_quirk[]) {
1046                         /* in the 96 kHz modes, only interface 1 is there */
1047                         {
1048                                 .ifnum = 1,
1049                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1050                         },
1051                         {
1052                                 .ifnum = 2,
1053                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1054                         },
1055                         {
1056                                 .ifnum = -1
1057                         }
1058                 }
1059         }
1060 },
1061 {
1062         /* has ID 0x004a when not in "Advanced Driver" mode */
1063         USB_DEVICE(0x0582, 0x0048),
1064         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1065                 /* .vendor_name = "EDIROL", */
1066                 /* .product_name = "UR-80", */
1067                 .ifnum = 0,
1068                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1069                 .data = & (const struct snd_usb_midi_endpoint_info) {
1070                         .out_cables = 0x0003,
1071                         .in_cables  = 0x0007
1072                 }
1073         }
1074 },
1075         /* TODO: add Edirol M-100FX support */
1076 {
1077         /* has ID 0x004e when not in "Advanced Driver" mode */
1078         USB_DEVICE(0x0582, 0x004c),
1079         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1080                 .vendor_name = "EDIROL",
1081                 .product_name = "PCR-A",
1082                 .ifnum = QUIRK_ANY_INTERFACE,
1083                 .type = QUIRK_COMPOSITE,
1084                 .data = (const struct snd_usb_audio_quirk[]) {
1085                         {
1086                                 .ifnum = 1,
1087                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1088                         },
1089                         {
1090                                 .ifnum = 2,
1091                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1092                         },
1093                         {
1094                                 .ifnum = -1
1095                         }
1096                 }
1097         }
1098 },
1099 {
1100         /* has ID 0x004f when not in "Advanced Driver" mode */
1101         USB_DEVICE(0x0582, 0x004d),
1102         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1103                 .vendor_name = "EDIROL",
1104                 .product_name = "PCR-A",
1105                 .ifnum = 0,
1106                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1107                 .data = & (const struct snd_usb_midi_endpoint_info) {
1108                         .out_cables = 0x0003,
1109                         .in_cables  = 0x0007
1110                 }
1111         }
1112 },
1113 {
1114         /*
1115          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1116          * is standard compliant, but has only 16-bit PCM.
1117          */
1118         USB_DEVICE(0x0582, 0x0050),
1119         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1120                 .vendor_name = "EDIROL",
1121                 .product_name = "UA-3FX",
1122                 .ifnum = QUIRK_ANY_INTERFACE,
1123                 .type = QUIRK_COMPOSITE,
1124                 .data = (const struct snd_usb_audio_quirk[]) {
1125                         {
1126                                 .ifnum = 1,
1127                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1128                         },
1129                         {
1130                                 .ifnum = 2,
1131                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1132                         },
1133                         {
1134                                 .ifnum = -1
1135                         }
1136                 }
1137         }
1138 },
1139 {
1140         USB_DEVICE(0x0582, 0x0052),
1141         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1142                 .vendor_name = "EDIROL",
1143                 .product_name = "UM-1SX",
1144                 .ifnum = 0,
1145                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1146         }
1147 },
1148 {
1149         USB_DEVICE(0x0582, 0x0060),
1150         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1151                 .vendor_name = "Roland",
1152                 .product_name = "EXR Series",
1153                 .ifnum = 0,
1154                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1155         }
1156 },
1157 {
1158         /* has ID 0x0066 when not in "Advanced Driver" mode */
1159         USB_DEVICE(0x0582, 0x0064),
1160         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1161                 /* .vendor_name = "EDIROL", */
1162                 /* .product_name = "PCR-1", */
1163                 .ifnum = QUIRK_ANY_INTERFACE,
1164                 .type = QUIRK_COMPOSITE,
1165                 .data = (const struct snd_usb_audio_quirk[]) {
1166                         {
1167                                 .ifnum = 1,
1168                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1169                         },
1170                         {
1171                                 .ifnum = 2,
1172                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1173                         },
1174                         {
1175                                 .ifnum = -1
1176                         }
1177                 }
1178         }
1179 },
1180 {
1181         /* has ID 0x0067 when not in "Advanced Driver" mode */
1182         USB_DEVICE(0x0582, 0x0065),
1183         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1184                 /* .vendor_name = "EDIROL", */
1185                 /* .product_name = "PCR-1", */
1186                 .ifnum = 0,
1187                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1188                 .data = & (const struct snd_usb_midi_endpoint_info) {
1189                         .out_cables = 0x0001,
1190                         .in_cables  = 0x0003
1191                 }
1192         }
1193 },
1194 {
1195         /* has ID 0x006b when not in "Advanced Driver" mode */
1196         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1197         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1198                 .vendor_name = "Roland",
1199                 .product_name = "SP-606",
1200                 .ifnum = 3,
1201                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1202                 .data = & (const struct snd_usb_midi_endpoint_info) {
1203                         .out_cables = 0x0001,
1204                         .in_cables  = 0x0001
1205                 }
1206         }
1207 },
1208 {
1209         /* has ID 0x006e when not in "Advanced Driver" mode */
1210         USB_DEVICE(0x0582, 0x006d),
1211         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1212                 .vendor_name = "Roland",
1213                 .product_name = "FANTOM-X",
1214                 .ifnum = 0,
1215                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1216                 .data = & (const struct snd_usb_midi_endpoint_info) {
1217                         .out_cables = 0x0001,
1218                         .in_cables  = 0x0001
1219                 }
1220         }
1221 },
1222 {       /*
1223          * This quirk is for the "Advanced" modes of the Edirol UA-25.
1224          * If the switch is not in an advanced setting, the UA-25 has
1225          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1226          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1227          */
1228         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1229         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1230                 .vendor_name = "EDIROL",
1231                 .product_name = "UA-25",
1232                 .ifnum = QUIRK_ANY_INTERFACE,
1233                 .type = QUIRK_COMPOSITE,
1234                 .data = (const struct snd_usb_audio_quirk[]) {
1235                         {
1236                                 .ifnum = 0,
1237                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1238                         },
1239                         {
1240                                 .ifnum = 1,
1241                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1242                         },
1243                         {
1244                                 .ifnum = 2,
1245                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1246                         },
1247                         {
1248                                 .ifnum = -1
1249                         }
1250                 }
1251         }
1252 },
1253 {
1254         /* has ID 0x0076 when not in "Advanced Driver" mode */
1255         USB_DEVICE(0x0582, 0x0075),
1256         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1257                 .vendor_name = "BOSS",
1258                 .product_name = "DR-880",
1259                 .ifnum = 0,
1260                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1261                 .data = & (const struct snd_usb_midi_endpoint_info) {
1262                         .out_cables = 0x0001,
1263                         .in_cables  = 0x0001
1264                 }
1265         }
1266 },
1267 {
1268         /* has ID 0x007b when not in "Advanced Driver" mode */
1269         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1270         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1271                 .vendor_name = "Roland",
1272                 /* "RD" or "RD-700SX"? */
1273                 .ifnum = 0,
1274                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1275                 .data = & (const struct snd_usb_midi_endpoint_info) {
1276                         .out_cables = 0x0003,
1277                         .in_cables  = 0x0003
1278                 }
1279         }
1280 },
1281 {
1282         /* has ID 0x0081 when not in "Advanced Driver" mode */
1283         USB_DEVICE(0x0582, 0x0080),
1284         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1285                 .vendor_name = "Roland",
1286                 .product_name = "G-70",
1287                 .ifnum = 0,
1288                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1289                 .data = & (const struct snd_usb_midi_endpoint_info) {
1290                         .out_cables = 0x0001,
1291                         .in_cables  = 0x0001
1292                 }
1293         }
1294 },
1295         /* TODO: add Roland V-SYNTH XT support */
1296         /* TODO: add BOSS GT-PRO support */
1297 {
1298         /* has ID 0x008c when not in "Advanced Driver" mode */
1299         USB_DEVICE(0x0582, 0x008b),
1300         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1301                 .vendor_name = "EDIROL",
1302                 .product_name = "PC-50",
1303                 .ifnum = 0,
1304                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1305                 .data = & (const struct snd_usb_midi_endpoint_info) {
1306                         .out_cables = 0x0001,
1307                         .in_cables  = 0x0001
1308                 }
1309         }
1310 },
1311         /* TODO: add Edirol PC-80 support */
1312 {
1313         USB_DEVICE(0x0582, 0x0096),
1314         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1315                 .vendor_name = "EDIROL",
1316                 .product_name = "UA-1EX",
1317                 .ifnum = QUIRK_ANY_INTERFACE,
1318                 .type = QUIRK_COMPOSITE,
1319                 .data = (const struct snd_usb_audio_quirk[]) {
1320                         {
1321                                 .ifnum = 0,
1322                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1323                         },
1324                         {
1325                                 .ifnum = 1,
1326                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1327                         },
1328                         {
1329                                 .ifnum = -1
1330                         }
1331                 }
1332         }
1333 },
1334 {
1335         USB_DEVICE(0x0582, 0x009a),
1336         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1337                 .vendor_name = "EDIROL",
1338                 .product_name = "UM-3EX",
1339                 .ifnum = 0,
1340                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1341                 .data = & (const struct snd_usb_midi_endpoint_info) {
1342                         .out_cables = 0x000f,
1343                         .in_cables  = 0x000f
1344                 }
1345         }
1346 },
1347 {
1348         /*
1349          * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1350          * is standard compliant, but has only 16-bit PCM and no MIDI.
1351          */
1352         USB_DEVICE(0x0582, 0x00a3),
1353         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1354                 .vendor_name = "EDIROL",
1355                 .product_name = "UA-4FX",
1356                 .ifnum = QUIRK_ANY_INTERFACE,
1357                 .type = QUIRK_COMPOSITE,
1358                 .data = (const struct snd_usb_audio_quirk[]) {
1359                         {
1360                                 .ifnum = 0,
1361                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1362                         },
1363                         {
1364                                 .ifnum = 1,
1365                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1366                         },
1367                         {
1368                                 .ifnum = 2,
1369                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1370                         },
1371                         {
1372                                 .ifnum = -1
1373                         }
1374                 }
1375         }
1376 },
1377         /* TODO: add Edirol MD-P1 support */
1378 {
1379         USB_DEVICE(0x582, 0x00a6),
1380         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1381                 .vendor_name = "Roland",
1382                 .product_name = "Juno-G",
1383                 .ifnum = 0,
1384                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1385                 .data = & (const struct snd_usb_midi_endpoint_info) {
1386                         .out_cables = 0x0001,
1387                         .in_cables  = 0x0001
1388                 }
1389         }
1390 },
1391 {
1392         /* Roland SH-201 */
1393         USB_DEVICE(0x0582, 0x00ad),
1394         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1395                 .vendor_name = "Roland",
1396                 .product_name = "SH-201",
1397                 .ifnum = QUIRK_ANY_INTERFACE,
1398                 .type = QUIRK_COMPOSITE,
1399                 .data = (const struct snd_usb_audio_quirk[]) {
1400                         {
1401                                 .ifnum = 0,
1402                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1403                         },
1404                         {
1405                                 .ifnum = 1,
1406                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1407                         },
1408                         {
1409                                 .ifnum = 2,
1410                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1411                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1412                                         .out_cables = 0x0001,
1413                                         .in_cables  = 0x0001
1414                                 }
1415                         },
1416                         {
1417                                 .ifnum = -1
1418                         }
1419                 }
1420         }
1421 },
1422 {
1423         /* Roland SonicCell */
1424         USB_DEVICE(0x0582, 0x00c2),
1425         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1426                 .vendor_name = "Roland",
1427                 .product_name = "SonicCell",
1428                 .ifnum = QUIRK_ANY_INTERFACE,
1429                 .type = QUIRK_COMPOSITE,
1430                 .data = (const struct snd_usb_audio_quirk[]) {
1431                         {
1432                                 .ifnum = 0,
1433                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1434                         },
1435                         {
1436                                 .ifnum = 1,
1437                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1438                         },
1439                         {
1440                                 .ifnum = 2,
1441                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1442                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1443                                         .out_cables = 0x0001,
1444                                         .in_cables  = 0x0001
1445                                 }
1446                         },
1447                         {
1448                                 .ifnum = -1
1449                         }
1450                 }
1451         }
1452 },
1453 {
1454         /* Edirol M-16DX */
1455         /* FIXME: This quirk gives a good-working capture stream but the
1456          *        playback seems problematic because of lacking of sync
1457          *        with capture stream.  It needs to sync with the capture
1458          *        clock.  As now, you'll get frequent sound distortions
1459          *        via the playback.
1460          */
1461         USB_DEVICE(0x0582, 0x00c4),
1462         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1463                 .ifnum = QUIRK_ANY_INTERFACE,
1464                 .type = QUIRK_COMPOSITE,
1465                 .data = (const struct snd_usb_audio_quirk[]) {
1466                         {
1467                                 .ifnum = 0,
1468                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1469                         },
1470                         {
1471                                 .ifnum = 1,
1472                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1473                         },
1474                         {
1475                                 .ifnum = 2,
1476                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1477                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1478                                         .out_cables = 0x0001,
1479                                         .in_cables  = 0x0001
1480                                 }
1481                         },
1482                         {
1483                                 .ifnum = -1
1484                         }
1485                 }
1486         }
1487 },
1488 {
1489         /* BOSS GT-10 */
1490         USB_DEVICE(0x0582, 0x00da),
1491         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1492                 .ifnum = QUIRK_ANY_INTERFACE,
1493                 .type = QUIRK_COMPOSITE,
1494                 .data = (const struct snd_usb_audio_quirk[]) {
1495                         {
1496                                 .ifnum = 0,
1497                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1498                         },
1499                         {
1500                                 .ifnum = 1,
1501                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1502                         },
1503                         {
1504                                 .ifnum = 2,
1505                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1506                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1507                                         .out_cables = 0x0001,
1508                                         .in_cables  = 0x0001
1509                                 }
1510                         },
1511                         {
1512                                 .ifnum = -1
1513                         }
1514                 }
1515         }
1516 },
1517 {
1518         /* Advanced modes of the Edirol UA-25EX.
1519          * For the standard mode, UA-25EX has ID 0582:00e7, which
1520          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1521          */
1522         USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1523         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1524                 .vendor_name = "EDIROL",
1525                 .product_name = "UA-25EX",
1526                 .ifnum = QUIRK_ANY_INTERFACE,
1527                 .type = QUIRK_COMPOSITE,
1528                 .data = (const struct snd_usb_audio_quirk[]) {
1529                         {
1530                                 .ifnum = 0,
1531                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1532                         },
1533                         {
1534                                 .ifnum = 1,
1535                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1536                         },
1537                         {
1538                                 .ifnum = 2,
1539                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1540                         },
1541                         {
1542                                 .ifnum = -1
1543                         }
1544                 }
1545         }
1546 },
1547 {
1548         /* has ID 0x00ea when not in Advanced Driver mode */
1549         USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9),
1550         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1551                 /* .vendor_name = "Roland", */
1552                 /* .product_name = "UA-1G", */
1553                 .ifnum = QUIRK_ANY_INTERFACE,
1554                 .type = QUIRK_COMPOSITE,
1555                 .data = (const struct snd_usb_audio_quirk[]) {
1556                         {
1557                                 .ifnum = 0,
1558                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1559                         },
1560                         {
1561                                 .ifnum = 1,
1562                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1563                         },
1564                         {
1565                                 .ifnum = -1
1566                         }
1567                 }
1568         }
1569 },
1570 {
1571         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0104),
1572         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1573                 /* .vendor_name = "Roland", */
1574                 /* .product_name = "UM-1G", */
1575                 .ifnum = 0,
1576                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1577                 .data = & (const struct snd_usb_midi_endpoint_info) {
1578                         .out_cables = 0x0001,
1579                         .in_cables  = 0x0001
1580                 }
1581         }
1582 },
1583 {
1584         /* Boss JS-8 Jam Station  */
1585         USB_DEVICE(0x0582, 0x0109),
1586         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1587                 /* .vendor_name = "BOSS", */
1588                 /* .product_name = "JS-8", */
1589                 .ifnum = QUIRK_ANY_INTERFACE,
1590                 .type = QUIRK_COMPOSITE,
1591                 .data = (const struct snd_usb_audio_quirk[]) {
1592                         {
1593                                 .ifnum = 0,
1594                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1595                         },
1596                         {
1597                                 .ifnum = 1,
1598                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1599                         },
1600                         {
1601                                 .ifnum = 2,
1602                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1603                         },
1604                         {
1605                                 .ifnum = -1
1606                         }
1607                 }
1608         }
1609 },
1610 {
1611         /* has ID 0x0110 when not in Advanced Driver mode */
1612         USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f),
1613         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1614                 /* .vendor_name = "Roland", */
1615                 /* .product_name = "A-PRO", */
1616                 .ifnum = 1,
1617                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1618                 .data = & (const struct snd_usb_midi_endpoint_info) {
1619                         .out_cables = 0x0003,
1620                         .in_cables  = 0x0007
1621                 }
1622         }
1623 },
1624 {
1625         USB_DEVICE(0x0582, 0x0113),
1626         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1627                 /* .vendor_name = "BOSS", */
1628                 /* .product_name = "ME-25", */
1629                 .ifnum = QUIRK_ANY_INTERFACE,
1630                 .type = QUIRK_COMPOSITE,
1631                 .data = (const struct snd_usb_audio_quirk[]) {
1632                         {
1633                                 .ifnum = 0,
1634                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1635                         },
1636                         {
1637                                 .ifnum = 1,
1638                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1639                         },
1640                         {
1641                                 .ifnum = 2,
1642                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1643                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1644                                         .out_cables = 0x0001,
1645                                         .in_cables  = 0x0001
1646                                 }
1647                         },
1648                         {
1649                                 .ifnum = -1
1650                         }
1651                 }
1652         }
1653 },
1654 {
1655         USB_DEVICE(0x0582, 0x0127),
1656         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1657                 /* .vendor_name = "Roland", */
1658                 /* .product_name = "GR-55", */
1659                 .ifnum = QUIRK_ANY_INTERFACE,
1660                 .type = QUIRK_COMPOSITE,
1661                 .data = (const struct snd_usb_audio_quirk[]) {
1662                         {
1663                                 .ifnum = 0,
1664                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1665                         },
1666                         {
1667                                 .ifnum = 1,
1668                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1669                         },
1670                         {
1671                                 .ifnum = 2,
1672                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1673                         },
1674                         {
1675                                 .ifnum = -1
1676                         }
1677                 }
1678         }
1679 },
1680 {
1681         USB_DEVICE(0x0582, 0x011e),
1682         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1683                 /* .vendor_name = "BOSS", */
1684                 /* .product_name = "BR-800", */
1685                 .ifnum = QUIRK_ANY_INTERFACE,
1686                 .type = QUIRK_COMPOSITE,
1687                 .data = (const struct snd_usb_audio_quirk[]) {
1688                         {
1689                                 .ifnum = 0,
1690                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1691                         },
1692                         {
1693                                 .ifnum = 1,
1694                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1695                         },
1696                         {
1697                                 .ifnum = 2,
1698                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1699                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1700                                         .out_cables = 0x0001,
1701                                         .in_cables  = 0x0001
1702                                 }
1703                         },
1704                         {
1705                                 .ifnum = -1
1706                         }
1707                 }
1708         }
1709 },
1710 {
1711         USB_DEVICE(0x0582, 0x0130),
1712         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1713                 /* .vendor_name = "BOSS", */
1714                 /* .product_name = "MICRO BR-80", */
1715                 .ifnum = QUIRK_ANY_INTERFACE,
1716                 .type = QUIRK_COMPOSITE,
1717                 .data = (const struct snd_usb_audio_quirk[]) {
1718                         {
1719                                 .ifnum = 0,
1720                                 .type = QUIRK_IGNORE_INTERFACE
1721                         },
1722                         {
1723                                 .ifnum = 1,
1724                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1725                         },
1726                         {
1727                                 .ifnum = 2,
1728                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1729                         },
1730                         {
1731                                 .ifnum = 3,
1732                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1733                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1734                                         .out_cables = 0x0001,
1735                                         .in_cables  = 0x0001
1736                                 }
1737                         },
1738                         {
1739                                 .ifnum = -1
1740                         }
1741                 }
1742         }
1743 },
1744
1745 /* Guillemot devices */
1746 {
1747         /*
1748          * This is for the "Windows Edition" where the external MIDI ports are
1749          * the only MIDI ports; the control data is reported through HID
1750          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1751          * compliant USB MIDI ports for external MIDI and controls.
1752          */
1753         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1754         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1755                 .vendor_name = "Hercules",
1756                 .product_name = "DJ Console (WE)",
1757                 .ifnum = 4,
1758                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1759                 .data = & (const struct snd_usb_midi_endpoint_info) {
1760                         .out_cables = 0x0001,
1761                         .in_cables = 0x0001
1762                 }
1763         }
1764 },
1765
1766 /* Midiman/M-Audio devices */
1767 {
1768         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1769         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1770                 .vendor_name = "M-Audio",
1771                 .product_name = "MidiSport 2x2",
1772                 .ifnum = QUIRK_ANY_INTERFACE,
1773                 .type = QUIRK_MIDI_MIDIMAN,
1774                 .data = & (const struct snd_usb_midi_endpoint_info) {
1775                         .out_cables = 0x0003,
1776                         .in_cables  = 0x0003
1777                 }
1778         }
1779 },
1780 {
1781         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1782         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1783                 .vendor_name = "M-Audio",
1784                 .product_name = "MidiSport 1x1",
1785                 .ifnum = QUIRK_ANY_INTERFACE,
1786                 .type = QUIRK_MIDI_MIDIMAN,
1787                 .data = & (const struct snd_usb_midi_endpoint_info) {
1788                         .out_cables = 0x0001,
1789                         .in_cables  = 0x0001
1790                 }
1791         }
1792 },
1793 {
1794         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1795         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1796                 .vendor_name = "M-Audio",
1797                 .product_name = "Keystation",
1798                 .ifnum = QUIRK_ANY_INTERFACE,
1799                 .type = QUIRK_MIDI_MIDIMAN,
1800                 .data = & (const struct snd_usb_midi_endpoint_info) {
1801                         .out_cables = 0x0001,
1802                         .in_cables  = 0x0001
1803                 }
1804         }
1805 },
1806 {
1807         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1808         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1809                 .vendor_name = "M-Audio",
1810                 .product_name = "MidiSport 4x4",
1811                 .ifnum = QUIRK_ANY_INTERFACE,
1812                 .type = QUIRK_MIDI_MIDIMAN,
1813                 .data = & (const struct snd_usb_midi_endpoint_info) {
1814                         .out_cables = 0x000f,
1815                         .in_cables  = 0x000f
1816                 }
1817         }
1818 },
1819 {
1820         /*
1821          * For hardware revision 1.05; in the later revisions (1.10 and
1822          * 1.21), 0x1031 is the ID for the device without firmware.
1823          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1824          */
1825         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1826         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1827                 .vendor_name = "M-Audio",
1828                 .product_name = "MidiSport 8x8",
1829                 .ifnum = QUIRK_ANY_INTERFACE,
1830                 .type = QUIRK_MIDI_MIDIMAN,
1831                 .data = & (const struct snd_usb_midi_endpoint_info) {
1832                         .out_cables = 0x01ff,
1833                         .in_cables  = 0x01ff
1834                 }
1835         }
1836 },
1837 {
1838         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1839         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1840                 .vendor_name = "M-Audio",
1841                 .product_name = "MidiSport 8x8",
1842                 .ifnum = QUIRK_ANY_INTERFACE,
1843                 .type = QUIRK_MIDI_MIDIMAN,
1844                 .data = & (const struct snd_usb_midi_endpoint_info) {
1845                         .out_cables = 0x01ff,
1846                         .in_cables  = 0x01ff
1847                 }
1848         }
1849 },
1850 {
1851         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1852         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1853                 .vendor_name = "M-Audio",
1854                 .product_name = "MidiSport 2x4",
1855                 .ifnum = QUIRK_ANY_INTERFACE,
1856                 .type = QUIRK_MIDI_MIDIMAN,
1857                 .data = & (const struct snd_usb_midi_endpoint_info) {
1858                         .out_cables = 0x000f,
1859                         .in_cables  = 0x0003
1860                 }
1861         }
1862 },
1863 {
1864         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1865         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1866                 .vendor_name = "M-Audio",
1867                 .product_name = "Quattro",
1868                 .ifnum = QUIRK_ANY_INTERFACE,
1869                 .type = QUIRK_COMPOSITE,
1870                 .data = & (const struct snd_usb_audio_quirk[]) {
1871                         /*
1872                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1873                          * and share endpoints with the other interfaces.
1874                          * Ignore them.  The other interfaces can do 24 bits,
1875                          * but captured samples are big-endian (see usbaudio.c).
1876                          */
1877                         {
1878                                 .ifnum = 0,
1879                                 .type = QUIRK_IGNORE_INTERFACE
1880                         },
1881                         {
1882                                 .ifnum = 1,
1883                                 .type = QUIRK_IGNORE_INTERFACE
1884                         },
1885                         {
1886                                 .ifnum = 2,
1887                                 .type = QUIRK_IGNORE_INTERFACE
1888                         },
1889                         {
1890                                 .ifnum = 3,
1891                                 .type = QUIRK_IGNORE_INTERFACE
1892                         },
1893                         {
1894                                 .ifnum = 4,
1895                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1896                         },
1897                         {
1898                                 .ifnum = 5,
1899                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1900                         },
1901                         {
1902                                 .ifnum = 6,
1903                                 .type = QUIRK_IGNORE_INTERFACE
1904                         },
1905                         {
1906                                 .ifnum = 7,
1907                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1908                         },
1909                         {
1910                                 .ifnum = 8,
1911                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1912                         },
1913                         {
1914                                 .ifnum = 9,
1915                                 .type = QUIRK_MIDI_MIDIMAN,
1916                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1917                                         .out_cables = 0x0001,
1918                                         .in_cables  = 0x0001
1919                                 }
1920                         },
1921                         {
1922                                 .ifnum = -1
1923                         }
1924                 }
1925         }
1926 },
1927 {
1928         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1929         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1930                 .vendor_name = "M-Audio",
1931                 .product_name = "AudioPhile",
1932                 .ifnum = 6,
1933                 .type = QUIRK_MIDI_MIDIMAN,
1934                 .data = & (const struct snd_usb_midi_endpoint_info) {
1935                         .out_cables = 0x0001,
1936                         .in_cables  = 0x0001
1937                 }
1938         }
1939 },
1940 {
1941         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1942         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1943                 .vendor_name = "M-Audio",
1944                 .product_name = "Ozone",
1945                 .ifnum = 3,
1946                 .type = QUIRK_MIDI_MIDIMAN,
1947                 .data = & (const struct snd_usb_midi_endpoint_info) {
1948                         .out_cables = 0x0001,
1949                         .in_cables  = 0x0001
1950                 }
1951         }
1952 },
1953 {
1954         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1955         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1956                 .vendor_name = "M-Audio",
1957                 .product_name = "OmniStudio",
1958                 .ifnum = QUIRK_ANY_INTERFACE,
1959                 .type = QUIRK_COMPOSITE,
1960                 .data = & (const struct snd_usb_audio_quirk[]) {
1961                         {
1962                                 .ifnum = 0,
1963                                 .type = QUIRK_IGNORE_INTERFACE
1964                         },
1965                         {
1966                                 .ifnum = 1,
1967                                 .type = QUIRK_IGNORE_INTERFACE
1968                         },
1969                         {
1970                                 .ifnum = 2,
1971                                 .type = QUIRK_IGNORE_INTERFACE
1972                         },
1973                         {
1974                                 .ifnum = 3,
1975                                 .type = QUIRK_IGNORE_INTERFACE
1976                         },
1977                         {
1978                                 .ifnum = 4,
1979                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1980                         },
1981                         {
1982                                 .ifnum = 5,
1983                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1984                         },
1985                         {
1986                                 .ifnum = 6,
1987                                 .type = QUIRK_IGNORE_INTERFACE
1988                         },
1989                         {
1990                                 .ifnum = 7,
1991                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1992                         },
1993                         {
1994                                 .ifnum = 8,
1995                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1996                         },
1997                         {
1998                                 .ifnum = 9,
1999                                 .type = QUIRK_MIDI_MIDIMAN,
2000                                 .data = & (const struct snd_usb_midi_endpoint_info) {
2001                                         .out_cables = 0x0001,
2002                                         .in_cables  = 0x0001
2003                                 }
2004                         },
2005                         {
2006                                 .ifnum = -1
2007                         }
2008                 }
2009         }
2010 },
2011 {
2012         USB_DEVICE(0x0763, 0x2019),
2013         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2014                 /* .vendor_name = "M-Audio", */
2015                 /* .product_name = "Ozone Academic", */
2016                 .ifnum = QUIRK_ANY_INTERFACE,
2017                 .type = QUIRK_COMPOSITE,
2018                 .data = & (const struct snd_usb_audio_quirk[]) {
2019                         {
2020                                 .ifnum = 0,
2021                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2022                         },
2023                         {
2024                                 .ifnum = 1,
2025                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2026                         },
2027                         {
2028                                 .ifnum = 2,
2029                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2030                         },
2031                         {
2032                                 .ifnum = 3,
2033                                 .type = QUIRK_MIDI_MIDIMAN,
2034                                 .data = & (const struct snd_usb_midi_endpoint_info) {
2035                                         .out_cables = 0x0001,
2036                                         .in_cables  = 0x0001
2037                                 }
2038                         },
2039                         {
2040                                 .ifnum = -1
2041                         }
2042                 }
2043         }
2044 },
2045 {
2046         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2047         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2048                 /* .vendor_name = "M-Audio", */
2049                 /* .product_name = "Fast Track Ultra", */
2050                 .ifnum = QUIRK_ANY_INTERFACE,
2051                 .type = QUIRK_COMPOSITE,
2052                 .data = & (const struct snd_usb_audio_quirk[]) {
2053                         {
2054                                 .ifnum = 0,
2055                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2056                         },
2057                         {
2058                                 .ifnum = 1,
2059                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2060                                 .data = & (const struct audioformat) {
2061                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2062                                         .channels = 8,
2063                                         .iface = 1,
2064                                         .altsetting = 1,
2065                                         .altset_idx = 1,
2066                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2067                                         .endpoint = 0x01,
2068                                         .ep_attr = 0x09,
2069                                         .rates = SNDRV_PCM_RATE_44100 |
2070                                                  SNDRV_PCM_RATE_48000 |
2071                                                  SNDRV_PCM_RATE_88200 |
2072                                                  SNDRV_PCM_RATE_96000,
2073                                         .rate_min = 44100,
2074                                         .rate_max = 96000,
2075                                         .nr_rates = 4,
2076                                         .rate_table = (unsigned int[]) {
2077                                                 44100, 48000, 88200, 96000
2078                                         }
2079                                 }
2080                         },
2081                         {
2082                                 .ifnum = 2,
2083                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2084                                 .data = & (const struct audioformat) {
2085                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2086                                         .channels = 8,
2087                                         .iface = 2,
2088                                         .altsetting = 1,
2089                                         .altset_idx = 1,
2090                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2091                                         .endpoint = 0x81,
2092                                         .ep_attr = 0x05,
2093                                         .rates = SNDRV_PCM_RATE_44100 |
2094                                                  SNDRV_PCM_RATE_48000 |
2095                                                  SNDRV_PCM_RATE_88200 |
2096                                                  SNDRV_PCM_RATE_96000,
2097                                         .rate_min = 44100,
2098                                         .rate_max = 96000,
2099                                         .nr_rates = 4,
2100                                         .rate_table = (unsigned int[]) {
2101                                                 44100, 48000, 88200, 96000
2102                                         }
2103                                 }
2104                         },
2105                         /* interface 3 (MIDI) is standard compliant */
2106                         {
2107                                 .ifnum = -1
2108                         }
2109                 }
2110         }
2111 },
2112 {
2113         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2114         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2115                 /* .vendor_name = "M-Audio", */
2116                 /* .product_name = "Fast Track Ultra 8R", */
2117                 .ifnum = QUIRK_ANY_INTERFACE,
2118                 .type = QUIRK_COMPOSITE,
2119                 .data = & (const struct snd_usb_audio_quirk[]) {
2120                         {
2121                                 .ifnum = 0,
2122                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2123                         },
2124                         {
2125                                 .ifnum = 1,
2126                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2127                                 .data = & (const struct audioformat) {
2128                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2129                                         .channels = 8,
2130                                         .iface = 1,
2131                                         .altsetting = 1,
2132                                         .altset_idx = 1,
2133                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2134                                         .endpoint = 0x01,
2135                                         .ep_attr = 0x09,
2136                                         .rates = SNDRV_PCM_RATE_44100 |
2137                                                  SNDRV_PCM_RATE_48000 |
2138                                                  SNDRV_PCM_RATE_88200 |
2139                                                  SNDRV_PCM_RATE_96000,
2140                                         .rate_min = 44100,
2141                                         .rate_max = 96000,
2142                                         .nr_rates = 4,
2143                                         .rate_table = (unsigned int[]) {
2144                                                         44100, 48000, 88200, 96000
2145                                         }
2146                                 }
2147                         },
2148                         {
2149                                 .ifnum = 2,
2150                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2151                                 .data = & (const struct audioformat) {
2152                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2153                                         .channels = 8,
2154                                         .iface = 2,
2155                                         .altsetting = 1,
2156                                         .altset_idx = 1,
2157                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2158                                         .endpoint = 0x81,
2159                                         .ep_attr = 0x05,
2160                                         .rates = SNDRV_PCM_RATE_44100 |
2161                                                  SNDRV_PCM_RATE_48000 |
2162                                                  SNDRV_PCM_RATE_88200 |
2163                                                  SNDRV_PCM_RATE_96000,
2164                                         .rate_min = 44100,
2165                                         .rate_max = 96000,
2166                                         .nr_rates = 4,
2167                                         .rate_table = (unsigned int[]) {
2168                                                 44100, 48000, 88200, 96000
2169                                         }
2170                                 }
2171                         },
2172                         /* interface 3 (MIDI) is standard compliant */
2173                         {
2174                                 .ifnum = -1
2175                         }
2176                 }
2177         }
2178 },
2179
2180 /* Casio devices */
2181 {
2182         USB_DEVICE(0x07cf, 0x6801),
2183         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2184                 .vendor_name = "Casio",
2185                 .product_name = "PL-40R",
2186                 .ifnum = 0,
2187                 .type = QUIRK_MIDI_YAMAHA
2188         }
2189 },
2190 {
2191         /* this ID is used by several devices without a product ID */
2192         USB_DEVICE(0x07cf, 0x6802),
2193         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2194                 .vendor_name = "Casio",
2195                 .product_name = "Keyboard",
2196                 .ifnum = 0,
2197                 .type = QUIRK_MIDI_YAMAHA
2198         }
2199 },
2200
2201 /* Mark of the Unicorn devices */
2202 {
2203         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2204         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2205                        USB_DEVICE_ID_MATCH_PRODUCT |
2206                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2207         .idVendor = 0x07fd,
2208         .idProduct = 0x0001,
2209         .bDeviceSubClass = 2,
2210         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2211                 .vendor_name = "MOTU",
2212                 .product_name = "Fastlane",
2213                 .ifnum = QUIRK_ANY_INTERFACE,
2214                 .type = QUIRK_COMPOSITE,
2215                 .data = & (const struct snd_usb_audio_quirk[]) {
2216                         {
2217                                 .ifnum = 0,
2218                                 .type = QUIRK_MIDI_RAW_BYTES
2219                         },
2220                         {
2221                                 .ifnum = 1,
2222                                 .type = QUIRK_IGNORE_INTERFACE
2223                         },
2224                         {
2225                                 .ifnum = -1
2226                         }
2227                 }
2228         }
2229 },
2230
2231 /* Emagic devices */
2232 {
2233         USB_DEVICE(0x086a, 0x0001),
2234         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2235                 .vendor_name = "Emagic",
2236                 /* .product_name = "Unitor8", */
2237                 .ifnum = 2,
2238                 .type = QUIRK_MIDI_EMAGIC,
2239                 .data = & (const struct snd_usb_midi_endpoint_info) {
2240                         .out_cables = 0x80ff,
2241                         .in_cables  = 0x80ff
2242                 }
2243         }
2244 },
2245 {
2246         USB_DEVICE(0x086a, 0x0002),
2247         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2248                 .vendor_name = "Emagic",
2249                 /* .product_name = "AMT8", */
2250                 .ifnum = 2,
2251                 .type = QUIRK_MIDI_EMAGIC,
2252                 .data = & (const struct snd_usb_midi_endpoint_info) {
2253                         .out_cables = 0x80ff,
2254                         .in_cables  = 0x80ff
2255                 }
2256         }
2257 },
2258 {
2259         USB_DEVICE(0x086a, 0x0003),
2260         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2261                 .vendor_name = "Emagic",
2262                 /* .product_name = "MT4", */
2263                 .ifnum = 2,
2264                 .type = QUIRK_MIDI_EMAGIC,
2265                 .data = & (const struct snd_usb_midi_endpoint_info) {
2266                         .out_cables = 0x800f,
2267                         .in_cables  = 0x8003
2268                 }
2269         }
2270 },
2271
2272 /* KORG devices */
2273 {
2274         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2275         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2276                 .vendor_name = "KORG, Inc.",
2277                 /* .product_name = "PANDORA PX5D", */
2278                 .ifnum = 3,
2279                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2280         }
2281 },
2282
2283 /* AKAI devices */
2284 {
2285         USB_DEVICE(0x09e8, 0x0062),
2286         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2287                 .vendor_name = "AKAI",
2288                 .product_name = "MPD16",
2289                 .ifnum = 0,
2290                 .type = QUIRK_MIDI_AKAI,
2291         }
2292 },
2293
2294 /* TerraTec devices */
2295 {
2296         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2297         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2298                 .vendor_name = "TerraTec",
2299                 .product_name = "PHASE 26",
2300                 .ifnum = 3,
2301                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2302         }
2303 },
2304 {
2305         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2306         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2307                 .vendor_name = "TerraTec",
2308                 .product_name = "PHASE 26",
2309                 .ifnum = 3,
2310                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2311         }
2312 },
2313 {
2314         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2315         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2316                 .vendor_name = "TerraTec",
2317                 .product_name = "PHASE 26",
2318                 .ifnum = 3,
2319                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2320         }
2321 },
2322 {
2323         USB_DEVICE(0x0ccd, 0x0028),
2324         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2325                 .vendor_name = "TerraTec",
2326                 .product_name = "Aureon5.1MkII",
2327                 .ifnum = QUIRK_NO_INTERFACE
2328         }
2329 },
2330 {
2331         USB_DEVICE(0x0ccd, 0x0035),
2332         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2333                 .vendor_name = "Miditech",
2334                 .product_name = "Play'n Roll",
2335                 .ifnum = 0,
2336                 .type = QUIRK_MIDI_CME
2337         }
2338 },
2339
2340 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2341 {
2342         USB_DEVICE(0x103d, 0x0100),
2343                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2344                 .vendor_name = "Stanton",
2345                 .product_name = "ScratchAmp",
2346                 .ifnum = QUIRK_NO_INTERFACE
2347         }
2348 },
2349 {
2350         USB_DEVICE(0x103d, 0x0101),
2351                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2352                 .vendor_name = "Stanton",
2353                 .product_name = "ScratchAmp",
2354                 .ifnum = QUIRK_NO_INTERFACE
2355         }
2356 },
2357
2358 /* Novation EMS devices */
2359 {
2360         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2361         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2362                 .vendor_name = "Novation",
2363                 .product_name = "ReMOTE Audio/XStation",
2364                 .ifnum = 4,
2365                 .type = QUIRK_MIDI_NOVATION
2366         }
2367 },
2368 {
2369         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2370         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2371                 .vendor_name = "Novation",
2372                 .product_name = "Speedio",
2373                 .ifnum = 3,
2374                 .type = QUIRK_MIDI_NOVATION
2375         }
2376 },
2377 {
2378         USB_DEVICE(0x1235, 0x000e),
2379         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2380                 /* .vendor_name = "Novation", */
2381                 /* .product_name = "Launchpad", */
2382                 .ifnum = 0,
2383                 .type = QUIRK_MIDI_RAW_BYTES
2384         }
2385 },
2386 {
2387         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2388         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2389                 .vendor_name = "Novation",
2390                 .product_name = "ReMOTE25",
2391                 .ifnum = 0,
2392                 .type = QUIRK_MIDI_NOVATION
2393         }
2394 },
2395
2396 /* Access Music devices */
2397 {
2398         /* VirusTI Desktop */
2399         USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2400         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2401                 .ifnum = QUIRK_ANY_INTERFACE,
2402                 .type = QUIRK_COMPOSITE,
2403                 .data = &(const struct snd_usb_audio_quirk[]) {
2404                         {
2405                                 .ifnum = 3,
2406                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2407                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2408                                         .out_cables = 0x0003,
2409                                         .in_cables  = 0x0003
2410                                 }
2411                         },
2412                         {
2413                                 .ifnum = 4,
2414                                 .type = QUIRK_IGNORE_INTERFACE
2415                         },
2416                         {
2417                                 .ifnum = -1
2418                         }
2419                 }
2420         }
2421 },
2422
2423 /* */
2424 {
2425         /* aka. Serato Scratch Live DJ Box */
2426         USB_DEVICE(0x13e5, 0x0001),
2427         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2428                 .vendor_name = "Rane",
2429                 .product_name = "SL-1",
2430                 .ifnum = QUIRK_NO_INTERFACE
2431         }
2432 },
2433
2434 /* Native Instruments MK2 series */
2435 {
2436         /* Komplete Audio 6 */
2437         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2438         .idVendor = 0x17cc,
2439         .idProduct = 0x1000,
2440 },
2441 {
2442         /* Traktor Audio 6 */
2443         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2444         .idVendor = 0x17cc,
2445         .idProduct = 0x1010,
2446 },
2447 {
2448         /* Traktor Audio 10 */
2449         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2450         .idVendor = 0x17cc,
2451         .idProduct = 0x1020,
2452 },
2453
2454 /* KeithMcMillen Stringport */
2455 {
2456         USB_DEVICE(0x1f38, 0x0001),
2457         .bInterfaceClass = USB_CLASS_AUDIO,
2458 },
2459
2460 /* Miditech devices */
2461 {
2462         USB_DEVICE(0x4752, 0x0011),
2463         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2464                 .vendor_name = "Miditech",
2465                 .product_name = "Midistart-2",
2466                 .ifnum = 0,
2467                 .type = QUIRK_MIDI_CME
2468         }
2469 },
2470
2471 /* Central Music devices */
2472 {
2473         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2474         USB_DEVICE(0x7104, 0x2202),
2475         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2476                 .ifnum = 0,
2477                 .type = QUIRK_MIDI_CME
2478         }
2479 },
2480
2481 /* Hauppauge HVR-950Q and HVR-850 */
2482 {
2483         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
2484         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2485                        USB_DEVICE_ID_MATCH_INT_CLASS |
2486                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2487         .bInterfaceClass = USB_CLASS_AUDIO,
2488         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2489         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2490                 .vendor_name = "Hauppauge",
2491                 .product_name = "HVR-950Q",
2492                 .ifnum = QUIRK_ANY_INTERFACE,
2493                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2494         }
2495 },
2496 {
2497         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240),
2498         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2499                        USB_DEVICE_ID_MATCH_INT_CLASS |
2500                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2501         .bInterfaceClass = USB_CLASS_AUDIO,
2502         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2503         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2504                 .vendor_name = "Hauppauge",
2505                 .product_name = "HVR-850",
2506                 .ifnum = QUIRK_ANY_INTERFACE,
2507                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2508         }
2509 },
2510 {
2511         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210),
2512         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2513                        USB_DEVICE_ID_MATCH_INT_CLASS |
2514                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2515         .bInterfaceClass = USB_CLASS_AUDIO,
2516         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2517         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2518                 .vendor_name = "Hauppauge",
2519                 .product_name = "HVR-950Q",
2520                 .ifnum = QUIRK_ANY_INTERFACE,
2521                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2522         }
2523 },
2524 {
2525         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217),
2526         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2527                        USB_DEVICE_ID_MATCH_INT_CLASS |
2528                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2529         .bInterfaceClass = USB_CLASS_AUDIO,
2530         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2531         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2532                 .vendor_name = "Hauppauge",
2533                 .product_name = "HVR-950Q",
2534                 .ifnum = QUIRK_ANY_INTERFACE,
2535                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2536         }
2537 },
2538 {
2539         USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b),
2540         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2541                        USB_DEVICE_ID_MATCH_INT_CLASS |
2542                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2543         .bInterfaceClass = USB_CLASS_AUDIO,
2544         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2545         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2546                 .vendor_name = "Hauppauge",
2547                 .product_name = "HVR-950Q",
2548                 .ifnum = QUIRK_ANY_INTERFACE,
2549                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2550         }
2551 },
2552 {
2553         USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e),
2554         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2555                        USB_DEVICE_ID_MATCH_INT_CLASS |
2556                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2557         .bInterfaceClass = USB_CLASS_AUDIO,
2558         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2559         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2560                 .vendor_name = "Hauppauge",
2561                 .product_name = "HVR-950Q",
2562                 .ifnum = QUIRK_ANY_INTERFACE,
2563                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2564         }
2565 },
2566 {
2567         USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f),
2568         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2569                        USB_DEVICE_ID_MATCH_INT_CLASS |
2570                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2571         .bInterfaceClass = USB_CLASS_AUDIO,
2572         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2573         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2574                 .vendor_name = "Hauppauge",
2575                 .product_name = "HVR-950Q",
2576                 .ifnum = QUIRK_ANY_INTERFACE,
2577                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2578         }
2579 },
2580 {
2581         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280),
2582         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2583                        USB_DEVICE_ID_MATCH_INT_CLASS |
2584                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2585         .bInterfaceClass = USB_CLASS_AUDIO,
2586         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2587         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2588                 .vendor_name = "Hauppauge",
2589                 .product_name = "HVR-950Q",
2590                 .ifnum = QUIRK_ANY_INTERFACE,
2591                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2592         }
2593 },
2594 {
2595         USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008),
2596         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2597                        USB_DEVICE_ID_MATCH_INT_CLASS |
2598                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2599         .bInterfaceClass = USB_CLASS_AUDIO,
2600         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2601         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2602                 .vendor_name = "Hauppauge",
2603                 .product_name = "HVR-950Q",
2604                 .ifnum = QUIRK_ANY_INTERFACE,
2605                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2606         }
2607 },
2608
2609 /* Digidesign Mbox */
2610 {
2611         /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2612         USB_DEVICE(0x0dba, 0x1000),
2613         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2614                 .vendor_name = "Digidesign",
2615                 .product_name = "MBox",
2616                 .ifnum = QUIRK_ANY_INTERFACE,
2617                 .type = QUIRK_COMPOSITE,
2618                 .data = (const struct snd_usb_audio_quirk[]){
2619                         {
2620                                 .ifnum = 0,
2621                                 .type = QUIRK_IGNORE_INTERFACE,
2622                         },
2623                         {
2624                                 .ifnum = 1,
2625                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2626                                 .data = &(const struct audioformat) {
2627                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2628                                         .channels = 2,
2629                                         .iface = 1,
2630                                         .altsetting = 1,
2631                                         .altset_idx = 1,
2632                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2633                                         .endpoint = 0x02,
2634                                         .ep_attr = 0x01,
2635                                         .maxpacksize = 0x130,
2636                                         .rates = SNDRV_PCM_RATE_44100 |
2637                                                  SNDRV_PCM_RATE_48000,
2638                                         .rate_min = 44100,
2639                                         .rate_max = 48000,
2640                                         .nr_rates = 2,
2641                                         .rate_table = (unsigned int[]) {
2642                                                 44100, 48000
2643                                         }
2644                                 }
2645                         },
2646                         {
2647                                 .ifnum = -1
2648                         }
2649                 }
2650
2651         }
2652 },
2653
2654 {
2655         /*
2656          * Some USB MIDI devices don't have an audio control interface,
2657          * so we have to grab MIDI streaming interfaces here.
2658          */
2659         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
2660                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2661         .bInterfaceClass = USB_CLASS_AUDIO,
2662         .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
2663         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2664                 .ifnum = QUIRK_ANY_INTERFACE,
2665                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2666         }
2667 },
2668
2669 #undef USB_DEVICE_VENDOR_SPEC