source: src/linux/universal/linux-3.18/sound/usb/quirks-table.h @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 2 months ago

update

File size: 77.9 KB
Line 
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/* FTDI devices */
43{
44        USB_DEVICE(0x0403, 0xb8d8),
45        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
46                /* .vendor_name = "STARR LABS", */
47                /* .product_name = "Starr Labs MIDI USB device", */
48                .ifnum = 0,
49                .type = QUIRK_MIDI_FTDI
50        }
51},
52
53{
54        /* Creative BT-D1 */
55        USB_DEVICE(0x041e, 0x0005),
56        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
57                .ifnum = 1,
58                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
59                .data = &(const struct audioformat) {
60                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
61                        .channels = 2,
62                        .iface = 1,
63                        .altsetting = 1,
64                        .altset_idx = 1,
65                        .endpoint = 0x03,
66                        .ep_attr = USB_ENDPOINT_XFER_ISOC,
67                        .attributes = 0,
68                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
69                        .rate_min = 48000,
70                        .rate_max = 48000,
71                }
72        }
73},
74
75/* Creative/E-Mu devices */
76{
77        USB_DEVICE(0x041e, 0x3010),
78        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
79                .vendor_name = "Creative Labs",
80                .product_name = "Sound Blaster MP3+",
81                .ifnum = QUIRK_NO_INTERFACE
82        }
83},
84/* Creative/Toshiba Multimedia Center SB-0500 */
85{
86        USB_DEVICE(0x041e, 0x3048),
87        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
88                .vendor_name = "Toshiba",
89                .product_name = "SB-0500",
90                .ifnum = QUIRK_NO_INTERFACE
91        }
92},
93{
94        /* E-Mu 0202 USB */
95        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
96        .idVendor = 0x041e,
97        .idProduct = 0x3f02,
98        .bInterfaceClass = USB_CLASS_AUDIO,
99},
100{
101        /* E-Mu 0404 USB */
102        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
103        .idVendor = 0x041e,
104        .idProduct = 0x3f04,
105        .bInterfaceClass = USB_CLASS_AUDIO,
106},
107{
108        /* E-Mu Tracker Pre */
109        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
110        .idVendor = 0x041e,
111        .idProduct = 0x3f0a,
112        .bInterfaceClass = USB_CLASS_AUDIO,
113},
114{
115        /* E-Mu 0204 USB */
116        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
117        .idVendor = 0x041e,
118        .idProduct = 0x3f19,
119        .bInterfaceClass = USB_CLASS_AUDIO,
120},
121
122/*
123 * HP Wireless Audio
124 * When not ignored, causes instability issues for some users, forcing them to
125 * blacklist the entire module.
126 */
127{
128        USB_DEVICE(0x0424, 0xb832),
129        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
130                .vendor_name = "Standard Microsystems Corp.",
131                .product_name = "HP Wireless Audio",
132                .ifnum = QUIRK_ANY_INTERFACE,
133                .type = QUIRK_COMPOSITE,
134                .data = (const struct snd_usb_audio_quirk[]) {
135                        /* Mixer */
136                        {
137                                .ifnum = 0,
138                                .type = QUIRK_IGNORE_INTERFACE,
139                        },
140                        /* Playback */
141                        {
142                                .ifnum = 1,
143                                .type = QUIRK_IGNORE_INTERFACE,
144                        },
145                        /* Capture */
146                        {
147                                .ifnum = 2,
148                                .type = QUIRK_IGNORE_INTERFACE,
149                        },
150                        /* HID Device, .ifnum = 3 */
151                        {
152                                .ifnum = -1,
153                        }
154                }
155        }
156},
157
158/*
159 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
160 * class matches do not take effect without an explicit ID match.
161 */
162{
163        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
164                       USB_DEVICE_ID_MATCH_INT_CLASS |
165                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
166        .idVendor = 0x046d,
167        .idProduct = 0x0850,
168        .bInterfaceClass = USB_CLASS_AUDIO,
169        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
170},
171{
172        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
173                       USB_DEVICE_ID_MATCH_INT_CLASS |
174                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
175        .idVendor = 0x046d,
176        .idProduct = 0x08ae,
177        .bInterfaceClass = USB_CLASS_AUDIO,
178        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
179},
180{
181        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
182                       USB_DEVICE_ID_MATCH_INT_CLASS |
183                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
184        .idVendor = 0x046d,
185        .idProduct = 0x08c6,
186        .bInterfaceClass = USB_CLASS_AUDIO,
187        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
188},
189{
190        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
191                       USB_DEVICE_ID_MATCH_INT_CLASS |
192                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
193        .idVendor = 0x046d,
194        .idProduct = 0x08f0,
195        .bInterfaceClass = USB_CLASS_AUDIO,
196        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
197},
198{
199        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
200                       USB_DEVICE_ID_MATCH_INT_CLASS |
201                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
202        .idVendor = 0x046d,
203        .idProduct = 0x08f5,
204        .bInterfaceClass = USB_CLASS_AUDIO,
205        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
206},
207{
208        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
209                       USB_DEVICE_ID_MATCH_INT_CLASS |
210                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
211        .idVendor = 0x046d,
212        .idProduct = 0x08f6,
213        .bInterfaceClass = USB_CLASS_AUDIO,
214        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
215},
216{
217        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
218                       USB_DEVICE_ID_MATCH_INT_CLASS |
219                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
220        .idVendor = 0x046d,
221        .idProduct = 0x0990,
222        .bInterfaceClass = USB_CLASS_AUDIO,
223        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
224        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
225                .vendor_name = "Logitech, Inc.",
226                .product_name = "QuickCam Pro 9000",
227                .ifnum = QUIRK_NO_INTERFACE
228        }
229},
230
231/*
232 * Yamaha devices
233 */
234
235#define YAMAHA_DEVICE(id, name) { \
236        USB_DEVICE(0x0499, id), \
237        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
238                .vendor_name = "Yamaha", \
239                .product_name = name, \
240                .ifnum = QUIRK_ANY_INTERFACE, \
241                .type = QUIRK_MIDI_YAMAHA \
242        } \
243}
244#define YAMAHA_INTERFACE(id, intf, name) { \
245        USB_DEVICE_VENDOR_SPEC(0x0499, id), \
246        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
247                .vendor_name = "Yamaha", \
248                .product_name = name, \
249                .ifnum = intf, \
250                .type = QUIRK_MIDI_YAMAHA \
251        } \
252}
253YAMAHA_DEVICE(0x1000, "UX256"),
254YAMAHA_DEVICE(0x1001, "MU1000"),
255YAMAHA_DEVICE(0x1002, "MU2000"),
256YAMAHA_DEVICE(0x1003, "MU500"),
257YAMAHA_INTERFACE(0x1004, 3, "UW500"),
258YAMAHA_DEVICE(0x1005, "MOTIF6"),
259YAMAHA_DEVICE(0x1006, "MOTIF7"),
260YAMAHA_DEVICE(0x1007, "MOTIF8"),
261YAMAHA_DEVICE(0x1008, "UX96"),
262YAMAHA_DEVICE(0x1009, "UX16"),
263YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
264YAMAHA_DEVICE(0x100c, "UC-MX"),
265YAMAHA_DEVICE(0x100d, "UC-KX"),
266YAMAHA_DEVICE(0x100e, "S08"),
267YAMAHA_DEVICE(0x100f, "CLP-150"),
268YAMAHA_DEVICE(0x1010, "CLP-170"),
269YAMAHA_DEVICE(0x1011, "P-250"),
270YAMAHA_DEVICE(0x1012, "TYROS"),
271YAMAHA_DEVICE(0x1013, "PF-500"),
272YAMAHA_DEVICE(0x1014, "S90"),
273YAMAHA_DEVICE(0x1015, "MOTIF-R"),
274YAMAHA_DEVICE(0x1016, "MDP-5"),
275YAMAHA_DEVICE(0x1017, "CVP-204"),
276YAMAHA_DEVICE(0x1018, "CVP-206"),
277YAMAHA_DEVICE(0x1019, "CVP-208"),
278YAMAHA_DEVICE(0x101a, "CVP-210"),
279YAMAHA_DEVICE(0x101b, "PSR-1100"),
280YAMAHA_DEVICE(0x101c, "PSR-2100"),
281YAMAHA_DEVICE(0x101d, "CLP-175"),
282YAMAHA_DEVICE(0x101e, "PSR-K1"),
283YAMAHA_DEVICE(0x101f, "EZ-J24"),
284YAMAHA_DEVICE(0x1020, "EZ-250i"),
285YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
286YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
287YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
288YAMAHA_DEVICE(0x1024, "CVP-301"),
289YAMAHA_DEVICE(0x1025, "CVP-303"),
290YAMAHA_DEVICE(0x1026, "CVP-305"),
291YAMAHA_DEVICE(0x1027, "CVP-307"),
292YAMAHA_DEVICE(0x1028, "CVP-309"),
293YAMAHA_DEVICE(0x1029, "CVP-309GP"),
294YAMAHA_DEVICE(0x102a, "PSR-1500"),
295YAMAHA_DEVICE(0x102b, "PSR-3000"),
296YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
297YAMAHA_DEVICE(0x1030, "PSR-295/293"),
298YAMAHA_DEVICE(0x1031, "DGX-205/203"),
299YAMAHA_DEVICE(0x1032, "DGX-305"),
300YAMAHA_DEVICE(0x1033, "DGX-505"),
301YAMAHA_DEVICE(0x1034, NULL),
302YAMAHA_DEVICE(0x1035, NULL),
303YAMAHA_DEVICE(0x1036, NULL),
304YAMAHA_DEVICE(0x1037, NULL),
305YAMAHA_DEVICE(0x1038, NULL),
306YAMAHA_DEVICE(0x1039, NULL),
307YAMAHA_DEVICE(0x103a, NULL),
308YAMAHA_DEVICE(0x103b, NULL),
309YAMAHA_DEVICE(0x103c, NULL),
310YAMAHA_DEVICE(0x103d, NULL),
311YAMAHA_DEVICE(0x103e, NULL),
312YAMAHA_DEVICE(0x103f, NULL),
313YAMAHA_DEVICE(0x1040, NULL),
314YAMAHA_DEVICE(0x1041, NULL),
315YAMAHA_DEVICE(0x1042, NULL),
316YAMAHA_DEVICE(0x1043, NULL),
317YAMAHA_DEVICE(0x1044, NULL),
318YAMAHA_DEVICE(0x1045, NULL),
319YAMAHA_INTERFACE(0x104e, 0, NULL),
320YAMAHA_DEVICE(0x104f, NULL),
321YAMAHA_DEVICE(0x1050, NULL),
322YAMAHA_DEVICE(0x1051, NULL),
323YAMAHA_DEVICE(0x1052, NULL),
324YAMAHA_INTERFACE(0x1053, 0, NULL),
325YAMAHA_INTERFACE(0x1054, 0, NULL),
326YAMAHA_DEVICE(0x1055, NULL),
327YAMAHA_DEVICE(0x1056, NULL),
328YAMAHA_DEVICE(0x1057, NULL),
329YAMAHA_DEVICE(0x1058, NULL),
330YAMAHA_DEVICE(0x1059, NULL),
331YAMAHA_DEVICE(0x105a, NULL),
332YAMAHA_DEVICE(0x105b, NULL),
333YAMAHA_DEVICE(0x105c, NULL),
334YAMAHA_DEVICE(0x105d, NULL),
335{
336        USB_DEVICE(0x0499, 0x1503),
337        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
338                /* .vendor_name = "Yamaha", */
339                /* .product_name = "MOX6/MOX8", */
340                .ifnum = QUIRK_ANY_INTERFACE,
341                .type = QUIRK_COMPOSITE,
342                .data = (const struct snd_usb_audio_quirk[]) {
343                        {
344                                .ifnum = 1,
345                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
346                        },
347                        {
348                                .ifnum = 2,
349                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
350                        },
351                        {
352                                .ifnum = 3,
353                                .type = QUIRK_MIDI_YAMAHA
354                        },
355                        {
356                                .ifnum = -1
357                        }
358                }
359        }
360},
361{
362        USB_DEVICE(0x0499, 0x1507),
363        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
364                /* .vendor_name = "Yamaha", */
365                /* .product_name = "THR10", */
366                .ifnum = QUIRK_ANY_INTERFACE,
367                .type = QUIRK_COMPOSITE,
368                .data = (const struct snd_usb_audio_quirk[]) {
369                        {
370                                .ifnum = 1,
371                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
372                        },
373                        {
374                                .ifnum = 2,
375                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
376                        },
377                        {
378                                .ifnum = 3,
379                                .type = QUIRK_MIDI_YAMAHA
380                        },
381                        {
382                                .ifnum = -1
383                        }
384                }
385        }
386},
387{
388        USB_DEVICE(0x0499, 0x1509),
389        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
390                /* .vendor_name = "Yamaha", */
391                /* .product_name = "Steinberg UR22", */
392                .ifnum = QUIRK_ANY_INTERFACE,
393                .type = QUIRK_COMPOSITE,
394                .data = (const struct snd_usb_audio_quirk[]) {
395                        {
396                                .ifnum = 1,
397                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
398                        },
399                        {
400                                .ifnum = 2,
401                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
402                        },
403                        {
404                                .ifnum = 3,
405                                .type = QUIRK_MIDI_YAMAHA
406                        },
407                        {
408                                .ifnum = 4,
409                                .type = QUIRK_IGNORE_INTERFACE
410                        },
411                        {
412                                .ifnum = -1
413                        }
414                }
415        }
416},
417{
418        USB_DEVICE(0x0499, 0x150a),
419        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
420                /* .vendor_name = "Yamaha", */
421                /* .product_name = "THR5A", */
422                .ifnum = QUIRK_ANY_INTERFACE,
423                .type = QUIRK_COMPOSITE,
424                .data = (const struct snd_usb_audio_quirk[]) {
425                        {
426                                .ifnum = 1,
427                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
428                        },
429                        {
430                                .ifnum = 2,
431                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
432                        },
433                        {
434                                .ifnum = 3,
435                                .type = QUIRK_MIDI_YAMAHA
436                        },
437                        {
438                                .ifnum = -1
439                        }
440                }
441        }
442},
443{
444        USB_DEVICE(0x0499, 0x150c),
445        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
446                /* .vendor_name = "Yamaha", */
447                /* .product_name = "THR10C", */
448                .ifnum = QUIRK_ANY_INTERFACE,
449                .type = QUIRK_COMPOSITE,
450                .data = (const struct snd_usb_audio_quirk[]) {
451                        {
452                                .ifnum = 1,
453                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
454                        },
455                        {
456                                .ifnum = 2,
457                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
458                        },
459                        {
460                                .ifnum = 3,
461                                .type = QUIRK_MIDI_YAMAHA
462                        },
463                        {
464                                .ifnum = -1
465                        }
466                }
467        }
468},
469YAMAHA_DEVICE(0x2000, "DGP-7"),
470YAMAHA_DEVICE(0x2001, "DGP-5"),
471YAMAHA_DEVICE(0x2002, NULL),
472YAMAHA_DEVICE(0x2003, NULL),
473YAMAHA_DEVICE(0x5000, "CS1D"),
474YAMAHA_DEVICE(0x5001, "DSP1D"),
475YAMAHA_DEVICE(0x5002, "DME32"),
476YAMAHA_DEVICE(0x5003, "DM2000"),
477YAMAHA_DEVICE(0x5004, "02R96"),
478YAMAHA_DEVICE(0x5005, "ACU16-C"),
479YAMAHA_DEVICE(0x5006, "NHB32-C"),
480YAMAHA_DEVICE(0x5007, "DM1000"),
481YAMAHA_DEVICE(0x5008, "01V96"),
482YAMAHA_DEVICE(0x5009, "SPX2000"),
483YAMAHA_DEVICE(0x500a, "PM5D"),
484YAMAHA_DEVICE(0x500b, "DME64N"),
485YAMAHA_DEVICE(0x500c, "DME24N"),
486YAMAHA_DEVICE(0x500d, NULL),
487YAMAHA_DEVICE(0x500e, NULL),
488YAMAHA_DEVICE(0x500f, NULL),
489YAMAHA_DEVICE(0x7000, "DTX"),
490YAMAHA_DEVICE(0x7010, "UB99"),
491#undef YAMAHA_DEVICE
492#undef YAMAHA_INTERFACE
493/* this catches most recent vendor-specific Yamaha devices */
494{
495        .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
496                       USB_DEVICE_ID_MATCH_INT_CLASS,
497        .idVendor = 0x0499,
498        .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
499        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
500                .ifnum = QUIRK_ANY_INTERFACE,
501                .type = QUIRK_AUTODETECT
502        }
503},
504
505/*
506 * Roland/RolandED/Edirol/BOSS devices
507 */
508{
509        USB_DEVICE(0x0582, 0x0000),
510        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
511                .vendor_name = "Roland",
512                .product_name = "UA-100",
513                .ifnum = QUIRK_ANY_INTERFACE,
514                .type = QUIRK_COMPOSITE,
515                .data = (const struct snd_usb_audio_quirk[]) {
516                        {
517                                .ifnum = 0,
518                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
519                                .data = & (const struct audioformat) {
520                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
521                                        .channels = 4,
522                                        .iface = 0,
523                                        .altsetting = 1,
524                                        .altset_idx = 1,
525                                        .attributes = 0,
526                                        .endpoint = 0x01,
527                                        .ep_attr = 0x09,
528                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
529                                        .rate_min = 44100,
530                                        .rate_max = 44100,
531                                }
532                        },
533                        {
534                                .ifnum = 1,
535                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
536                                .data = & (const struct audioformat) {
537                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
538                                        .channels = 2,
539                                        .iface = 1,
540                                        .altsetting = 1,
541                                        .altset_idx = 1,
542                                        .attributes = UAC_EP_CS_ATTR_FILL_MAX,
543                                        .endpoint = 0x81,
544                                        .ep_attr = 0x05,
545                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
546                                        .rate_min = 44100,
547                                        .rate_max = 44100,
548                                }
549                        },
550                        {
551                                .ifnum = 2,
552                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
553                                .data = & (const struct snd_usb_midi_endpoint_info) {
554                                        .out_cables = 0x0007,
555                                        .in_cables  = 0x0007
556                                }
557                        },
558                        {
559                                .ifnum = -1
560                        }
561                }
562        }
563},
564{
565        USB_DEVICE(0x0582, 0x0002),
566        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
567                .vendor_name = "EDIROL",
568                .product_name = "UM-4",
569                .ifnum = QUIRK_ANY_INTERFACE,
570                .type = QUIRK_COMPOSITE,
571                .data = (const struct snd_usb_audio_quirk[]) {
572                        {
573                                .ifnum = 0,
574                                .type = QUIRK_IGNORE_INTERFACE
575                        },
576                        {
577                                .ifnum = 1,
578                                .type = QUIRK_IGNORE_INTERFACE
579                        },
580                        {
581                                .ifnum = 2,
582                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
583                                .data = & (const struct snd_usb_midi_endpoint_info) {
584                                        .out_cables = 0x000f,
585                                        .in_cables  = 0x000f
586                                }
587                        },
588                        {
589                                .ifnum = -1
590                        }
591                }
592        }
593},
594{
595        USB_DEVICE(0x0582, 0x0003),
596        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
597                .vendor_name = "Roland",
598                .product_name = "SC-8850",
599                .ifnum = QUIRK_ANY_INTERFACE,
600                .type = QUIRK_COMPOSITE,
601                .data = (const struct snd_usb_audio_quirk[]) {
602                        {
603                                .ifnum = 0,
604                                .type = QUIRK_IGNORE_INTERFACE
605                        },
606                        {
607                                .ifnum = 1,
608                                .type = QUIRK_IGNORE_INTERFACE
609                        },
610                        {
611                                .ifnum = 2,
612                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
613                                .data = & (const struct snd_usb_midi_endpoint_info) {
614                                        .out_cables = 0x003f,
615                                        .in_cables  = 0x003f
616                                }
617                        },
618                        {
619                                .ifnum = -1
620                        }
621                }
622        }
623},
624{
625        USB_DEVICE(0x0582, 0x0004),
626        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
627                .vendor_name = "Roland",
628                .product_name = "U-8",
629                .ifnum = QUIRK_ANY_INTERFACE,
630                .type = QUIRK_COMPOSITE,
631                .data = (const struct snd_usb_audio_quirk[]) {
632                        {
633                                .ifnum = 0,
634                                .type = QUIRK_IGNORE_INTERFACE
635                        },
636                        {
637                                .ifnum = 1,
638                                .type = QUIRK_IGNORE_INTERFACE
639                        },
640                        {
641                                .ifnum = 2,
642                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
643                                .data = & (const struct snd_usb_midi_endpoint_info) {
644                                        .out_cables = 0x0005,
645                                        .in_cables  = 0x0005
646                                }
647                        },
648                        {
649                                .ifnum = -1
650                        }
651                }
652        }
653},
654{
655        /* Has ID 0x0099 when not in "Advanced Driver" mode.
656         * The UM-2EX has only one input, but we cannot detect this. */
657        USB_DEVICE(0x0582, 0x0005),
658        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
659                .vendor_name = "EDIROL",
660                .product_name = "UM-2",
661                .ifnum = QUIRK_ANY_INTERFACE,
662                .type = QUIRK_COMPOSITE,
663                .data = (const struct snd_usb_audio_quirk[]) {
664                        {
665                                .ifnum = 0,
666                                .type = QUIRK_IGNORE_INTERFACE
667                        },
668                        {
669                                .ifnum = 1,
670                                .type = QUIRK_IGNORE_INTERFACE
671                        },
672                        {
673                                .ifnum = 2,
674                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
675                                .data = & (const struct snd_usb_midi_endpoint_info) {
676                                        .out_cables = 0x0003,
677                                        .in_cables  = 0x0003
678                                }
679                        },
680                        {
681                                .ifnum = -1
682                        }
683                }
684        }
685},
686{
687        USB_DEVICE(0x0582, 0x0007),
688        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
689                .vendor_name = "Roland",
690                .product_name = "SC-8820",
691                .ifnum = QUIRK_ANY_INTERFACE,
692                .type = QUIRK_COMPOSITE,
693                .data = (const struct snd_usb_audio_quirk[]) {
694                        {
695                                .ifnum = 0,
696                                .type = QUIRK_IGNORE_INTERFACE
697                        },
698                        {
699                                .ifnum = 1,
700                                .type = QUIRK_IGNORE_INTERFACE
701                        },
702                        {
703                                .ifnum = 2,
704                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
705                                .data = & (const struct snd_usb_midi_endpoint_info) {
706                                        .out_cables = 0x0013,
707                                        .in_cables  = 0x0013
708                                }
709                        },
710                        {
711                                .ifnum = -1
712                        }
713                }
714        }
715},
716{
717        USB_DEVICE(0x0582, 0x0008),
718        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
719                .vendor_name = "Roland",
720                .product_name = "PC-300",
721                .ifnum = QUIRK_ANY_INTERFACE,
722                .type = QUIRK_COMPOSITE,
723                .data = (const struct snd_usb_audio_quirk[]) {
724                        {
725                                .ifnum = 0,
726                                .type = QUIRK_IGNORE_INTERFACE
727                        },
728                        {
729                                .ifnum = 1,
730                                .type = QUIRK_IGNORE_INTERFACE
731                        },
732                        {
733                                .ifnum = 2,
734                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
735                                .data = & (const struct snd_usb_midi_endpoint_info) {
736                                        .out_cables = 0x0001,
737                                        .in_cables  = 0x0001
738                                }
739                        },
740                        {
741                                .ifnum = -1
742                        }
743                }
744        }
745},
746{
747        /* has ID 0x009d when not in "Advanced Driver" mode */
748        USB_DEVICE(0x0582, 0x0009),
749        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
750                .vendor_name = "EDIROL",
751                .product_name = "UM-1",
752                .ifnum = QUIRK_ANY_INTERFACE,
753                .type = QUIRK_COMPOSITE,
754                .data = (const struct snd_usb_audio_quirk[]) {
755                        {
756                                .ifnum = 0,
757                                .type = QUIRK_IGNORE_INTERFACE
758                        },
759                        {
760                                .ifnum = 1,
761                                .type = QUIRK_IGNORE_INTERFACE
762                        },
763                        {
764                                .ifnum = 2,
765                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
766                                .data = & (const struct snd_usb_midi_endpoint_info) {
767                                        .out_cables = 0x0001,
768                                        .in_cables  = 0x0001
769                                }
770                        },
771                        {
772                                .ifnum = -1
773                        }
774                }
775        }
776},
777{
778        USB_DEVICE(0x0582, 0x000b),
779        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
780                .vendor_name = "Roland",
781                .product_name = "SK-500",
782                .ifnum = QUIRK_ANY_INTERFACE,
783                .type = QUIRK_COMPOSITE,
784                .data = (const struct snd_usb_audio_quirk[]) {
785                        {
786                                .ifnum = 0,
787                                .type = QUIRK_IGNORE_INTERFACE
788                        },
789                        {
790                                .ifnum = 1,
791                                .type = QUIRK_IGNORE_INTERFACE
792                        },
793                        {
794                                .ifnum = 2,
795                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
796                                .data = & (const struct snd_usb_midi_endpoint_info) {
797                                        .out_cables = 0x0013,
798                                        .in_cables  = 0x0013
799                                }
800                        },
801                        {
802                                .ifnum = -1
803                        }
804                }
805        }
806},
807{
808        /* thanks to Emiliano Grilli <emillo@libero.it>
809         * for helping researching this data */
810        USB_DEVICE(0x0582, 0x000c),
811        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
812                .vendor_name = "Roland",
813                .product_name = "SC-D70",
814                .ifnum = QUIRK_ANY_INTERFACE,
815                .type = QUIRK_COMPOSITE,
816                .data = (const struct snd_usb_audio_quirk[]) {
817                        {
818                                .ifnum = 0,
819                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
820                                .data = & (const struct audioformat) {
821                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
822                                        .channels = 2,
823                                        .iface = 0,
824                                        .altsetting = 1,
825                                        .altset_idx = 1,
826                                        .attributes = 0,
827                                        .endpoint = 0x01,
828                                        .ep_attr = 0x01,
829                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
830                                        .rate_min = 44100,
831                                        .rate_max = 44100,
832                                }
833                        },
834                        {
835                                .ifnum = 1,
836                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
837                                .data = & (const struct audioformat) {
838                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
839                                        .channels = 2,
840                                        .iface = 1,
841                                        .altsetting = 1,
842                                        .altset_idx = 1,
843                                        .attributes = 0,
844                                        .endpoint = 0x81,
845                                        .ep_attr = 0x01,
846                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
847                                        .rate_min = 44100,
848                                        .rate_max = 44100,
849                                }
850                        },
851                        {
852                                .ifnum = 2,
853                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
854                                .data = & (const struct snd_usb_midi_endpoint_info) {
855                                        .out_cables = 0x0007,
856                                        .in_cables  = 0x0007
857                                }
858                        },
859                        {
860                                .ifnum = -1
861                        }
862                }
863        }
864},
865{       /*
866         * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
867         * If the advanced mode switch at the back of the unit is off, the
868         * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
869         * but offers only 16-bit PCM.
870         * In advanced mode, the UA-5 will output S24_3LE samples (two
871         * channels) at the rate indicated on the front switch, including
872         * the 96kHz sample rate.
873         */
874        USB_DEVICE(0x0582, 0x0010),
875        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
876                .vendor_name = "EDIROL",
877                .product_name = "UA-5",
878                .ifnum = QUIRK_ANY_INTERFACE,
879                .type = QUIRK_COMPOSITE,
880                .data = (const struct snd_usb_audio_quirk[]) {
881                        {
882                                .ifnum = 1,
883                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
884                        },
885                        {
886                                .ifnum = 2,
887                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
888                        },
889                        {
890                                .ifnum = -1
891                        }
892                }
893        }
894},
895{
896        /* has ID 0x0013 when not in "Advanced Driver" mode */
897        USB_DEVICE(0x0582, 0x0012),
898        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
899                .vendor_name = "Roland",
900                .product_name = "XV-5050",
901                .ifnum = 0,
902                .type = QUIRK_MIDI_FIXED_ENDPOINT,
903                .data = & (const struct snd_usb_midi_endpoint_info) {
904                        .out_cables = 0x0001,
905                        .in_cables  = 0x0001
906                }
907        }
908},
909{
910        /* has ID 0x0015 when not in "Advanced Driver" mode */
911        USB_DEVICE(0x0582, 0x0014),
912        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
913                .vendor_name = "EDIROL",
914                .product_name = "UM-880",
915                .ifnum = 0,
916                .type = QUIRK_MIDI_FIXED_ENDPOINT,
917                .data = & (const struct snd_usb_midi_endpoint_info) {
918                        .out_cables = 0x01ff,
919                        .in_cables  = 0x01ff
920                }
921        }
922},
923{
924        /* has ID 0x0017 when not in "Advanced Driver" mode */
925        USB_DEVICE(0x0582, 0x0016),
926        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
927                .vendor_name = "EDIROL",
928                .product_name = "SD-90",
929                .ifnum = QUIRK_ANY_INTERFACE,
930                .type = QUIRK_COMPOSITE,
931                .data = (const struct snd_usb_audio_quirk[]) {
932                        {
933                                .ifnum = 0,
934                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
935                        },
936                        {
937                                .ifnum = 1,
938                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
939                        },
940                        {
941                                .ifnum = 2,
942                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
943                                .data = & (const struct snd_usb_midi_endpoint_info) {
944                                        .out_cables = 0x000f,
945                                        .in_cables  = 0x000f
946                                }
947                        },
948                        {
949                                .ifnum = -1
950                        }
951                }
952        }
953},
954{
955        /* has ID 0x001c when not in "Advanced Driver" mode */
956        USB_DEVICE(0x0582, 0x001b),
957        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
958                .vendor_name = "Roland",
959                .product_name = "MMP-2",
960                .ifnum = QUIRK_ANY_INTERFACE,
961                .type = QUIRK_COMPOSITE,
962                .data = (const struct snd_usb_audio_quirk[]) {
963                        {
964                                .ifnum = 0,
965                                .type = QUIRK_IGNORE_INTERFACE
966                        },
967                        {
968                                .ifnum = 1,
969                                .type = QUIRK_IGNORE_INTERFACE
970                        },
971                        {
972                                .ifnum = 2,
973                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
974                                .data = & (const struct snd_usb_midi_endpoint_info) {
975                                        .out_cables = 0x0001,
976                                        .in_cables  = 0x0001
977                                }
978                        },
979                        {
980                                .ifnum = -1
981                        }
982                }
983        }
984},
985{
986        /* has ID 0x001e when not in "Advanced Driver" mode */
987        USB_DEVICE(0x0582, 0x001d),
988        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
989                .vendor_name = "Roland",
990                .product_name = "V-SYNTH",
991                .ifnum = 0,
992                .type = QUIRK_MIDI_FIXED_ENDPOINT,
993                .data = & (const struct snd_usb_midi_endpoint_info) {
994                        .out_cables = 0x0001,
995                        .in_cables  = 0x0001
996                }
997        }
998},
999{
1000        /* has ID 0x0024 when not in "Advanced Driver" mode */
1001        USB_DEVICE(0x0582, 0x0023),
1002        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1003                .vendor_name = "EDIROL",
1004                .product_name = "UM-550",
1005                .ifnum = 0,
1006                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1007                .data = & (const struct snd_usb_midi_endpoint_info) {
1008                        .out_cables = 0x003f,
1009                        .in_cables  = 0x003f
1010                }
1011        }
1012},
1013{
1014        /*
1015         * This quirk is for the "Advanced Driver" mode. If off, the UA-20
1016         * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
1017         * and no MIDI.
1018         */
1019        USB_DEVICE(0x0582, 0x0025),
1020        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1021                .vendor_name = "EDIROL",
1022                .product_name = "UA-20",
1023                .ifnum = QUIRK_ANY_INTERFACE,
1024                .type = QUIRK_COMPOSITE,
1025                .data = (const struct snd_usb_audio_quirk[]) {
1026                        {
1027                                .ifnum = 0,
1028                                .type = QUIRK_IGNORE_INTERFACE
1029                        },
1030                        {
1031                                .ifnum = 1,
1032                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1033                                .data = & (const struct audioformat) {
1034                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
1035                                        .channels = 2,
1036                                        .iface = 1,
1037                                        .altsetting = 1,
1038                                        .altset_idx = 1,
1039                                        .attributes = 0,
1040                                        .endpoint = 0x01,
1041                                        .ep_attr = 0x01,
1042                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
1043                                        .rate_min = 44100,
1044                                        .rate_max = 44100,
1045                                }
1046                        },
1047                        {
1048                                .ifnum = 2,
1049                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1050                                .data = & (const struct audioformat) {
1051                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
1052                                        .channels = 2,
1053                                        .iface = 2,
1054                                        .altsetting = 1,
1055                                        .altset_idx = 1,
1056                                        .attributes = 0,
1057                                        .endpoint = 0x82,
1058                                        .ep_attr = 0x01,
1059                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
1060                                        .rate_min = 44100,
1061                                        .rate_max = 44100,
1062                                }
1063                        },
1064                        {
1065                                .ifnum = 3,
1066                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1067                                .data = & (const struct snd_usb_midi_endpoint_info) {
1068                                        .out_cables = 0x0001,
1069                                        .in_cables  = 0x0001
1070                                }
1071                        },
1072                        {
1073                                .ifnum = -1
1074                        }
1075                }
1076        }
1077},
1078{
1079        /* has ID 0x0028 when not in "Advanced Driver" mode */
1080        USB_DEVICE(0x0582, 0x0027),
1081        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1082                .vendor_name = "EDIROL",
1083                .product_name = "SD-20",
1084                .ifnum = 0,
1085                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1086                .data = & (const struct snd_usb_midi_endpoint_info) {
1087                        .out_cables = 0x0003,
1088                        .in_cables  = 0x0007
1089                }
1090        }
1091},
1092{
1093        /* has ID 0x002a when not in "Advanced Driver" mode */
1094        USB_DEVICE(0x0582, 0x0029),
1095        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1096                .vendor_name = "EDIROL",
1097                .product_name = "SD-80",
1098                .ifnum = 0,
1099                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1100                .data = & (const struct snd_usb_midi_endpoint_info) {
1101                        .out_cables = 0x000f,
1102                        .in_cables  = 0x000f
1103                }
1104        }
1105},
1106{       /*
1107         * This quirk is for the "Advanced" modes of the Edirol UA-700.
1108         * If the sample format switch is not in an advanced setting, the
1109         * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
1110         * but offers only 16-bit PCM and no MIDI.
1111         */
1112        USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
1113        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1114                .vendor_name = "EDIROL",
1115                .product_name = "UA-700",
1116                .ifnum = QUIRK_ANY_INTERFACE,
1117                .type = QUIRK_COMPOSITE,
1118                .data = (const struct snd_usb_audio_quirk[]) {
1119                        {
1120                                .ifnum = 1,
1121                                .type = QUIRK_AUDIO_EDIROL_UAXX
1122                        },
1123                        {
1124                                .ifnum = 2,
1125                                .type = QUIRK_AUDIO_EDIROL_UAXX
1126                        },
1127                        {
1128                                .ifnum = 3,
1129                                .type = QUIRK_AUDIO_EDIROL_UAXX
1130                        },
1131                        {
1132                                .ifnum = -1
1133                        }
1134                }
1135        }
1136},
1137{
1138        /* has ID 0x002e when not in "Advanced Driver" mode */
1139        USB_DEVICE(0x0582, 0x002d),
1140        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1141                .vendor_name = "Roland",
1142                .product_name = "XV-2020",
1143                .ifnum = 0,
1144                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1145                .data = & (const struct snd_usb_midi_endpoint_info) {
1146                        .out_cables = 0x0001,
1147                        .in_cables  = 0x0001
1148                }
1149        }
1150},
1151{
1152        /* has ID 0x0030 when not in "Advanced Driver" mode */
1153        USB_DEVICE(0x0582, 0x002f),
1154        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1155                .vendor_name = "Roland",
1156                .product_name = "VariOS",
1157                .ifnum = 0,
1158                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1159                .data = & (const struct snd_usb_midi_endpoint_info) {
1160                        .out_cables = 0x0007,
1161                        .in_cables  = 0x0007
1162                }
1163        }
1164},
1165{
1166        /* has ID 0x0034 when not in "Advanced Driver" mode */
1167        USB_DEVICE(0x0582, 0x0033),
1168        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1169                .vendor_name = "EDIROL",
1170                .product_name = "PCR",
1171                .ifnum = 0,
1172                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1173                .data = & (const struct snd_usb_midi_endpoint_info) {
1174                        .out_cables = 0x0003,
1175                        .in_cables  = 0x0007
1176                }
1177        }
1178},
1179{
1180        /*
1181         * Has ID 0x0038 when not in "Advanced Driver" mode;
1182         * later revisions use IDs 0x0054 and 0x00a2.
1183         */
1184        USB_DEVICE(0x0582, 0x0037),
1185        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1186                .vendor_name = "Roland",
1187                .product_name = "Digital Piano",
1188                .ifnum = 0,
1189                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1190                .data = & (const struct snd_usb_midi_endpoint_info) {
1191                        .out_cables = 0x0001,
1192                        .in_cables  = 0x0001
1193                }
1194        }
1195},
1196{
1197        /*
1198         * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
1199         * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1200         * and no MIDI.
1201         */
1202        USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1203        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1204                .vendor_name = "BOSS",
1205                .product_name = "GS-10",
1206                .ifnum = QUIRK_ANY_INTERFACE,
1207                .type = QUIRK_COMPOSITE,
1208                .data = & (const struct snd_usb_audio_quirk[]) {
1209                        {
1210                                .ifnum = 1,
1211                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1212                        },
1213                        {
1214                                .ifnum = 2,
1215                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1216                        },
1217                        {
1218                                .ifnum = 3,
1219                                .type = QUIRK_MIDI_STANDARD_INTERFACE
1220                        },
1221                        {
1222                                .ifnum = -1
1223                        }
1224                }
1225        }
1226},
1227{
1228        /* has ID 0x0041 when not in "Advanced Driver" mode */
1229        USB_DEVICE(0x0582, 0x0040),
1230        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1231                .vendor_name = "Roland",
1232                .product_name = "GI-20",
1233                .ifnum = 0,
1234                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1235                .data = & (const struct snd_usb_midi_endpoint_info) {
1236                        .out_cables = 0x0001,
1237                        .in_cables  = 0x0001
1238                }
1239        }
1240},
1241{
1242        /* has ID 0x0043 when not in "Advanced Driver" mode */
1243        USB_DEVICE(0x0582, 0x0042),
1244        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1245                .vendor_name = "Roland",
1246                .product_name = "RS-70",
1247                .ifnum = 0,
1248                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1249                .data = & (const struct snd_usb_midi_endpoint_info) {
1250                        .out_cables = 0x0001,
1251                        .in_cables  = 0x0001
1252                }
1253        }
1254},
1255{
1256        /* has ID 0x0049 when not in "Advanced Driver" mode */
1257        USB_DEVICE(0x0582, 0x0047),
1258        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1259                /* .vendor_name = "EDIROL", */
1260                /* .product_name = "UR-80", */
1261                .ifnum = QUIRK_ANY_INTERFACE,
1262                .type = QUIRK_COMPOSITE,
1263                .data = (const struct snd_usb_audio_quirk[]) {
1264                        /* in the 96 kHz modes, only interface 1 is there */
1265                        {
1266                                .ifnum = 1,
1267                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1268                        },
1269                        {
1270                                .ifnum = 2,
1271                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1272                        },
1273                        {
1274                                .ifnum = -1
1275                        }
1276                }
1277        }
1278},
1279{
1280        /* has ID 0x004a when not in "Advanced Driver" mode */
1281        USB_DEVICE(0x0582, 0x0048),
1282        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1283                /* .vendor_name = "EDIROL", */
1284                /* .product_name = "UR-80", */
1285                .ifnum = 0,
1286                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1287                .data = & (const struct snd_usb_midi_endpoint_info) {
1288                        .out_cables = 0x0003,
1289                        .in_cables  = 0x0007
1290                }
1291        }
1292},
1293{
1294        /* has ID 0x004e when not in "Advanced Driver" mode */
1295        USB_DEVICE(0x0582, 0x004c),
1296        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1297                .vendor_name = "EDIROL",
1298                .product_name = "PCR-A",
1299                .ifnum = QUIRK_ANY_INTERFACE,
1300                .type = QUIRK_COMPOSITE,
1301                .data = (const struct snd_usb_audio_quirk[]) {
1302                        {
1303                                .ifnum = 1,
1304                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1305                        },
1306                        {
1307                                .ifnum = 2,
1308                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1309                        },
1310                        {
1311                                .ifnum = -1
1312                        }
1313                }
1314        }
1315},
1316{
1317        /* has ID 0x004f when not in "Advanced Driver" mode */
1318        USB_DEVICE(0x0582, 0x004d),
1319        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1320                .vendor_name = "EDIROL",
1321                .product_name = "PCR-A",
1322                .ifnum = 0,
1323                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1324                .data = & (const struct snd_usb_midi_endpoint_info) {
1325                        .out_cables = 0x0003,
1326                        .in_cables  = 0x0007
1327                }
1328        }
1329},
1330{
1331        /*
1332         * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1333         * is standard compliant, but has only 16-bit PCM.
1334         */
1335        USB_DEVICE(0x0582, 0x0050),
1336        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1337                .vendor_name = "EDIROL",
1338                .product_name = "UA-3FX",
1339                .ifnum = QUIRK_ANY_INTERFACE,
1340                .type = QUIRK_COMPOSITE,
1341                .data = (const struct snd_usb_audio_quirk[]) {
1342                        {
1343                                .ifnum = 1,
1344                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1345                        },
1346                        {
1347                                .ifnum = 2,
1348                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1349                        },
1350                        {
1351                                .ifnum = -1
1352                        }
1353                }
1354        }
1355},
1356{
1357        USB_DEVICE(0x0582, 0x0052),
1358        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1359                .vendor_name = "EDIROL",
1360                .product_name = "UM-1SX",
1361                .ifnum = 0,
1362                .type = QUIRK_MIDI_STANDARD_INTERFACE
1363        }
1364},
1365{
1366        USB_DEVICE(0x0582, 0x0060),
1367        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1368                .vendor_name = "Roland",
1369                .product_name = "EXR Series",
1370                .ifnum = 0,
1371                .type = QUIRK_MIDI_STANDARD_INTERFACE
1372        }
1373},
1374{
1375        /* has ID 0x0066 when not in "Advanced Driver" mode */
1376        USB_DEVICE(0x0582, 0x0064),
1377        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1378                /* .vendor_name = "EDIROL", */
1379                /* .product_name = "PCR-1", */
1380                .ifnum = QUIRK_ANY_INTERFACE,
1381                .type = QUIRK_COMPOSITE,
1382                .data = (const struct snd_usb_audio_quirk[]) {
1383                        {
1384                                .ifnum = 1,
1385                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1386                        },
1387                        {
1388                                .ifnum = 2,
1389                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1390                        },
1391                        {
1392                                .ifnum = -1
1393                        }
1394                }
1395        }
1396},
1397{
1398        /* has ID 0x0067 when not in "Advanced Driver" mode */
1399        USB_DEVICE(0x0582, 0x0065),
1400        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1401                /* .vendor_name = "EDIROL", */
1402                /* .product_name = "PCR-1", */
1403                .ifnum = 0,
1404                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1405                .data = & (const struct snd_usb_midi_endpoint_info) {
1406                        .out_cables = 0x0001,
1407                        .in_cables  = 0x0003
1408                }
1409        }
1410},
1411{
1412        /* has ID 0x006e when not in "Advanced Driver" mode */
1413        USB_DEVICE(0x0582, 0x006d),
1414        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1415                .vendor_name = "Roland",
1416                .product_name = "FANTOM-X",
1417                .ifnum = 0,
1418                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1419                .data = & (const struct snd_usb_midi_endpoint_info) {
1420                        .out_cables = 0x0001,
1421                        .in_cables  = 0x0001
1422                }
1423        }
1424},
1425{       /*
1426         * This quirk is for the "Advanced" modes of the Edirol UA-25.
1427         * If the switch is not in an advanced setting, the UA-25 has
1428         * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1429         * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1430         */
1431        USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1432        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1433                .vendor_name = "EDIROL",
1434                .product_name = "UA-25",
1435                .ifnum = QUIRK_ANY_INTERFACE,
1436                .type = QUIRK_COMPOSITE,
1437                .data = (const struct snd_usb_audio_quirk[]) {
1438                        {
1439                                .ifnum = 0,
1440                                .type = QUIRK_AUDIO_EDIROL_UAXX
1441                        },
1442                        {
1443                                .ifnum = 1,
1444                                .type = QUIRK_AUDIO_EDIROL_UAXX
1445                        },
1446                        {
1447                                .ifnum = 2,
1448                                .type = QUIRK_AUDIO_EDIROL_UAXX
1449                        },
1450                        {
1451                                .ifnum = -1
1452                        }
1453                }
1454        }
1455},
1456{
1457        /* has ID 0x0076 when not in "Advanced Driver" mode */
1458        USB_DEVICE(0x0582, 0x0075),
1459        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1460                .vendor_name = "BOSS",
1461                .product_name = "DR-880",
1462                .ifnum = 0,
1463                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1464                .data = & (const struct snd_usb_midi_endpoint_info) {
1465                        .out_cables = 0x0001,
1466                        .in_cables  = 0x0001
1467                }
1468        }
1469},
1470{
1471        /* has ID 0x007b when not in "Advanced Driver" mode */
1472        USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1473        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1474                .vendor_name = "Roland",
1475                /* "RD" or "RD-700SX"? */
1476                .ifnum = 0,
1477                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1478                .data = & (const struct snd_usb_midi_endpoint_info) {
1479                        .out_cables = 0x0003,
1480                        .in_cables  = 0x0003
1481                }
1482        }
1483},
1484{
1485        /* has ID 0x0081 when not in "Advanced Driver" mode */
1486        USB_DEVICE(0x0582, 0x0080),
1487        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1488                .vendor_name = "Roland",
1489                .product_name = "G-70",
1490                .ifnum = 0,
1491                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1492                .data = & (const struct snd_usb_midi_endpoint_info) {
1493                        .out_cables = 0x0001,
1494                        .in_cables  = 0x0001
1495                }
1496        }
1497},
1498{
1499        /* has ID 0x008c when not in "Advanced Driver" mode */
1500        USB_DEVICE(0x0582, 0x008b),
1501        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1502                .vendor_name = "EDIROL",
1503                .product_name = "PC-50",
1504                .ifnum = 0,
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{
1513        /*
1514         * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1515         * is standard compliant, but has only 16-bit PCM and no MIDI.
1516         */
1517        USB_DEVICE(0x0582, 0x00a3),
1518        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1519                .vendor_name = "EDIROL",
1520                .product_name = "UA-4FX",
1521                .ifnum = QUIRK_ANY_INTERFACE,
1522                .type = QUIRK_COMPOSITE,
1523                .data = (const struct snd_usb_audio_quirk[]) {
1524                        {
1525                                .ifnum = 0,
1526                                .type = QUIRK_AUDIO_EDIROL_UAXX
1527                        },
1528                        {
1529                                .ifnum = 1,
1530                                .type = QUIRK_AUDIO_EDIROL_UAXX
1531                        },
1532                        {
1533                                .ifnum = 2,
1534                                .type = QUIRK_AUDIO_EDIROL_UAXX
1535                        },
1536                        {
1537                                .ifnum = -1
1538                        }
1539                }
1540        }
1541},
1542{
1543        /* Edirol M-16DX */
1544        USB_DEVICE(0x0582, 0x00c4),
1545        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1546                .ifnum = QUIRK_ANY_INTERFACE,
1547                .type = QUIRK_COMPOSITE,
1548                .data = (const struct snd_usb_audio_quirk[]) {
1549                        {
1550                                .ifnum = 0,
1551                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1552                        },
1553                        {
1554                                .ifnum = 1,
1555                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1556                        },
1557                        {
1558                                .ifnum = 2,
1559                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1560                                .data = & (const struct snd_usb_midi_endpoint_info) {
1561                                        .out_cables = 0x0001,
1562                                        .in_cables  = 0x0001
1563                                }
1564                        },
1565                        {
1566                                .ifnum = -1
1567                        }
1568                }
1569        }
1570},
1571{
1572        /* Advanced modes of the Edirol UA-25EX.
1573         * For the standard mode, UA-25EX has ID 0582:00e7, which
1574         * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1575         */
1576        USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1577        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1578                .vendor_name = "EDIROL",
1579                .product_name = "UA-25EX",
1580                .ifnum = QUIRK_ANY_INTERFACE,
1581                .type = QUIRK_COMPOSITE,
1582                .data = (const struct snd_usb_audio_quirk[]) {
1583                        {
1584                                .ifnum = 0,
1585                                .type = QUIRK_AUDIO_EDIROL_UAXX
1586                        },
1587                        {
1588                                .ifnum = 1,
1589                                .type = QUIRK_AUDIO_EDIROL_UAXX
1590                        },
1591                        {
1592                                .ifnum = 2,
1593                                .type = QUIRK_AUDIO_EDIROL_UAXX
1594                        },
1595                        {
1596                                .ifnum = -1
1597                        }
1598                }
1599        }
1600},
1601{
1602        /* Edirol UM-3G */
1603        USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1604        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1605                .ifnum = 0,
1606                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1607                .data = & (const struct snd_usb_midi_endpoint_info) {
1608                        .out_cables = 0x0007,
1609                        .in_cables  = 0x0007
1610                }
1611        }
1612},
1613{
1614        /* BOSS ME-25 */
1615        USB_DEVICE(0x0582, 0x0113),
1616        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1617                .ifnum = QUIRK_ANY_INTERFACE,
1618                .type = QUIRK_COMPOSITE,
1619                .data = (const struct snd_usb_audio_quirk[]) {
1620                        {
1621                                .ifnum = 0,
1622                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1623                        },
1624                        {
1625                                .ifnum = 1,
1626                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1627                        },
1628                        {
1629                                .ifnum = 2,
1630                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1631                                .data = & (const struct snd_usb_midi_endpoint_info) {
1632                                        .out_cables = 0x0001,
1633                                        .in_cables  = 0x0001
1634                                }
1635                        },
1636                        {
1637                                .ifnum = -1
1638                        }
1639                }
1640        }
1641},
1642{
1643        /* only 44.1 kHz works at the moment */
1644        USB_DEVICE(0x0582, 0x0120),
1645        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1646                /* .vendor_name = "Roland", */
1647                /* .product_name = "OCTO-CAPTURE", */
1648                .ifnum = QUIRK_ANY_INTERFACE,
1649                .type = QUIRK_COMPOSITE,
1650                .data = (const struct snd_usb_audio_quirk[]) {
1651                        {
1652                                .ifnum = 0,
1653                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1654                                .data = & (const struct audioformat) {
1655                                        .formats = SNDRV_PCM_FMTBIT_S32_LE,
1656                                        .channels = 10,
1657                                        .iface = 0,
1658                                        .altsetting = 1,
1659                                        .altset_idx = 1,
1660                                        .endpoint = 0x05,
1661                                        .ep_attr = 0x05,
1662                                        .rates = SNDRV_PCM_RATE_44100,
1663                                        .rate_min = 44100,
1664                                        .rate_max = 44100,
1665                                        .nr_rates = 1,
1666                                        .rate_table = (unsigned int[]) { 44100 }
1667                                }
1668                        },
1669                        {
1670                                .ifnum = 1,
1671                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1672                                .data = & (const struct audioformat) {
1673                                        .formats = SNDRV_PCM_FMTBIT_S32_LE,
1674                                        .channels = 12,
1675                                        .iface = 1,
1676                                        .altsetting = 1,
1677                                        .altset_idx = 1,
1678                                        .endpoint = 0x85,
1679                                        .ep_attr = 0x25,
1680                                        .rates = SNDRV_PCM_RATE_44100,
1681                                        .rate_min = 44100,
1682                                        .rate_max = 44100,
1683                                        .nr_rates = 1,
1684                                        .rate_table = (unsigned int[]) { 44100 }
1685                                }
1686                        },
1687                        {
1688                                .ifnum = 2,
1689                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1690                                .data = & (const struct snd_usb_midi_endpoint_info) {
1691                                        .out_cables = 0x0001,
1692                                        .in_cables  = 0x0001
1693                                }
1694                        },
1695                        {
1696                                .ifnum = 3,
1697                                .type = QUIRK_IGNORE_INTERFACE
1698                        },
1699                        {
1700                                .ifnum = 4,
1701                                .type = QUIRK_IGNORE_INTERFACE
1702                        },
1703                        {
1704                                .ifnum = -1
1705                        }
1706                }
1707        }
1708},
1709{
1710        /* only 44.1 kHz works at the moment */
1711        USB_DEVICE(0x0582, 0x012f),
1712        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1713                /* .vendor_name = "Roland", */
1714                /* .product_name = "QUAD-CAPTURE", */
1715                .ifnum = QUIRK_ANY_INTERFACE,
1716                .type = QUIRK_COMPOSITE,
1717                .data = (const struct snd_usb_audio_quirk[]) {
1718                        {
1719                                .ifnum = 0,
1720                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1721                                .data = & (const struct audioformat) {
1722                                        .formats = SNDRV_PCM_FMTBIT_S32_LE,
1723                                        .channels = 4,
1724                                        .iface = 0,
1725                                        .altsetting = 1,
1726                                        .altset_idx = 1,
1727                                        .endpoint = 0x05,
1728                                        .ep_attr = 0x05,
1729                                        .rates = SNDRV_PCM_RATE_44100,
1730                                        .rate_min = 44100,
1731                                        .rate_max = 44100,
1732                                        .nr_rates = 1,
1733                                        .rate_table = (unsigned int[]) { 44100 }
1734                                }
1735                        },
1736                        {
1737                                .ifnum = 1,
1738                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1739                                .data = & (const struct audioformat) {
1740                                        .formats = SNDRV_PCM_FMTBIT_S32_LE,
1741                                        .channels = 6,
1742                                        .iface = 1,
1743                                        .altsetting = 1,
1744                                        .altset_idx = 1,
1745                                        .endpoint = 0x85,
1746                                        .ep_attr = 0x25,
1747                                        .rates = SNDRV_PCM_RATE_44100,
1748                                        .rate_min = 44100,
1749                                        .rate_max = 44100,
1750                                        .nr_rates = 1,
1751                                        .rate_table = (unsigned int[]) { 44100 }
1752                                }
1753                        },
1754                        {
1755                                .ifnum = 2,
1756                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1757                                .data = & (const struct snd_usb_midi_endpoint_info) {
1758                                        .out_cables = 0x0001,
1759                                        .in_cables  = 0x0001
1760                                }
1761                        },
1762                        {
1763                                .ifnum = 3,
1764                                .type = QUIRK_IGNORE_INTERFACE
1765                        },
1766                        {
1767                                .ifnum = 4,
1768                                .type = QUIRK_IGNORE_INTERFACE
1769                        },
1770                        {
1771                                .ifnum = -1
1772                        }
1773                }
1774        }
1775},
1776{
1777        USB_DEVICE(0x0582, 0x0159),
1778        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1779                /* .vendor_name = "Roland", */
1780                /* .product_name = "UA-22", */
1781                .ifnum = QUIRK_ANY_INTERFACE,
1782                .type = QUIRK_COMPOSITE,
1783                .data = (const struct snd_usb_audio_quirk[]) {
1784                        {
1785                                .ifnum = 0,
1786                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1787                        },
1788                        {
1789                                .ifnum = 1,
1790                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1791                        },
1792                        {
1793                                .ifnum = 2,
1794                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1795                                .data = & (const struct snd_usb_midi_endpoint_info) {
1796                                        .out_cables = 0x0001,
1797                                        .in_cables = 0x0001
1798                                }
1799                        },
1800                        {
1801                                .ifnum = -1
1802                        }
1803                }
1804        }
1805},
1806/* this catches most recent vendor-specific Roland devices */
1807{
1808        .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1809                       USB_DEVICE_ID_MATCH_INT_CLASS,
1810        .idVendor = 0x0582,
1811        .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1812        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1813                .ifnum = QUIRK_ANY_INTERFACE,
1814                .type = QUIRK_AUTODETECT
1815        }
1816},
1817
1818/* Guillemot devices */
1819{
1820        /*
1821         * This is for the "Windows Edition" where the external MIDI ports are
1822         * the only MIDI ports; the control data is reported through HID
1823         * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1824         * compliant USB MIDI ports for external MIDI and controls.
1825         */
1826        USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1827        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1828                .vendor_name = "Hercules",
1829                .product_name = "DJ Console (WE)",
1830                .ifnum = 4,
1831                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1832                .data = & (const struct snd_usb_midi_endpoint_info) {
1833                        .out_cables = 0x0001,
1834                        .in_cables = 0x0001
1835                }
1836        }
1837},
1838
1839/* Midiman/M-Audio devices */
1840{
1841        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1842        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1843                .vendor_name = "M-Audio",
1844                .product_name = "MidiSport 2x2",
1845                .ifnum = QUIRK_ANY_INTERFACE,
1846                .type = QUIRK_MIDI_MIDIMAN,
1847                .data = & (const struct snd_usb_midi_endpoint_info) {
1848                        .out_cables = 0x0003,
1849                        .in_cables  = 0x0003
1850                }
1851        }
1852},
1853{
1854        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1855        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1856                .vendor_name = "M-Audio",
1857                .product_name = "MidiSport 1x1",
1858                .ifnum = QUIRK_ANY_INTERFACE,
1859                .type = QUIRK_MIDI_MIDIMAN,
1860                .data = & (const struct snd_usb_midi_endpoint_info) {
1861                        .out_cables = 0x0001,
1862                        .in_cables  = 0x0001
1863                }
1864        }
1865},
1866{
1867        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1868        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1869                .vendor_name = "M-Audio",
1870                .product_name = "Keystation",
1871                .ifnum = QUIRK_ANY_INTERFACE,
1872                .type = QUIRK_MIDI_MIDIMAN,
1873                .data = & (const struct snd_usb_midi_endpoint_info) {
1874                        .out_cables = 0x0001,
1875                        .in_cables  = 0x0001
1876                }
1877        }
1878},
1879{
1880        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1881        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1882                .vendor_name = "M-Audio",
1883                .product_name = "MidiSport 4x4",
1884                .ifnum = QUIRK_ANY_INTERFACE,
1885                .type = QUIRK_MIDI_MIDIMAN,
1886                .data = & (const struct snd_usb_midi_endpoint_info) {
1887                        .out_cables = 0x000f,
1888                        .in_cables  = 0x000f
1889                }
1890        }
1891},
1892{
1893        /*
1894         * For hardware revision 1.05; in the later revisions (1.10 and
1895         * 1.21), 0x1031 is the ID for the device without firmware.
1896         * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1897         */
1898        USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1899        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1900                .vendor_name = "M-Audio",
1901                .product_name = "MidiSport 8x8",
1902                .ifnum = QUIRK_ANY_INTERFACE,
1903                .type = QUIRK_MIDI_MIDIMAN,
1904                .data = & (const struct snd_usb_midi_endpoint_info) {
1905                        .out_cables = 0x01ff,
1906                        .in_cables  = 0x01ff
1907                }
1908        }
1909},
1910{
1911        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1912        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1913                .vendor_name = "M-Audio",
1914                .product_name = "MidiSport 8x8",
1915                .ifnum = QUIRK_ANY_INTERFACE,
1916                .type = QUIRK_MIDI_MIDIMAN,
1917                .data = & (const struct snd_usb_midi_endpoint_info) {
1918                        .out_cables = 0x01ff,
1919                        .in_cables  = 0x01ff
1920                }
1921        }
1922},
1923{
1924        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1925        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1926                .vendor_name = "M-Audio",
1927                .product_name = "MidiSport 2x4",
1928                .ifnum = QUIRK_ANY_INTERFACE,
1929                .type = QUIRK_MIDI_MIDIMAN,
1930                .data = & (const struct snd_usb_midi_endpoint_info) {
1931                        .out_cables = 0x000f,
1932                        .in_cables  = 0x0003
1933                }
1934        }
1935},
1936{
1937        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1938        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1939                .vendor_name = "M-Audio",
1940                .product_name = "Quattro",
1941                .ifnum = QUIRK_ANY_INTERFACE,
1942                .type = QUIRK_COMPOSITE,
1943                .data = & (const struct snd_usb_audio_quirk[]) {
1944                        /*
1945                         * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1946                         * and share endpoints with the other interfaces.
1947                         * Ignore them.  The other interfaces can do 24 bits,
1948                         * but captured samples are big-endian (see usbaudio.c).
1949                         */
1950                        {
1951                                .ifnum = 0,
1952                                .type = QUIRK_IGNORE_INTERFACE
1953                        },
1954                        {
1955                                .ifnum = 1,
1956                                .type = QUIRK_IGNORE_INTERFACE
1957                        },
1958                        {
1959                                .ifnum = 2,
1960                                .type = QUIRK_IGNORE_INTERFACE
1961                        },
1962                        {
1963                                .ifnum = 3,
1964                                .type = QUIRK_IGNORE_INTERFACE
1965                        },
1966                        {
1967                                .ifnum = 4,
1968                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1969                        },
1970                        {
1971                                .ifnum = 5,
1972                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1973                        },
1974                        {
1975                                .ifnum = 6,
1976                                .type = QUIRK_IGNORE_INTERFACE
1977                        },
1978                        {
1979                                .ifnum = 7,
1980                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1981                        },
1982                        {
1983                                .ifnum = 8,
1984                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1985                        },
1986                        {
1987                                .ifnum = 9,
1988                                .type = QUIRK_MIDI_MIDIMAN,
1989                                .data = & (const struct snd_usb_midi_endpoint_info) {
1990                                        .out_cables = 0x0001,
1991                                        .in_cables  = 0x0001
1992                                }
1993                        },
1994                        {
1995                                .ifnum = -1
1996                        }
1997                }
1998        }
1999},
2000{
2001        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
2002        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2003                .vendor_name = "M-Audio",
2004                .product_name = "AudioPhile",
2005                .ifnum = 6,
2006                .type = QUIRK_MIDI_MIDIMAN,
2007                .data = & (const struct snd_usb_midi_endpoint_info) {
2008                        .out_cables = 0x0001,
2009                        .in_cables  = 0x0001
2010                }
2011        }
2012},
2013{
2014        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
2015        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2016                .vendor_name = "M-Audio",
2017                .product_name = "Ozone",
2018                .ifnum = 3,
2019                .type = QUIRK_MIDI_MIDIMAN,
2020                .data = & (const struct snd_usb_midi_endpoint_info) {
2021                        .out_cables = 0x0001,
2022                        .in_cables  = 0x0001
2023                }
2024        }
2025},
2026{
2027        USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
2028        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2029                .vendor_name = "M-Audio",
2030                .product_name = "OmniStudio",
2031                .ifnum = QUIRK_ANY_INTERFACE,
2032                .type = QUIRK_COMPOSITE,
2033                .data = & (const struct snd_usb_audio_quirk[]) {
2034                        {
2035                                .ifnum = 0,
2036                                .type = QUIRK_IGNORE_INTERFACE
2037                        },
2038                        {
2039                                .ifnum = 1,
2040                                .type = QUIRK_IGNORE_INTERFACE
2041                        },
2042                        {
2043                                .ifnum = 2,
2044                                .type = QUIRK_IGNORE_INTERFACE
2045                        },
2046                        {
2047                                .ifnum = 3,
2048                                .type = QUIRK_IGNORE_INTERFACE
2049                        },
2050                        {
2051                                .ifnum = 4,
2052                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2053                        },
2054                        {
2055                                .ifnum = 5,
2056                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2057                        },
2058                        {
2059                                .ifnum = 6,
2060                                .type = QUIRK_IGNORE_INTERFACE
2061                        },
2062                        {
2063                                .ifnum = 7,
2064                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2065                        },
2066                        {
2067                                .ifnum = 8,
2068                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2069                        },
2070                        {
2071                                .ifnum = 9,
2072                                .type = QUIRK_MIDI_MIDIMAN,
2073                                .data = & (const struct snd_usb_midi_endpoint_info) {
2074                                        .out_cables = 0x0001,
2075                                        .in_cables  = 0x0001
2076                                }
2077                        },
2078                        {
2079                                .ifnum = -1
2080                        }
2081                }
2082        }
2083},
2084{
2085        USB_DEVICE(0x0763, 0x2019),
2086        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2087                /* .vendor_name = "M-Audio", */
2088                /* .product_name = "Ozone Academic", */
2089                .ifnum = QUIRK_ANY_INTERFACE,
2090                .type = QUIRK_COMPOSITE,
2091                .data = & (const struct snd_usb_audio_quirk[]) {
2092                        {
2093                                .ifnum = 0,
2094                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2095                        },
2096                        {
2097                                .ifnum = 1,
2098                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2099                        },
2100                        {
2101                                .ifnum = 2,
2102                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2103                        },
2104                        {
2105                                .ifnum = 3,
2106                                .type = QUIRK_MIDI_MIDIMAN,
2107                                .data = & (const struct snd_usb_midi_endpoint_info) {
2108                                        .out_cables = 0x0001,
2109                                        .in_cables  = 0x0001
2110                                }
2111                        },
2112                        {
2113                                .ifnum = -1
2114                        }
2115                }
2116        }
2117},
2118{
2119        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2120        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2121                /* .vendor_name = "M-Audio", */
2122                /* .product_name = "Fast Track C400", */
2123                .ifnum = QUIRK_ANY_INTERFACE,
2124                .type = QUIRK_COMPOSITE,
2125                .data = &(const struct snd_usb_audio_quirk[]) {
2126                        {
2127                                .ifnum = 1,
2128                                .type = QUIRK_AUDIO_STANDARD_MIXER,
2129                        },
2130                        /* Playback */
2131                        {
2132                                .ifnum = 2,
2133                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2134                                .data = &(const struct audioformat) {
2135                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2136                                        .channels = 6,
2137                                        .iface = 2,
2138                                        .altsetting = 1,
2139                                        .altset_idx = 1,
2140                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2141                                        .endpoint = 0x01,
2142                                        .ep_attr = 0x09,
2143                                        .rates = SNDRV_PCM_RATE_44100 |
2144                                                 SNDRV_PCM_RATE_48000 |
2145                                                 SNDRV_PCM_RATE_88200 |
2146                                                 SNDRV_PCM_RATE_96000,
2147                                        .rate_min = 44100,
2148                                        .rate_max = 96000,
2149                                        .nr_rates = 4,
2150                                        .rate_table = (unsigned int[]) {
2151                                                        44100, 48000, 88200, 96000
2152                                        },
2153                                        .clock = 0x80,
2154                                }
2155                        },
2156                        /* Capture */
2157                        {
2158                                .ifnum = 3,
2159                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2160                                .data = &(const struct audioformat) {
2161                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2162                                        .channels = 4,
2163                                        .iface = 3,
2164                                        .altsetting = 1,
2165                                        .altset_idx = 1,
2166                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2167                                        .endpoint = 0x81,
2168                                        .ep_attr = 0x05,
2169                                        .rates = SNDRV_PCM_RATE_44100 |
2170                                                 SNDRV_PCM_RATE_48000 |
2171                                                 SNDRV_PCM_RATE_88200 |
2172                                                 SNDRV_PCM_RATE_96000,
2173                                        .rate_min = 44100,
2174                                        .rate_max = 96000,
2175                                        .nr_rates = 4,
2176                                        .rate_table = (unsigned int[]) {
2177                                                44100, 48000, 88200, 96000
2178                                        },
2179                                        .clock = 0x80,
2180                                }
2181                        },
2182                        /* MIDI */
2183                        {
2184                                .ifnum = -1 /* Interface = 4 */
2185                        }
2186                }
2187        }
2188},
2189{
2190        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2191        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2192                /* .vendor_name = "M-Audio", */
2193                /* .product_name = "Fast Track C600", */
2194                .ifnum = QUIRK_ANY_INTERFACE,
2195                .type = QUIRK_COMPOSITE,
2196                .data = &(const struct snd_usb_audio_quirk[]) {
2197                        {
2198                                .ifnum = 1,
2199                                .type = QUIRK_AUDIO_STANDARD_MIXER,
2200                        },
2201                        /* Playback */
2202                        {
2203                                .ifnum = 2,
2204                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2205                                .data = &(const struct audioformat) {
2206                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2207                                        .channels = 8,
2208                                        .iface = 2,
2209                                        .altsetting = 1,
2210                                        .altset_idx = 1,
2211                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2212                                        .endpoint = 0x01,
2213                                        .ep_attr = 0x09,
2214                                        .rates = SNDRV_PCM_RATE_44100 |
2215                                                 SNDRV_PCM_RATE_48000 |
2216                                                 SNDRV_PCM_RATE_88200 |
2217                                                 SNDRV_PCM_RATE_96000,
2218                                        .rate_min = 44100,
2219                                        .rate_max = 96000,
2220                                        .nr_rates = 4,
2221                                        .rate_table = (unsigned int[]) {
2222                                                        44100, 48000, 88200, 96000
2223                                        },
2224                                        .clock = 0x80,
2225                                }
2226                        },
2227                        /* Capture */
2228                        {
2229                                .ifnum = 3,
2230                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2231                                .data = &(const struct audioformat) {
2232                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2233                                        .channels = 6,
2234                                        .iface = 3,
2235                                        .altsetting = 1,
2236                                        .altset_idx = 1,
2237                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2238                                        .endpoint = 0x81,
2239                                        .ep_attr = 0x05,
2240                                        .rates = SNDRV_PCM_RATE_44100 |
2241                                                 SNDRV_PCM_RATE_48000 |
2242                                                 SNDRV_PCM_RATE_88200 |
2243                                                 SNDRV_PCM_RATE_96000,
2244                                        .rate_min = 44100,
2245                                        .rate_max = 96000,
2246                                        .nr_rates = 4,
2247                                        .rate_table = (unsigned int[]) {
2248                                                44100, 48000, 88200, 96000
2249                                        },
2250                                        .clock = 0x80,
2251                                }
2252                        },
2253                        /* MIDI */
2254                        {
2255                                .ifnum = -1 /* Interface = 4 */
2256                        }
2257                }
2258        }
2259},
2260{
2261        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2262        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2263                /* .vendor_name = "M-Audio", */
2264                /* .product_name = "Fast Track Ultra", */
2265                .ifnum = QUIRK_ANY_INTERFACE,
2266                .type = QUIRK_COMPOSITE,
2267                .data = & (const struct snd_usb_audio_quirk[]) {
2268                        {
2269                                .ifnum = 0,
2270                                .type = QUIRK_AUDIO_STANDARD_MIXER,
2271                        },
2272                        {
2273                                .ifnum = 1,
2274                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2275                                .data = & (const struct audioformat) {
2276                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2277                                        .channels = 8,
2278                                        .iface = 1,
2279                                        .altsetting = 1,
2280                                        .altset_idx = 1,
2281                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2282                                        .endpoint = 0x01,
2283                                        .ep_attr = 0x09,
2284                                        .rates = SNDRV_PCM_RATE_44100 |
2285                                                 SNDRV_PCM_RATE_48000 |
2286                                                 SNDRV_PCM_RATE_88200 |
2287                                                 SNDRV_PCM_RATE_96000,
2288                                        .rate_min = 44100,
2289                                        .rate_max = 96000,
2290                                        .nr_rates = 4,
2291                                        .rate_table = (unsigned int[]) {
2292                                                44100, 48000, 88200, 96000
2293                                        }
2294                                }
2295                        },
2296                        {
2297                                .ifnum = 2,
2298                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2299                                .data = & (const struct audioformat) {
2300                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2301                                        .channels = 8,
2302                                        .iface = 2,
2303                                        .altsetting = 1,
2304                                        .altset_idx = 1,
2305                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2306                                        .endpoint = 0x81,
2307                                        .ep_attr = 0x05,
2308                                        .rates = SNDRV_PCM_RATE_44100 |
2309                                                 SNDRV_PCM_RATE_48000 |
2310                                                 SNDRV_PCM_RATE_88200 |
2311                                                 SNDRV_PCM_RATE_96000,
2312                                        .rate_min = 44100,
2313                                        .rate_max = 96000,
2314                                        .nr_rates = 4,
2315                                        .rate_table = (unsigned int[]) {
2316                                                44100, 48000, 88200, 96000
2317                                        }
2318                                }
2319                        },
2320                        /* interface 3 (MIDI) is standard compliant */
2321                        {
2322                                .ifnum = -1
2323                        }
2324                }
2325        }
2326},
2327{
2328        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2329        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2330                /* .vendor_name = "M-Audio", */
2331                /* .product_name = "Fast Track Ultra 8R", */
2332                .ifnum = QUIRK_ANY_INTERFACE,
2333                .type = QUIRK_COMPOSITE,
2334                .data = & (const struct snd_usb_audio_quirk[]) {
2335                        {
2336                                .ifnum = 0,
2337                                .type = QUIRK_AUDIO_STANDARD_MIXER,
2338                        },
2339                        {
2340                                .ifnum = 1,
2341                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2342                                .data = & (const struct audioformat) {
2343                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2344                                        .channels = 8,
2345                                        .iface = 1,
2346                                        .altsetting = 1,
2347                                        .altset_idx = 1,
2348                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2349                                        .endpoint = 0x01,
2350                                        .ep_attr = 0x09,
2351                                        .rates = SNDRV_PCM_RATE_44100 |
2352                                                 SNDRV_PCM_RATE_48000 |
2353                                                 SNDRV_PCM_RATE_88200 |
2354                                                 SNDRV_PCM_RATE_96000,
2355                                        .rate_min = 44100,
2356                                        .rate_max = 96000,
2357                                        .nr_rates = 4,
2358                                        .rate_table = (unsigned int[]) {
2359                                                        44100, 48000, 88200, 96000
2360                                        }
2361                                }
2362                        },
2363                        {
2364                                .ifnum = 2,
2365                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2366                                .data = & (const struct audioformat) {
2367                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2368                                        .channels = 8,
2369                                        .iface = 2,
2370                                        .altsetting = 1,
2371                                        .altset_idx = 1,
2372                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2373                                        .endpoint = 0x81,
2374                                        .ep_attr = 0x05,
2375                                        .rates = SNDRV_PCM_RATE_44100 |
2376                                                 SNDRV_PCM_RATE_48000 |
2377                                                 SNDRV_PCM_RATE_88200 |
2378                                                 SNDRV_PCM_RATE_96000,
2379                                        .rate_min = 44100,
2380                                        .rate_max = 96000,
2381                                        .nr_rates = 4,
2382                                        .rate_table = (unsigned int[]) {
2383                                                44100, 48000, 88200, 96000
2384                                        }
2385                                }
2386                        },
2387                        /* interface 3 (MIDI) is standard compliant */
2388                        {
2389                                .ifnum = -1
2390                        }
2391                }
2392        }
2393},
2394
2395/* Casio devices */
2396{
2397        USB_DEVICE(0x07cf, 0x6801),
2398        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2399                .vendor_name = "Casio",
2400                .product_name = "PL-40R",
2401                .ifnum = 0,
2402                .type = QUIRK_MIDI_YAMAHA
2403        }
2404},
2405{
2406        /* this ID is used by several devices without a product ID */
2407        USB_DEVICE(0x07cf, 0x6802),
2408        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2409                .vendor_name = "Casio",
2410                .product_name = "Keyboard",
2411                .ifnum = 0,
2412                .type = QUIRK_MIDI_YAMAHA
2413        }
2414},
2415
2416/* Mark of the Unicorn devices */
2417{
2418        /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2419        .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2420                       USB_DEVICE_ID_MATCH_PRODUCT |
2421                       USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2422        .idVendor = 0x07fd,
2423        .idProduct = 0x0001,
2424        .bDeviceSubClass = 2,
2425        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2426                .vendor_name = "MOTU",
2427                .product_name = "Fastlane",
2428                .ifnum = QUIRK_ANY_INTERFACE,
2429                .type = QUIRK_COMPOSITE,
2430                .data = & (const struct snd_usb_audio_quirk[]) {
2431                        {
2432                                .ifnum = 0,
2433                                .type = QUIRK_MIDI_RAW_BYTES
2434                        },
2435                        {
2436                                .ifnum = 1,
2437                                .type = QUIRK_IGNORE_INTERFACE
2438                        },
2439                        {
2440                                .ifnum = -1
2441                        }
2442                }
2443        }
2444},
2445
2446/* Emagic devices */
2447{
2448        USB_DEVICE(0x086a, 0x0001),
2449        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2450                .vendor_name = "Emagic",
2451                /* .product_name = "Unitor8", */
2452                .ifnum = 2,
2453                .type = QUIRK_MIDI_EMAGIC,
2454                .data = & (const struct snd_usb_midi_endpoint_info) {
2455                        .out_cables = 0x80ff,
2456                        .in_cables  = 0x80ff
2457                }
2458        }
2459},
2460{
2461        USB_DEVICE(0x086a, 0x0002),
2462        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2463                .vendor_name = "Emagic",
2464                /* .product_name = "AMT8", */
2465                .ifnum = 2,
2466                .type = QUIRK_MIDI_EMAGIC,
2467                .data = & (const struct snd_usb_midi_endpoint_info) {
2468                        .out_cables = 0x80ff,
2469                        .in_cables  = 0x80ff
2470                }
2471        }
2472},
2473{
2474        USB_DEVICE(0x086a, 0x0003),
2475        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2476                .vendor_name = "Emagic",
2477                /* .product_name = "MT4", */
2478                .ifnum = 2,
2479                .type = QUIRK_MIDI_EMAGIC,
2480                .data = & (const struct snd_usb_midi_endpoint_info) {
2481                        .out_cables = 0x800f,
2482                        .in_cables  = 0x8003
2483                }
2484        }
2485},
2486
2487/* KORG devices */
2488{
2489        USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2490        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2491                .vendor_name = "KORG, Inc.",
2492                /* .product_name = "PANDORA PX5D", */
2493                .ifnum = 3,
2494                .type = QUIRK_MIDI_STANDARD_INTERFACE,
2495        }
2496},
2497
2498{
2499        USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2500        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2501                .vendor_name = "KORG, Inc.",
2502                /* .product_name = "ToneLab ST", */
2503                .ifnum = 3,
2504                .type = QUIRK_MIDI_STANDARD_INTERFACE,
2505        }
2506},
2507
2508/* AKAI devices */
2509{
2510        USB_DEVICE(0x09e8, 0x0062),
2511        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2512                .vendor_name = "AKAI",
2513                .product_name = "MPD16",
2514                .ifnum = 0,
2515                .type = QUIRK_MIDI_AKAI,
2516        }
2517},
2518
2519/* Steinberg devices */
2520{
2521        /* Steinberg MI2 */
2522        USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2523        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2524                .ifnum = QUIRK_ANY_INTERFACE,
2525                .type = QUIRK_COMPOSITE,
2526                .data = & (const struct snd_usb_audio_quirk[]) {
2527                        {
2528                                .ifnum = 0,
2529                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2530                        },
2531                        {
2532                                .ifnum = 1,
2533                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2534                        },
2535                        {
2536                                .ifnum = 2,
2537                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2538                        },
2539                        {
2540                                .ifnum = 3,
2541                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
2542                                .data = &(const struct snd_usb_midi_endpoint_info) {
2543                                        .out_cables = 0x0001,
2544                                        .in_cables  = 0x0001
2545                                }
2546                        },
2547                        {
2548                                .ifnum = -1
2549                        }
2550                }
2551        }
2552},
2553{
2554        /* Steinberg MI4 */
2555        USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2556        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2557                .ifnum = QUIRK_ANY_INTERFACE,
2558                .type = QUIRK_COMPOSITE,
2559                .data = & (const struct snd_usb_audio_quirk[]) {
2560                        {
2561                                .ifnum = 0,
2562                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2563                        },
2564                        {
2565                                .ifnum = 1,
2566                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2567                        },
2568                        {
2569                                .ifnum = 2,
2570                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2571                        },
2572                        {
2573                                .ifnum = 3,
2574                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
2575                                .data = &(const struct snd_usb_midi_endpoint_info) {
2576                                        .out_cables = 0x0001,
2577                                        .in_cables  = 0x0001
2578                                }
2579                        },
2580                        {
2581                                .ifnum = -1
2582                        }
2583                }
2584        }
2585},
2586
2587/* TerraTec devices */
2588{
2589        USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2590        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2591                .vendor_name = "TerraTec",
2592                .product_name = "PHASE 26",
2593                .ifnum = 3,
2594                .type = QUIRK_MIDI_STANDARD_INTERFACE
2595        }
2596},
2597{
2598        USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2599        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2600                .vendor_name = "TerraTec",
2601                .product_name = "PHASE 26",
2602                .ifnum = 3,
2603                .type = QUIRK_MIDI_STANDARD_INTERFACE
2604        }
2605},
2606{
2607        USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2608        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2609                .vendor_name = "TerraTec",
2610                .product_name = "PHASE 26",
2611                .ifnum = 3,
2612                .type = QUIRK_MIDI_STANDARD_INTERFACE
2613        }
2614},
2615{
2616        USB_DEVICE(0x0ccd, 0x0028),
2617        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2618                .vendor_name = "TerraTec",
2619                .product_name = "Aureon5.1MkII",
2620                .ifnum = QUIRK_NO_INTERFACE
2621        }
2622},
2623{
2624        USB_DEVICE(0x0ccd, 0x0035),
2625        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2626                .vendor_name = "Miditech",
2627                .product_name = "Play'n Roll",
2628                .ifnum = 0,
2629                .type = QUIRK_MIDI_CME
2630        }
2631},
2632
2633/* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2634{
2635        USB_DEVICE(0x103d, 0x0100),
2636                .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2637                .vendor_name = "Stanton",
2638                .product_name = "ScratchAmp",
2639                .ifnum = QUIRK_NO_INTERFACE
2640        }
2641},
2642{
2643        USB_DEVICE(0x103d, 0x0101),
2644                .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2645                .vendor_name = "Stanton",
2646                .product_name = "ScratchAmp",
2647                .ifnum = QUIRK_NO_INTERFACE
2648        }
2649},
2650
2651/* Novation EMS devices */
2652{
2653        USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2654        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2655                .vendor_name = "Novation",
2656                .product_name = "ReMOTE Audio/XStation",
2657                .ifnum = 4,
2658                .type = QUIRK_MIDI_NOVATION
2659        }
2660},
2661{
2662        USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2663        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2664                .vendor_name = "Novation",
2665                .product_name = "Speedio",
2666                .ifnum = 3,
2667                .type = QUIRK_MIDI_NOVATION
2668        }
2669},
2670{
2671        USB_DEVICE(0x1235, 0x000e),
2672        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2673                /* .vendor_name = "Novation", */
2674                /* .product_name = "Launchpad", */
2675                .ifnum = 0,
2676                .type = QUIRK_MIDI_RAW_BYTES
2677        }
2678},
2679{
2680        USB_DEVICE(0x1235, 0x0010),
2681        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2682                .vendor_name = "Focusrite",
2683                .product_name = "Saffire 6 USB",
2684                .ifnum = QUIRK_ANY_INTERFACE,
2685                .type = QUIRK_COMPOSITE,
2686                .data = (const struct snd_usb_audio_quirk[]) {
2687                        {
2688                                .ifnum = 0,
2689                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2690                                .data = &(const struct audioformat) {
2691                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2692                                        .channels = 4,
2693                                        .iface = 0,
2694                                        .altsetting = 1,
2695                                        .altset_idx = 1,
2696                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2697                                        .endpoint = 0x01,
2698                                        .ep_attr = USB_ENDPOINT_XFER_ISOC,
2699                                        .rates = SNDRV_PCM_RATE_44100 |
2700                                                 SNDRV_PCM_RATE_48000,
2701                                        .rate_min = 44100,
2702                                        .rate_max = 48000,
2703                                        .nr_rates = 2,
2704                                        .rate_table = (unsigned int[]) {
2705                                                44100, 48000
2706                                        }
2707                                }
2708                        },
2709                        {
2710                                .ifnum = 1,
2711                                .type = QUIRK_MIDI_RAW_BYTES
2712                        },
2713                        {
2714                                .ifnum = -1
2715                        }
2716                }
2717        }
2718},
2719{
2720        USB_DEVICE(0x1235, 0x0018),
2721        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2722                .vendor_name = "Novation",
2723                .product_name = "Twitch",
2724                .ifnum = QUIRK_ANY_INTERFACE,
2725                .type = QUIRK_COMPOSITE,
2726                .data = (const struct snd_usb_audio_quirk[]) {
2727                        {
2728                                .ifnum = 0,
2729                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2730                                .data = & (const struct audioformat) {
2731                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2732                                        .channels = 4,
2733                                        .iface = 0,
2734                                        .altsetting = 1,
2735                                        .altset_idx = 1,
2736                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2737                                        .endpoint = 0x01,
2738                                        .ep_attr = USB_ENDPOINT_XFER_ISOC,
2739                                        .rates = SNDRV_PCM_RATE_44100 |
2740                                                 SNDRV_PCM_RATE_48000,
2741                                        .rate_min = 44100,
2742                                        .rate_max = 48000,
2743                                        .nr_rates = 2,
2744                                        .rate_table = (unsigned int[]) {
2745                                                44100, 48000
2746                                        }
2747                                }
2748                        },
2749                        {
2750                                .ifnum = 1,
2751                                .type = QUIRK_MIDI_RAW_BYTES
2752                        },
2753                        {
2754                                .ifnum = -1
2755                        }
2756                }
2757        }
2758},
2759{
2760        USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2761        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2762                .vendor_name = "Novation",
2763                .product_name = "ReMOTE25",
2764                .ifnum = 0,
2765                .type = QUIRK_MIDI_NOVATION
2766        }
2767},
2768{
2769        /*
2770         * Focusrite Scarlett 18i6
2771         *
2772         * Avoid mixer creation, which otherwise fails because some of
2773         * the interface descriptor subtypes for interface 0 are
2774         * unknown.  That should be fixed or worked-around but this at
2775         * least allows the device to be used successfully with a DAW
2776         * and an external mixer.  See comments below about other
2777         * ignored interfaces.
2778         */
2779        USB_DEVICE(0x1235, 0x8004),
2780        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2781                .vendor_name = "Focusrite",
2782                .product_name = "Scarlett 18i6",
2783                .ifnum = QUIRK_ANY_INTERFACE,
2784                .type = QUIRK_COMPOSITE,
2785                .data = & (const struct snd_usb_audio_quirk[]) {
2786                        {
2787                                /* InterfaceSubClass 1 (Control Device) */
2788                                .ifnum = 0,
2789                                .type = QUIRK_IGNORE_INTERFACE
2790                        },
2791                        {
2792                                .ifnum = 1,
2793                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2794                        },
2795                        {
2796                                .ifnum = 2,
2797                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2798                        },
2799                        {
2800                                /* InterfaceSubClass 1 (Control Device) */
2801                                .ifnum = 3,
2802                                .type = QUIRK_IGNORE_INTERFACE
2803                        },
2804                        {
2805                                .ifnum = 4,
2806                                .type = QUIRK_MIDI_STANDARD_INTERFACE
2807                        },
2808                        {
2809                                /* InterfaceSubClass 1 (Device Firmware Update) */
2810                                .ifnum = 5,
2811                                .type = QUIRK_IGNORE_INTERFACE
2812                        },
2813                        {
2814                                .ifnum = -1
2815                        }
2816                }
2817        }
2818},
2819
2820/* Access Music devices */
2821{
2822        /* VirusTI Desktop */
2823        USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2824        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2825                .ifnum = QUIRK_ANY_INTERFACE,
2826                .type = QUIRK_COMPOSITE,
2827                .data = &(const struct snd_usb_audio_quirk[]) {
2828                        {
2829                                .ifnum = 3,
2830                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
2831                                .data = &(const struct snd_usb_midi_endpoint_info) {
2832                                        .out_cables = 0x0003,
2833                                        .in_cables  = 0x0003
2834                                }
2835                        },
2836                        {
2837                                .ifnum = 4,
2838                                .type = QUIRK_IGNORE_INTERFACE
2839                        },
2840                        {
2841                                .ifnum = -1
2842                        }
2843                }
2844        }
2845},
2846
2847/* */
2848{
2849        /* aka. Serato Scratch Live DJ Box */
2850        USB_DEVICE(0x13e5, 0x0001),
2851        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2852                .vendor_name = "Rane",
2853                .product_name = "SL-1",
2854                .ifnum = QUIRK_NO_INTERFACE
2855        }
2856},
2857
2858/* Native Instruments MK2 series */
2859{
2860        /* Komplete Audio 6 */
2861        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2862        .idVendor = 0x17cc,
2863        .idProduct = 0x1000,
2864},
2865{
2866        /* Traktor Audio 6 */
2867        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2868        .idVendor = 0x17cc,
2869        .idProduct = 0x1010,
2870},
2871{
2872        /* Traktor Audio 10 */
2873        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2874        .idVendor = 0x17cc,
2875        .idProduct = 0x1020,
2876},
2877
2878/* KeithMcMillen Stringport */
2879{
2880        USB_DEVICE(0x1f38, 0x0001),
2881        .bInterfaceClass = USB_CLASS_AUDIO,
2882},
2883
2884/* Miditech devices */
2885{
2886        USB_DEVICE(0x4752, 0x0011),
2887        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2888                .vendor_name = "Miditech",
2889                .product_name = "Midistart-2",
2890                .ifnum = 0,
2891                .type = QUIRK_MIDI_CME
2892        }
2893},
2894
2895/* Central Music devices */
2896{
2897        /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2898        USB_DEVICE(0x7104, 0x2202),
2899        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2900                .ifnum = 0,
2901                .type = QUIRK_MIDI_CME
2902        }
2903},
2904
2905/*
2906 * Auvitek au0828 devices with audio interface.
2907 * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
2908 * Please notice that some drivers are DVB only, and don't need to be
2909 * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2910 */
2911
2912#define AU0828_DEVICE(vid, pid, vname, pname) { \
2913        USB_DEVICE_VENDOR_SPEC(vid, pid), \
2914        .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
2915                       USB_DEVICE_ID_MATCH_INT_CLASS | \
2916                       USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
2917        .bInterfaceClass = USB_CLASS_AUDIO, \
2918        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, \
2919        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2920                .vendor_name = vname, \
2921                .product_name = pname, \
2922                .ifnum = QUIRK_ANY_INTERFACE, \
2923                .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
2924        } \
2925}
2926
2927AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2928AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2929AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
2930AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
2931AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
2932AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
2933AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
2934AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
2935AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
2936AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
2937AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
2938AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
2939AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
2940AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
2941AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
2942AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
2943AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
2944
2945/* Syntek STK1160 */
2946{
2947        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2948                       USB_DEVICE_ID_MATCH_INT_CLASS |
2949                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2950        .idVendor = 0x05e1,
2951        .idProduct = 0x0408,
2952        .bInterfaceClass = USB_CLASS_AUDIO,
2953        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2954        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2955                .vendor_name = "Syntek",
2956                .product_name = "STK1160",
2957                .ifnum = QUIRK_ANY_INTERFACE,
2958                .type = QUIRK_AUDIO_ALIGN_TRANSFER
2959        }
2960},
2961
2962/* Syntek STK1160 */
2963{
2964        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2965                       USB_DEVICE_ID_MATCH_INT_CLASS |
2966                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2967        .idVendor = 0x05e1,
2968        .idProduct = 0x0408,
2969        .bInterfaceClass = USB_CLASS_AUDIO,
2970        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2971        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2972                .vendor_name = "Syntek",
2973                .product_name = "STK1160",
2974                .ifnum = QUIRK_ANY_INTERFACE,
2975                .type = QUIRK_AUDIO_ALIGN_TRANSFER
2976        }
2977},
2978
2979/* Digidesign Mbox */
2980{
2981        /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2982        USB_DEVICE(0x0dba, 0x1000),
2983        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2984                .vendor_name = "Digidesign",
2985                .product_name = "MBox",
2986                .ifnum = QUIRK_ANY_INTERFACE,
2987                .type = QUIRK_COMPOSITE,
2988                .data = (const struct snd_usb_audio_quirk[]){
2989                        {
2990                                .ifnum = 0,
2991                                .type = QUIRK_IGNORE_INTERFACE,
2992                        },
2993                        {
2994                                .ifnum = 1,
2995                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2996                                .data = &(const struct audioformat) {
2997                                        .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2998                                        .channels = 2,
2999                                        .iface = 1,
3000                                        .altsetting = 1,
3001                                        .altset_idx = 1,
3002                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3003                                        .endpoint = 0x02,
3004                                        .ep_attr = 0x01,
3005                                        .rates = SNDRV_PCM_RATE_44100 |
3006                                                 SNDRV_PCM_RATE_48000,
3007                                        .rate_min = 44100,
3008                                        .rate_max = 48000,
3009                                        .nr_rates = 2,
3010                                        .rate_table = (unsigned int[]) {
3011                                                44100, 48000
3012                                        }
3013                                }
3014                        },
3015                        {
3016                                .ifnum = -1
3017                        }
3018                }
3019
3020        }
3021},
3022
3023/* DIGIDESIGN MBOX 2 */
3024{
3025        USB_DEVICE(0x0dba, 0x3000),
3026        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3027                .vendor_name = "Digidesign",
3028                .product_name = "Mbox 2",
3029                .ifnum = QUIRK_ANY_INTERFACE,
3030                .type = QUIRK_COMPOSITE,
3031                .data = (const struct snd_usb_audio_quirk[]) {
3032                        {
3033                                .ifnum = 0,
3034                                .type = QUIRK_IGNORE_INTERFACE
3035                        },
3036                        {
3037                                .ifnum = 1,
3038                                .type = QUIRK_IGNORE_INTERFACE
3039                        },
3040                        {
3041                                .ifnum = 2,
3042                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3043                                .data = &(const struct audioformat) {
3044                                        .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3045                                        .channels = 2,
3046                                        .iface = 2,
3047                                        .altsetting = 2,
3048                                        .altset_idx = 1,
3049                                        .attributes = 0x00,
3050                                        .endpoint = 0x03,
3051                                        .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
3052                                        .rates = SNDRV_PCM_RATE_48000,
3053                                        .rate_min = 48000,
3054                                        .rate_max = 48000,
3055                                        .nr_rates = 1,
3056                                        .rate_table = (unsigned int[]) {
3057                                                48000
3058                                        }
3059                                }
3060                        },
3061                        {
3062                                .ifnum = 3,
3063                                .type = QUIRK_IGNORE_INTERFACE
3064                        },
3065                        {
3066                                .ifnum = 4,
3067                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3068                                .data = &(const struct audioformat) {
3069                                .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3070                                        .channels = 2,
3071                                        .iface = 4,
3072                                        .altsetting = 2,
3073                                        .altset_idx = 1,
3074                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3075                                        .endpoint = 0x85,
3076                                        .ep_attr = USB_ENDPOINT_SYNC_SYNC,
3077                                        .rates = SNDRV_PCM_RATE_48000,
3078                                        .rate_min = 48000,
3079                                        .rate_max = 48000,
3080                                        .nr_rates = 1,
3081                                        .rate_table = (unsigned int[]) {
3082                                                48000
3083                                        }
3084                                }
3085                        },
3086                        {
3087                                .ifnum = 5,
3088                                .type = QUIRK_IGNORE_INTERFACE
3089                        },
3090                        {
3091                                .ifnum = 6,
3092                                .type = QUIRK_MIDI_MIDIMAN,
3093                                .data = &(const struct snd_usb_midi_endpoint_info) {
3094                                        .out_ep =  0x02,
3095                                        .out_cables = 0x0001,
3096                                        .in_ep = 0x81,
3097                                        .in_interval = 0x01,
3098                                        .in_cables = 0x0001
3099                                }
3100                        },
3101                        {
3102                                .ifnum = -1
3103                        }
3104                }
3105        }
3106},
3107{
3108        /* Tascam US122 MKII - playback-only support */
3109        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
3110        .idVendor = 0x0644,
3111        .idProduct = 0x8021,
3112        .bInterfaceClass = USB_CLASS_AUDIO,
3113        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3114                .vendor_name = "TASCAM",
3115                .product_name = "US122 MKII",
3116                .ifnum = QUIRK_ANY_INTERFACE,
3117                .type = QUIRK_COMPOSITE,
3118                .data = (const struct snd_usb_audio_quirk[]) {
3119                        {
3120                                .ifnum = 0,
3121                                .type = QUIRK_IGNORE_INTERFACE
3122                        },
3123                        {
3124                                .ifnum = 1,
3125                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3126                                .data = &(const struct audioformat) {
3127                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3128                                        .channels = 2,
3129                                        .iface = 1,
3130                                        .altsetting = 1,
3131                                        .altset_idx = 1,
3132                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3133                                        .endpoint = 0x02,
3134                                        .ep_attr = USB_ENDPOINT_XFER_ISOC,
3135                                        .rates = SNDRV_PCM_RATE_44100 |
3136                                                 SNDRV_PCM_RATE_48000 |
3137                                                 SNDRV_PCM_RATE_88200 |
3138                                                 SNDRV_PCM_RATE_96000,
3139                                        .rate_min = 44100,
3140                                        .rate_max = 96000,
3141                                        .nr_rates = 4,
3142                                        .rate_table = (unsigned int[]) {
3143                                                44100, 48000, 88200, 96000
3144                                        }
3145                                }
3146                        },
3147                        {
3148                                .ifnum = -1
3149                        }
3150                }
3151        }
3152},
3153
3154/* Microsoft XboxLive Headset/Xbox Communicator */
3155{
3156        USB_DEVICE(0x045e, 0x0283),
3157        .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3158        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3159                .vendor_name = "Microsoft",
3160                .product_name = "XboxLive Headset/Xbox Communicator",
3161                .ifnum = QUIRK_ANY_INTERFACE,
3162                .type = QUIRK_COMPOSITE,
3163                .data = &(const struct snd_usb_audio_quirk[]) {
3164                        {
3165                                /* playback */
3166                                .ifnum = 0,
3167                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3168                                .data = &(const struct audioformat) {
3169                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
3170                                        .channels = 1,
3171                                        .iface = 0,
3172                                        .altsetting = 0,
3173                                        .altset_idx = 0,
3174                                        .attributes = 0,
3175                                        .endpoint = 0x04,
3176                                        .ep_attr = 0x05,
3177                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
3178                                        .rate_min = 22050,
3179                                        .rate_max = 22050
3180                                }
3181                        },
3182                        {
3183                                /* capture */
3184                                .ifnum = 1,
3185                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3186                                .data = &(const struct audioformat) {
3187                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
3188                                        .channels = 1,
3189                                        .iface = 1,
3190                                        .altsetting = 0,
3191                                        .altset_idx = 0,
3192                                        .attributes = 0,
3193                                        .endpoint = 0x85,
3194                                        .ep_attr = 0x05,
3195                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
3196                                        .rate_min = 16000,
3197                                        .rate_max = 16000
3198                                }
3199                        },
3200                        {
3201                                .ifnum = -1
3202                        }
3203                }
3204        }
3205},
3206
3207/* Reloop Play */
3208{
3209        USB_DEVICE(0x200c, 0x100b),
3210        .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3211        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3212                .ifnum = QUIRK_ANY_INTERFACE,
3213                .type = QUIRK_COMPOSITE,
3214                .data = &(const struct snd_usb_audio_quirk[]) {
3215                        {
3216                                .ifnum = 0,
3217                                .type = QUIRK_AUDIO_STANDARD_MIXER,
3218                        },
3219                        {
3220                                .ifnum = 1,
3221                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3222                                .data = &(const struct audioformat) {
3223                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3224                                        .channels = 4,
3225                                        .iface = 1,
3226                                        .altsetting = 1,
3227                                        .altset_idx = 1,
3228                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3229                                        .endpoint = 0x01,
3230                                        .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3231                                        .rates = SNDRV_PCM_RATE_44100 |
3232                                                 SNDRV_PCM_RATE_48000,
3233                                        .rate_min = 44100,
3234                                        .rate_max = 48000,
3235                                        .nr_rates = 2,
3236                                        .rate_table = (unsigned int[]) {
3237                                                44100, 48000
3238                                        }
3239                                }
3240                        },
3241                        {
3242                                .ifnum = -1
3243                        }
3244                }
3245        }
3246},
3247
3248{
3249        /*
3250         * ZOOM R16/24 in audio interface mode.
3251         * Mixer descriptors are garbage, further quirks will be needed
3252         * to make any of it functional, thus disabled for now.
3253         * Playback stream appears to start and run fine but no sound
3254         * is produced, so also disabled for now.
3255         */
3256        USB_DEVICE(0x1686, 0x00dd),
3257        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3258                .ifnum = QUIRK_ANY_INTERFACE,
3259                .type = QUIRK_COMPOSITE,
3260                .data = (const struct snd_usb_audio_quirk[]) {
3261                        {
3262                                /* Mixer */
3263                                .ifnum = 0,
3264                                .type = QUIRK_IGNORE_INTERFACE,
3265                        },
3266                        {
3267                                /* Playback  */
3268                                .ifnum = 1,
3269                                .type = QUIRK_IGNORE_INTERFACE,
3270                        },
3271                        {
3272                                /* Capture */
3273                                .ifnum = 2,
3274                                .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3275                        },
3276                        {
3277                                /* Midi */
3278                                .ifnum = 3,
3279                                .type = QUIRK_MIDI_STANDARD_INTERFACE
3280                        },
3281                        {
3282                                .ifnum = -1
3283                        },
3284                }
3285        }
3286},
3287
3288{
3289        /*
3290         * Some USB MIDI devices don't have an audio control interface,
3291         * so we have to grab MIDI streaming interfaces here.
3292         */
3293        .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3294                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3295        .bInterfaceClass = USB_CLASS_AUDIO,
3296        .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3297        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3298                .ifnum = QUIRK_ANY_INTERFACE,
3299                .type = QUIRK_MIDI_STANDARD_INTERFACE
3300        }
3301},
3302
3303{
3304        /*
3305         * The original product_name is "USB Sound Device", however this name
3306         * is also used by the CM106 based cards, so make it unique.
3307         */
3308        USB_DEVICE(0x0d8c, 0x0103),
3309        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3310                .product_name = "Audio Advantage MicroII",
3311                .ifnum = QUIRK_NO_INTERFACE
3312        }
3313},
3314
3315#undef USB_DEVICE_VENDOR_SPEC
Note: See TracBrowser for help on using the repository browser.