2 * ALSA USB Audio Driver
4 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>,
5 * Clemens Ladisch <clemens@ladisch.de>
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.
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.
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
24 * The contents of this file are part of the driver's id_table.
26 * In a perfect world, this file would be empty.
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.)
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, \
40 .bInterfaceClass = USB_CLASS_VENDOR_SPEC
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", */
49 .type = QUIRK_MIDI_FTDI
53 /* Creative/Toshiba Multimedia Center SB-0500 */
55 USB_DEVICE(0x041e, 0x3048),
56 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
57 .vendor_name = "Toshiba",
58 .product_name = "SB-0500",
59 .ifnum = QUIRK_NO_INTERFACE
63 /* Creative/E-Mu devices */
65 USB_DEVICE(0x041e, 0x3010),
66 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
67 .vendor_name = "Creative Labs",
68 .product_name = "Sound Blaster MP3+",
69 .ifnum = QUIRK_NO_INTERFACE
74 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
77 .bInterfaceClass = USB_CLASS_AUDIO,
81 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
84 .bInterfaceClass = USB_CLASS_AUDIO,
87 /* E-Mu Tracker Pre */
88 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
91 .bInterfaceClass = USB_CLASS_AUDIO,
95 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
98 .bInterfaceClass = USB_CLASS_AUDIO,
102 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
103 * class matches do not take effect without an explicit ID match.
106 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
107 USB_DEVICE_ID_MATCH_INT_CLASS |
108 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
111 .bInterfaceClass = USB_CLASS_AUDIO,
112 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
115 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
116 USB_DEVICE_ID_MATCH_INT_CLASS |
117 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
120 .bInterfaceClass = USB_CLASS_AUDIO,
121 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
124 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
125 USB_DEVICE_ID_MATCH_INT_CLASS |
126 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
129 .bInterfaceClass = USB_CLASS_AUDIO,
130 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
133 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
134 USB_DEVICE_ID_MATCH_INT_CLASS |
135 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
138 .bInterfaceClass = USB_CLASS_AUDIO,
139 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
142 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
143 USB_DEVICE_ID_MATCH_INT_CLASS |
144 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
147 .bInterfaceClass = USB_CLASS_AUDIO,
148 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
151 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
152 USB_DEVICE_ID_MATCH_INT_CLASS |
153 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
156 .bInterfaceClass = USB_CLASS_AUDIO,
157 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
160 USB_DEVICE(0x046d, 0x0990),
161 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
162 .vendor_name = "Logitech, Inc.",
163 .product_name = "QuickCam Pro 9000",
164 .ifnum = QUIRK_NO_INTERFACE
172 #define YAMAHA_DEVICE(id, name) { \
173 USB_DEVICE(0x0499, id), \
174 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
175 .vendor_name = "Yamaha", \
176 .product_name = name, \
177 .ifnum = QUIRK_ANY_INTERFACE, \
178 .type = QUIRK_MIDI_YAMAHA \
181 #define YAMAHA_INTERFACE(id, intf, name) { \
182 USB_DEVICE_VENDOR_SPEC(0x0499, id), \
183 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
184 .vendor_name = "Yamaha", \
185 .product_name = name, \
187 .type = QUIRK_MIDI_YAMAHA \
190 YAMAHA_DEVICE(0x1000, "UX256"),
191 YAMAHA_DEVICE(0x1001, "MU1000"),
192 YAMAHA_DEVICE(0x1002, "MU2000"),
193 YAMAHA_DEVICE(0x1003, "MU500"),
194 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
195 YAMAHA_DEVICE(0x1005, "MOTIF6"),
196 YAMAHA_DEVICE(0x1006, "MOTIF7"),
197 YAMAHA_DEVICE(0x1007, "MOTIF8"),
198 YAMAHA_DEVICE(0x1008, "UX96"),
199 YAMAHA_DEVICE(0x1009, "UX16"),
200 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
201 YAMAHA_DEVICE(0x100c, "UC-MX"),
202 YAMAHA_DEVICE(0x100d, "UC-KX"),
203 YAMAHA_DEVICE(0x100e, "S08"),
204 YAMAHA_DEVICE(0x100f, "CLP-150"),
205 YAMAHA_DEVICE(0x1010, "CLP-170"),
206 YAMAHA_DEVICE(0x1011, "P-250"),
207 YAMAHA_DEVICE(0x1012, "TYROS"),
208 YAMAHA_DEVICE(0x1013, "PF-500"),
209 YAMAHA_DEVICE(0x1014, "S90"),
210 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
211 YAMAHA_DEVICE(0x1016, "MDP-5"),
212 YAMAHA_DEVICE(0x1017, "CVP-204"),
213 YAMAHA_DEVICE(0x1018, "CVP-206"),
214 YAMAHA_DEVICE(0x1019, "CVP-208"),
215 YAMAHA_DEVICE(0x101a, "CVP-210"),
216 YAMAHA_DEVICE(0x101b, "PSR-1100"),
217 YAMAHA_DEVICE(0x101c, "PSR-2100"),
218 YAMAHA_DEVICE(0x101d, "CLP-175"),
219 YAMAHA_DEVICE(0x101e, "PSR-K1"),
220 YAMAHA_DEVICE(0x101f, "EZ-J24"),
221 YAMAHA_DEVICE(0x1020, "EZ-250i"),
222 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
223 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
224 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
225 YAMAHA_DEVICE(0x1024, "CVP-301"),
226 YAMAHA_DEVICE(0x1025, "CVP-303"),
227 YAMAHA_DEVICE(0x1026, "CVP-305"),
228 YAMAHA_DEVICE(0x1027, "CVP-307"),
229 YAMAHA_DEVICE(0x1028, "CVP-309"),
230 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
231 YAMAHA_DEVICE(0x102a, "PSR-1500"),
232 YAMAHA_DEVICE(0x102b, "PSR-3000"),
233 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
234 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
235 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
236 YAMAHA_DEVICE(0x1032, "DGX-305"),
237 YAMAHA_DEVICE(0x1033, "DGX-505"),
238 YAMAHA_DEVICE(0x1034, NULL),
239 YAMAHA_DEVICE(0x1035, NULL),
240 YAMAHA_DEVICE(0x1036, NULL),
241 YAMAHA_DEVICE(0x1037, NULL),
242 YAMAHA_DEVICE(0x1038, NULL),
243 YAMAHA_DEVICE(0x1039, NULL),
244 YAMAHA_DEVICE(0x103a, NULL),
245 YAMAHA_DEVICE(0x103b, NULL),
246 YAMAHA_DEVICE(0x103c, NULL),
247 YAMAHA_DEVICE(0x103d, NULL),
248 YAMAHA_DEVICE(0x103e, NULL),
249 YAMAHA_DEVICE(0x103f, NULL),
250 YAMAHA_DEVICE(0x1040, NULL),
251 YAMAHA_DEVICE(0x1041, NULL),
252 YAMAHA_DEVICE(0x1042, NULL),
253 YAMAHA_DEVICE(0x1043, NULL),
254 YAMAHA_DEVICE(0x1044, NULL),
255 YAMAHA_DEVICE(0x1045, NULL),
256 YAMAHA_INTERFACE(0x104e, 0, NULL),
257 YAMAHA_DEVICE(0x104f, NULL),
258 YAMAHA_DEVICE(0x1050, NULL),
259 YAMAHA_DEVICE(0x1051, NULL),
260 YAMAHA_DEVICE(0x1052, NULL),
261 YAMAHA_INTERFACE(0x1053, 0, NULL),
262 YAMAHA_INTERFACE(0x1054, 0, NULL),
263 YAMAHA_DEVICE(0x1055, NULL),
264 YAMAHA_DEVICE(0x1056, NULL),
265 YAMAHA_DEVICE(0x1057, NULL),
266 YAMAHA_DEVICE(0x1058, NULL),
267 YAMAHA_DEVICE(0x1059, NULL),
268 YAMAHA_DEVICE(0x105a, NULL),
269 YAMAHA_DEVICE(0x105b, NULL),
270 YAMAHA_DEVICE(0x105c, NULL),
271 YAMAHA_DEVICE(0x105d, NULL),
273 USB_DEVICE(0x0499, 0x1503),
274 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
275 /* .vendor_name = "Yamaha", */
276 /* .product_name = "MOX6/MOX8", */
277 .ifnum = QUIRK_ANY_INTERFACE,
278 .type = QUIRK_COMPOSITE,
279 .data = (const struct snd_usb_audio_quirk[]) {
282 .type = QUIRK_AUDIO_STANDARD_INTERFACE
286 .type = QUIRK_AUDIO_STANDARD_INTERFACE
290 .type = QUIRK_MIDI_YAMAHA
298 YAMAHA_DEVICE(0x2000, "DGP-7"),
299 YAMAHA_DEVICE(0x2001, "DGP-5"),
300 YAMAHA_DEVICE(0x2002, NULL),
301 YAMAHA_DEVICE(0x2003, NULL),
302 YAMAHA_DEVICE(0x5000, "CS1D"),
303 YAMAHA_DEVICE(0x5001, "DSP1D"),
304 YAMAHA_DEVICE(0x5002, "DME32"),
305 YAMAHA_DEVICE(0x5003, "DM2000"),
306 YAMAHA_DEVICE(0x5004, "02R96"),
307 YAMAHA_DEVICE(0x5005, "ACU16-C"),
308 YAMAHA_DEVICE(0x5006, "NHB32-C"),
309 YAMAHA_DEVICE(0x5007, "DM1000"),
310 YAMAHA_DEVICE(0x5008, "01V96"),
311 YAMAHA_DEVICE(0x5009, "SPX2000"),
312 YAMAHA_DEVICE(0x500a, "PM5D"),
313 YAMAHA_DEVICE(0x500b, "DME64N"),
314 YAMAHA_DEVICE(0x500c, "DME24N"),
315 YAMAHA_DEVICE(0x500d, NULL),
316 YAMAHA_DEVICE(0x500e, NULL),
317 YAMAHA_DEVICE(0x500f, NULL),
318 YAMAHA_DEVICE(0x7000, "DTX"),
319 YAMAHA_DEVICE(0x7010, "UB99"),
321 #undef YAMAHA_INTERFACE
324 * Roland/RolandED/Edirol/BOSS devices
327 USB_DEVICE(0x0582, 0x0000),
328 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
329 .vendor_name = "Roland",
330 .product_name = "UA-100",
331 .ifnum = QUIRK_ANY_INTERFACE,
332 .type = QUIRK_COMPOSITE,
333 .data = (const struct snd_usb_audio_quirk[]) {
336 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
337 .data = & (const struct audioformat) {
338 .formats = SNDRV_PCM_FMTBIT_S16_LE,
346 .rates = SNDRV_PCM_RATE_CONTINUOUS,
353 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
354 .data = & (const struct audioformat) {
355 .formats = SNDRV_PCM_FMTBIT_S16_LE,
360 .attributes = UAC_EP_CS_ATTR_FILL_MAX,
363 .rates = SNDRV_PCM_RATE_CONTINUOUS,
370 .type = QUIRK_MIDI_FIXED_ENDPOINT,
371 .data = & (const struct snd_usb_midi_endpoint_info) {
372 .out_cables = 0x0007,
383 USB_DEVICE(0x0582, 0x0002),
384 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
385 .vendor_name = "EDIROL",
386 .product_name = "UM-4",
387 .ifnum = QUIRK_ANY_INTERFACE,
388 .type = QUIRK_COMPOSITE,
389 .data = (const struct snd_usb_audio_quirk[]) {
392 .type = QUIRK_IGNORE_INTERFACE
396 .type = QUIRK_IGNORE_INTERFACE
400 .type = QUIRK_MIDI_FIXED_ENDPOINT,
401 .data = & (const struct snd_usb_midi_endpoint_info) {
402 .out_cables = 0x000f,
413 USB_DEVICE(0x0582, 0x0003),
414 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
415 .vendor_name = "Roland",
416 .product_name = "SC-8850",
417 .ifnum = QUIRK_ANY_INTERFACE,
418 .type = QUIRK_COMPOSITE,
419 .data = (const struct snd_usb_audio_quirk[]) {
422 .type = QUIRK_IGNORE_INTERFACE
426 .type = QUIRK_IGNORE_INTERFACE
430 .type = QUIRK_MIDI_FIXED_ENDPOINT,
431 .data = & (const struct snd_usb_midi_endpoint_info) {
432 .out_cables = 0x003f,
443 USB_DEVICE(0x0582, 0x0004),
444 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
445 .vendor_name = "Roland",
446 .product_name = "U-8",
447 .ifnum = QUIRK_ANY_INTERFACE,
448 .type = QUIRK_COMPOSITE,
449 .data = (const struct snd_usb_audio_quirk[]) {
452 .type = QUIRK_IGNORE_INTERFACE
456 .type = QUIRK_IGNORE_INTERFACE
460 .type = QUIRK_MIDI_FIXED_ENDPOINT,
461 .data = & (const struct snd_usb_midi_endpoint_info) {
462 .out_cables = 0x0005,
473 /* Has ID 0x0099 when not in "Advanced Driver" mode.
474 * The UM-2EX has only one input, but we cannot detect this. */
475 USB_DEVICE(0x0582, 0x0005),
476 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
477 .vendor_name = "EDIROL",
478 .product_name = "UM-2",
479 .ifnum = QUIRK_ANY_INTERFACE,
480 .type = QUIRK_COMPOSITE,
481 .data = (const struct snd_usb_audio_quirk[]) {
484 .type = QUIRK_IGNORE_INTERFACE
488 .type = QUIRK_IGNORE_INTERFACE
492 .type = QUIRK_MIDI_FIXED_ENDPOINT,
493 .data = & (const struct snd_usb_midi_endpoint_info) {
494 .out_cables = 0x0003,
505 USB_DEVICE(0x0582, 0x0007),
506 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
507 .vendor_name = "Roland",
508 .product_name = "SC-8820",
509 .ifnum = QUIRK_ANY_INTERFACE,
510 .type = QUIRK_COMPOSITE,
511 .data = (const struct snd_usb_audio_quirk[]) {
514 .type = QUIRK_IGNORE_INTERFACE
518 .type = QUIRK_IGNORE_INTERFACE
522 .type = QUIRK_MIDI_FIXED_ENDPOINT,
523 .data = & (const struct snd_usb_midi_endpoint_info) {
524 .out_cables = 0x0013,
535 USB_DEVICE(0x0582, 0x0008),
536 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
537 .vendor_name = "Roland",
538 .product_name = "PC-300",
539 .ifnum = QUIRK_ANY_INTERFACE,
540 .type = QUIRK_COMPOSITE,
541 .data = (const struct snd_usb_audio_quirk[]) {
544 .type = QUIRK_IGNORE_INTERFACE
548 .type = QUIRK_IGNORE_INTERFACE
552 .type = QUIRK_MIDI_FIXED_ENDPOINT,
553 .data = & (const struct snd_usb_midi_endpoint_info) {
554 .out_cables = 0x0001,
565 /* has ID 0x009d when not in "Advanced Driver" mode */
566 USB_DEVICE(0x0582, 0x0009),
567 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
568 .vendor_name = "EDIROL",
569 .product_name = "UM-1",
570 .ifnum = QUIRK_ANY_INTERFACE,
571 .type = QUIRK_COMPOSITE,
572 .data = (const struct snd_usb_audio_quirk[]) {
575 .type = QUIRK_IGNORE_INTERFACE
579 .type = QUIRK_IGNORE_INTERFACE
583 .type = QUIRK_MIDI_FIXED_ENDPOINT,
584 .data = & (const struct snd_usb_midi_endpoint_info) {
585 .out_cables = 0x0001,
596 USB_DEVICE(0x0582, 0x000b),
597 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
598 .vendor_name = "Roland",
599 .product_name = "SK-500",
600 .ifnum = QUIRK_ANY_INTERFACE,
601 .type = QUIRK_COMPOSITE,
602 .data = (const struct snd_usb_audio_quirk[]) {
605 .type = QUIRK_IGNORE_INTERFACE
609 .type = QUIRK_IGNORE_INTERFACE
613 .type = QUIRK_MIDI_FIXED_ENDPOINT,
614 .data = & (const struct snd_usb_midi_endpoint_info) {
615 .out_cables = 0x0013,
626 /* thanks to Emiliano Grilli <emillo@libero.it>
627 * for helping researching this data */
628 USB_DEVICE(0x0582, 0x000c),
629 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
630 .vendor_name = "Roland",
631 .product_name = "SC-D70",
632 .ifnum = QUIRK_ANY_INTERFACE,
633 .type = QUIRK_COMPOSITE,
634 .data = (const struct snd_usb_audio_quirk[]) {
637 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
638 .data = & (const struct audioformat) {
639 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
647 .rates = SNDRV_PCM_RATE_CONTINUOUS,
654 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
655 .data = & (const struct audioformat) {
656 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
664 .rates = SNDRV_PCM_RATE_CONTINUOUS,
671 .type = QUIRK_MIDI_FIXED_ENDPOINT,
672 .data = & (const struct snd_usb_midi_endpoint_info) {
673 .out_cables = 0x0007,
684 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
685 * If the advanced mode switch at the back of the unit is off, the
686 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
687 * but offers only 16-bit PCM.
688 * In advanced mode, the UA-5 will output S24_3LE samples (two
689 * channels) at the rate indicated on the front switch, including
690 * the 96kHz sample rate.
692 USB_DEVICE(0x0582, 0x0010),
693 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
694 .vendor_name = "EDIROL",
695 .product_name = "UA-5",
696 .ifnum = QUIRK_ANY_INTERFACE,
697 .type = QUIRK_COMPOSITE,
698 .data = (const struct snd_usb_audio_quirk[]) {
701 .type = QUIRK_AUDIO_STANDARD_INTERFACE
705 .type = QUIRK_AUDIO_STANDARD_INTERFACE
714 /* has ID 0x0013 when not in "Advanced Driver" mode */
715 USB_DEVICE(0x0582, 0x0012),
716 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
717 .vendor_name = "Roland",
718 .product_name = "XV-5050",
720 .type = QUIRK_MIDI_FIXED_ENDPOINT,
721 .data = & (const struct snd_usb_midi_endpoint_info) {
722 .out_cables = 0x0001,
728 /* has ID 0x0015 when not in "Advanced Driver" mode */
729 USB_DEVICE(0x0582, 0x0014),
730 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
731 .vendor_name = "EDIROL",
732 .product_name = "UM-880",
734 .type = QUIRK_MIDI_FIXED_ENDPOINT,
735 .data = & (const struct snd_usb_midi_endpoint_info) {
736 .out_cables = 0x01ff,
742 /* has ID 0x0017 when not in "Advanced Driver" mode */
743 USB_DEVICE(0x0582, 0x0016),
744 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
745 .vendor_name = "EDIROL",
746 .product_name = "SD-90",
747 .ifnum = QUIRK_ANY_INTERFACE,
748 .type = QUIRK_COMPOSITE,
749 .data = (const struct snd_usb_audio_quirk[]) {
752 .type = QUIRK_AUDIO_STANDARD_INTERFACE
756 .type = QUIRK_AUDIO_STANDARD_INTERFACE
760 .type = QUIRK_MIDI_FIXED_ENDPOINT,
761 .data = & (const struct snd_usb_midi_endpoint_info) {
762 .out_cables = 0x000f,
773 /* has ID 0x001c when not in "Advanced Driver" mode */
774 USB_DEVICE(0x0582, 0x001b),
775 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
776 .vendor_name = "Roland",
777 .product_name = "MMP-2",
778 .ifnum = QUIRK_ANY_INTERFACE,
779 .type = QUIRK_COMPOSITE,
780 .data = (const struct snd_usb_audio_quirk[]) {
783 .type = QUIRK_IGNORE_INTERFACE
787 .type = QUIRK_IGNORE_INTERFACE
791 .type = QUIRK_MIDI_FIXED_ENDPOINT,
792 .data = & (const struct snd_usb_midi_endpoint_info) {
793 .out_cables = 0x0001,
804 /* has ID 0x001e when not in "Advanced Driver" mode */
805 USB_DEVICE(0x0582, 0x001d),
806 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
807 .vendor_name = "Roland",
808 .product_name = "V-SYNTH",
810 .type = QUIRK_MIDI_FIXED_ENDPOINT,
811 .data = & (const struct snd_usb_midi_endpoint_info) {
812 .out_cables = 0x0001,
818 /* has ID 0x0024 when not in "Advanced Driver" mode */
819 USB_DEVICE(0x0582, 0x0023),
820 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
821 .vendor_name = "EDIROL",
822 .product_name = "UM-550",
824 .type = QUIRK_MIDI_FIXED_ENDPOINT,
825 .data = & (const struct snd_usb_midi_endpoint_info) {
826 .out_cables = 0x003f,
833 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
834 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
837 USB_DEVICE(0x0582, 0x0025),
838 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
839 .vendor_name = "EDIROL",
840 .product_name = "UA-20",
841 .ifnum = QUIRK_ANY_INTERFACE,
842 .type = QUIRK_COMPOSITE,
843 .data = (const struct snd_usb_audio_quirk[]) {
846 .type = QUIRK_IGNORE_INTERFACE
850 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
851 .data = & (const struct audioformat) {
852 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
860 .rates = SNDRV_PCM_RATE_CONTINUOUS,
867 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
868 .data = & (const struct audioformat) {
869 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
877 .rates = SNDRV_PCM_RATE_CONTINUOUS,
884 .type = QUIRK_MIDI_FIXED_ENDPOINT,
885 .data = & (const struct snd_usb_midi_endpoint_info) {
886 .out_cables = 0x0001,
897 /* has ID 0x0028 when not in "Advanced Driver" mode */
898 USB_DEVICE(0x0582, 0x0027),
899 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
900 .vendor_name = "EDIROL",
901 .product_name = "SD-20",
903 .type = QUIRK_MIDI_FIXED_ENDPOINT,
904 .data = & (const struct snd_usb_midi_endpoint_info) {
905 .out_cables = 0x0003,
911 /* has ID 0x002a when not in "Advanced Driver" mode */
912 USB_DEVICE(0x0582, 0x0029),
913 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
914 .vendor_name = "EDIROL",
915 .product_name = "SD-80",
917 .type = QUIRK_MIDI_FIXED_ENDPOINT,
918 .data = & (const struct snd_usb_midi_endpoint_info) {
919 .out_cables = 0x000f,
925 * This quirk is for the "Advanced" modes of the Edirol UA-700.
926 * If the sample format switch is not in an advanced setting, the
927 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
928 * but offers only 16-bit PCM and no MIDI.
930 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
931 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
932 .vendor_name = "EDIROL",
933 .product_name = "UA-700",
934 .ifnum = QUIRK_ANY_INTERFACE,
935 .type = QUIRK_COMPOSITE,
936 .data = (const struct snd_usb_audio_quirk[]) {
939 .type = QUIRK_AUDIO_EDIROL_UAXX
943 .type = QUIRK_AUDIO_EDIROL_UAXX
947 .type = QUIRK_AUDIO_EDIROL_UAXX
956 /* has ID 0x002e when not in "Advanced Driver" mode */
957 USB_DEVICE(0x0582, 0x002d),
958 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
959 .vendor_name = "Roland",
960 .product_name = "XV-2020",
962 .type = QUIRK_MIDI_FIXED_ENDPOINT,
963 .data = & (const struct snd_usb_midi_endpoint_info) {
964 .out_cables = 0x0001,
970 /* has ID 0x0030 when not in "Advanced Driver" mode */
971 USB_DEVICE(0x0582, 0x002f),
972 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
973 .vendor_name = "Roland",
974 .product_name = "VariOS",
976 .type = QUIRK_MIDI_FIXED_ENDPOINT,
977 .data = & (const struct snd_usb_midi_endpoint_info) {
978 .out_cables = 0x0007,
984 /* has ID 0x0034 when not in "Advanced Driver" mode */
985 USB_DEVICE(0x0582, 0x0033),
986 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
987 .vendor_name = "EDIROL",
988 .product_name = "PCR",
990 .type = QUIRK_MIDI_FIXED_ENDPOINT,
991 .data = & (const struct snd_usb_midi_endpoint_info) {
992 .out_cables = 0x0003,
997 /* TODO: add Roland M-1000 support */
1000 * Has ID 0x0038 when not in "Advanced Driver" mode;
1001 * later revisions use IDs 0x0054 and 0x00a2.
1003 USB_DEVICE(0x0582, 0x0037),
1004 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1005 .vendor_name = "Roland",
1006 .product_name = "Digital Piano",
1008 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1009 .data = & (const struct snd_usb_midi_endpoint_info) {
1010 .out_cables = 0x0001,
1017 * This quirk is for the "Advanced Driver" mode. If off, the GS-10
1018 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1021 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1022 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1023 .vendor_name = "BOSS",
1024 .product_name = "GS-10",
1025 .ifnum = QUIRK_ANY_INTERFACE,
1026 .type = QUIRK_COMPOSITE,
1027 .data = & (const struct snd_usb_audio_quirk[]) {
1030 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1034 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1038 .type = QUIRK_MIDI_STANDARD_INTERFACE
1047 /* has ID 0x0041 when not in "Advanced Driver" mode */
1048 USB_DEVICE(0x0582, 0x0040),
1049 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1050 .vendor_name = "Roland",
1051 .product_name = "GI-20",
1053 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1054 .data = & (const struct snd_usb_midi_endpoint_info) {
1055 .out_cables = 0x0001,
1061 /* has ID 0x0043 when not in "Advanced Driver" mode */
1062 USB_DEVICE(0x0582, 0x0042),
1063 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1064 .vendor_name = "Roland",
1065 .product_name = "RS-70",
1067 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1068 .data = & (const struct snd_usb_midi_endpoint_info) {
1069 .out_cables = 0x0001,
1075 /* has ID 0x0049 when not in "Advanced Driver" mode */
1076 USB_DEVICE(0x0582, 0x0047),
1077 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1078 /* .vendor_name = "EDIROL", */
1079 /* .product_name = "UR-80", */
1080 .ifnum = QUIRK_ANY_INTERFACE,
1081 .type = QUIRK_COMPOSITE,
1082 .data = (const struct snd_usb_audio_quirk[]) {
1083 /* in the 96 kHz modes, only interface 1 is there */
1086 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1090 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1099 /* has ID 0x004a when not in "Advanced Driver" mode */
1100 USB_DEVICE(0x0582, 0x0048),
1101 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1102 /* .vendor_name = "EDIROL", */
1103 /* .product_name = "UR-80", */
1105 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1106 .data = & (const struct snd_usb_midi_endpoint_info) {
1107 .out_cables = 0x0003,
1112 /* TODO: add Edirol M-100FX support */
1114 /* has ID 0x004e when not in "Advanced Driver" mode */
1115 USB_DEVICE(0x0582, 0x004c),
1116 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1117 .vendor_name = "EDIROL",
1118 .product_name = "PCR-A",
1119 .ifnum = QUIRK_ANY_INTERFACE,
1120 .type = QUIRK_COMPOSITE,
1121 .data = (const struct snd_usb_audio_quirk[]) {
1124 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1128 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1137 /* has ID 0x004f when not in "Advanced Driver" mode */
1138 USB_DEVICE(0x0582, 0x004d),
1139 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1140 .vendor_name = "EDIROL",
1141 .product_name = "PCR-A",
1143 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1144 .data = & (const struct snd_usb_midi_endpoint_info) {
1145 .out_cables = 0x0003,
1152 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1153 * is standard compliant, but has only 16-bit PCM.
1155 USB_DEVICE(0x0582, 0x0050),
1156 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1157 .vendor_name = "EDIROL",
1158 .product_name = "UA-3FX",
1159 .ifnum = QUIRK_ANY_INTERFACE,
1160 .type = QUIRK_COMPOSITE,
1161 .data = (const struct snd_usb_audio_quirk[]) {
1164 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1168 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1177 USB_DEVICE(0x0582, 0x0052),
1178 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1179 .vendor_name = "EDIROL",
1180 .product_name = "UM-1SX",
1182 .type = QUIRK_MIDI_STANDARD_INTERFACE
1186 USB_DEVICE(0x0582, 0x0060),
1187 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1188 .vendor_name = "Roland",
1189 .product_name = "EXR Series",
1191 .type = QUIRK_MIDI_STANDARD_INTERFACE
1195 /* has ID 0x0066 when not in "Advanced Driver" mode */
1196 USB_DEVICE(0x0582, 0x0064),
1197 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1198 /* .vendor_name = "EDIROL", */
1199 /* .product_name = "PCR-1", */
1200 .ifnum = QUIRK_ANY_INTERFACE,
1201 .type = QUIRK_COMPOSITE,
1202 .data = (const struct snd_usb_audio_quirk[]) {
1205 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1209 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1218 /* has ID 0x0067 when not in "Advanced Driver" mode */
1219 USB_DEVICE(0x0582, 0x0065),
1220 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1221 /* .vendor_name = "EDIROL", */
1222 /* .product_name = "PCR-1", */
1224 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1225 .data = & (const struct snd_usb_midi_endpoint_info) {
1226 .out_cables = 0x0001,
1232 /* has ID 0x006b when not in "Advanced Driver" mode */
1233 USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1234 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1235 .vendor_name = "Roland",
1236 .product_name = "SP-606",
1238 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1239 .data = & (const struct snd_usb_midi_endpoint_info) {
1240 .out_cables = 0x0001,
1246 /* has ID 0x006e when not in "Advanced Driver" mode */
1247 USB_DEVICE(0x0582, 0x006d),
1248 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1249 .vendor_name = "Roland",
1250 .product_name = "FANTOM-X",
1252 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1253 .data = & (const struct snd_usb_midi_endpoint_info) {
1254 .out_cables = 0x0001,
1260 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1261 * If the switch is not in an advanced setting, the UA-25 has
1262 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1263 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1265 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1266 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1267 .vendor_name = "EDIROL",
1268 .product_name = "UA-25",
1269 .ifnum = QUIRK_ANY_INTERFACE,
1270 .type = QUIRK_COMPOSITE,
1271 .data = (const struct snd_usb_audio_quirk[]) {
1274 .type = QUIRK_AUDIO_EDIROL_UAXX
1278 .type = QUIRK_AUDIO_EDIROL_UAXX
1282 .type = QUIRK_AUDIO_EDIROL_UAXX
1291 /* has ID 0x0076 when not in "Advanced Driver" mode */
1292 USB_DEVICE(0x0582, 0x0075),
1293 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1294 .vendor_name = "BOSS",
1295 .product_name = "DR-880",
1297 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1298 .data = & (const struct snd_usb_midi_endpoint_info) {
1299 .out_cables = 0x0001,
1305 /* has ID 0x007b when not in "Advanced Driver" mode */
1306 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1307 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1308 .vendor_name = "Roland",
1309 /* "RD" or "RD-700SX"? */
1311 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1312 .data = & (const struct snd_usb_midi_endpoint_info) {
1313 .out_cables = 0x0003,
1319 /* has ID 0x0081 when not in "Advanced Driver" mode */
1320 USB_DEVICE(0x0582, 0x0080),
1321 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1322 .vendor_name = "Roland",
1323 .product_name = "G-70",
1325 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1326 .data = & (const struct snd_usb_midi_endpoint_info) {
1327 .out_cables = 0x0001,
1332 /* TODO: add Roland V-SYNTH XT support */
1333 /* TODO: add BOSS GT-PRO support */
1335 /* has ID 0x008c when not in "Advanced Driver" mode */
1336 USB_DEVICE(0x0582, 0x008b),
1337 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1338 .vendor_name = "EDIROL",
1339 .product_name = "PC-50",
1341 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1342 .data = & (const struct snd_usb_midi_endpoint_info) {
1343 .out_cables = 0x0001,
1348 /* TODO: add Edirol PC-80 support */
1350 USB_DEVICE(0x0582, 0x0096),
1351 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1352 .vendor_name = "EDIROL",
1353 .product_name = "UA-1EX",
1354 .ifnum = QUIRK_ANY_INTERFACE,
1355 .type = QUIRK_COMPOSITE,
1356 .data = (const struct snd_usb_audio_quirk[]) {
1359 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1363 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1372 USB_DEVICE(0x0582, 0x009a),
1373 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1374 .vendor_name = "EDIROL",
1375 .product_name = "UM-3EX",
1377 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1378 .data = & (const struct snd_usb_midi_endpoint_info) {
1379 .out_cables = 0x000f,
1386 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1387 * is standard compliant, but has only 16-bit PCM and no MIDI.
1389 USB_DEVICE(0x0582, 0x00a3),
1390 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1391 .vendor_name = "EDIROL",
1392 .product_name = "UA-4FX",
1393 .ifnum = QUIRK_ANY_INTERFACE,
1394 .type = QUIRK_COMPOSITE,
1395 .data = (const struct snd_usb_audio_quirk[]) {
1398 .type = QUIRK_AUDIO_EDIROL_UAXX
1402 .type = QUIRK_AUDIO_EDIROL_UAXX
1406 .type = QUIRK_AUDIO_EDIROL_UAXX
1414 /* TODO: add Edirol MD-P1 support */
1416 USB_DEVICE(0x582, 0x00a6),
1417 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1418 .vendor_name = "Roland",
1419 .product_name = "Juno-G",
1421 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1422 .data = & (const struct snd_usb_midi_endpoint_info) {
1423 .out_cables = 0x0001,
1430 USB_DEVICE(0x0582, 0x00ad),
1431 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1432 .vendor_name = "Roland",
1433 .product_name = "SH-201",
1434 .ifnum = QUIRK_ANY_INTERFACE,
1435 .type = QUIRK_COMPOSITE,
1436 .data = (const struct snd_usb_audio_quirk[]) {
1439 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1443 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1447 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1448 .data = & (const struct snd_usb_midi_endpoint_info) {
1449 .out_cables = 0x0001,
1460 /* Advanced mode of the Roland VG-99, with MIDI and 24-bit PCM at 44.1
1461 * kHz. In standard mode, the device has ID 0582:00b3, and offers
1462 * 16-bit PCM at 44.1 kHz with no MIDI.
1464 USB_DEVICE(0x0582, 0x00b2),
1465 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1466 .vendor_name = "Roland",
1467 .product_name = "VG-99",
1468 .ifnum = QUIRK_ANY_INTERFACE,
1469 .type = QUIRK_COMPOSITE,
1470 .data = (const struct snd_usb_audio_quirk[]) {
1473 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1477 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1481 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1482 .data = & (const struct snd_usb_midi_endpoint_info) {
1483 .out_cables = 0x0003,
1494 /* Roland SonicCell */
1495 USB_DEVICE(0x0582, 0x00c2),
1496 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1497 .vendor_name = "Roland",
1498 .product_name = "SonicCell",
1499 .ifnum = QUIRK_ANY_INTERFACE,
1500 .type = QUIRK_COMPOSITE,
1501 .data = (const struct snd_usb_audio_quirk[]) {
1504 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1508 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1512 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1513 .data = & (const struct snd_usb_midi_endpoint_info) {
1514 .out_cables = 0x0001,
1526 /* FIXME: This quirk gives a good-working capture stream but the
1527 * playback seems problematic because of lacking of sync
1528 * with capture stream. It needs to sync with the capture
1529 * clock. As now, you'll get frequent sound distortions
1532 USB_DEVICE(0x0582, 0x00c4),
1533 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1534 .ifnum = QUIRK_ANY_INTERFACE,
1535 .type = QUIRK_COMPOSITE,
1536 .data = (const struct snd_usb_audio_quirk[]) {
1539 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1543 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1547 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1548 .data = & (const struct snd_usb_midi_endpoint_info) {
1549 .out_cables = 0x0001,
1561 USB_DEVICE(0x0582, 0x00da),
1562 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1563 .ifnum = QUIRK_ANY_INTERFACE,
1564 .type = QUIRK_COMPOSITE,
1565 .data = (const struct snd_usb_audio_quirk[]) {
1568 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1572 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1576 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1577 .data = & (const struct snd_usb_midi_endpoint_info) {
1578 .out_cables = 0x0001,
1589 /* Advanced modes of the Edirol UA-25EX.
1590 * For the standard mode, UA-25EX has ID 0582:00e7, which
1591 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1593 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1594 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1595 .vendor_name = "EDIROL",
1596 .product_name = "UA-25EX",
1597 .ifnum = QUIRK_ANY_INTERFACE,
1598 .type = QUIRK_COMPOSITE,
1599 .data = (const struct snd_usb_audio_quirk[]) {
1602 .type = QUIRK_AUDIO_EDIROL_UAXX
1606 .type = QUIRK_AUDIO_EDIROL_UAXX
1610 .type = QUIRK_AUDIO_EDIROL_UAXX
1619 /* has ID 0x00ea when not in Advanced Driver mode */
1620 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9),
1621 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1622 /* .vendor_name = "Roland", */
1623 /* .product_name = "UA-1G", */
1624 .ifnum = QUIRK_ANY_INTERFACE,
1625 .type = QUIRK_COMPOSITE,
1626 .data = (const struct snd_usb_audio_quirk[]) {
1629 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1633 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1642 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0104),
1643 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1644 /* .vendor_name = "Roland", */
1645 /* .product_name = "UM-1G", */
1647 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1648 .data = & (const struct snd_usb_midi_endpoint_info) {
1649 .out_cables = 0x0001,
1656 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1657 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1659 .type = QUIRK_MIDI_STANDARD_INTERFACE
1663 /* Boss JS-8 Jam Station */
1664 USB_DEVICE(0x0582, 0x0109),
1665 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1666 /* .vendor_name = "BOSS", */
1667 /* .product_name = "JS-8", */
1668 .ifnum = QUIRK_ANY_INTERFACE,
1669 .type = QUIRK_COMPOSITE,
1670 .data = (const struct snd_usb_audio_quirk[]) {
1673 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1677 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1681 .type = QUIRK_MIDI_STANDARD_INTERFACE
1690 /* has ID 0x0110 when not in Advanced Driver mode */
1691 USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f),
1692 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1693 /* .vendor_name = "Roland", */
1694 /* .product_name = "A-PRO", */
1696 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1697 .data = & (const struct snd_usb_midi_endpoint_info) {
1698 .out_cables = 0x0003,
1704 /* Roland GAIA SH-01 */
1705 USB_DEVICE(0x0582, 0x0111),
1706 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1707 .vendor_name = "Roland",
1708 .product_name = "GAIA",
1709 .ifnum = QUIRK_ANY_INTERFACE,
1710 .type = QUIRK_COMPOSITE,
1711 .data = (const struct snd_usb_audio_quirk[]) {
1714 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1718 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1722 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1723 .data = &(const struct snd_usb_midi_endpoint_info) {
1724 .out_cables = 0x0003,
1735 USB_DEVICE(0x0582, 0x0113),
1736 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1737 /* .vendor_name = "BOSS", */
1738 /* .product_name = "ME-25", */
1739 .ifnum = QUIRK_ANY_INTERFACE,
1740 .type = QUIRK_COMPOSITE,
1741 .data = (const struct snd_usb_audio_quirk[]) {
1744 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1748 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1752 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1753 .data = & (const struct snd_usb_midi_endpoint_info) {
1754 .out_cables = 0x0001,
1765 USB_DEVICE(0x0582, 0x0127),
1766 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1767 /* .vendor_name = "Roland", */
1768 /* .product_name = "GR-55", */
1769 .ifnum = QUIRK_ANY_INTERFACE,
1770 .type = QUIRK_COMPOSITE,
1771 .data = (const struct snd_usb_audio_quirk[]) {
1774 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1778 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1782 .type = QUIRK_MIDI_STANDARD_INTERFACE
1791 /* Added support for Roland UM-ONE which differs from UM-1 */
1792 USB_DEVICE(0x0582, 0x012a),
1793 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1794 /* .vendor_name = "ROLAND", */
1795 /* .product_name = "UM-ONE", */
1797 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1798 .data = & (const struct snd_usb_midi_endpoint_info) {
1799 .out_cables = 0x0001,
1805 USB_DEVICE(0x0582, 0x011e),
1806 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1807 /* .vendor_name = "BOSS", */
1808 /* .product_name = "BR-800", */
1809 .ifnum = QUIRK_ANY_INTERFACE,
1810 .type = QUIRK_COMPOSITE,
1811 .data = (const struct snd_usb_audio_quirk[]) {
1814 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1818 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1822 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1823 .data = & (const struct snd_usb_midi_endpoint_info) {
1824 .out_cables = 0x0001,
1835 USB_DEVICE(0x0582, 0x0130),
1836 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1837 /* .vendor_name = "BOSS", */
1838 /* .product_name = "MICRO BR-80", */
1839 .ifnum = QUIRK_ANY_INTERFACE,
1840 .type = QUIRK_COMPOSITE,
1841 .data = (const struct snd_usb_audio_quirk[]) {
1844 .type = QUIRK_IGNORE_INTERFACE
1848 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1852 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1856 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1857 .data = & (const struct snd_usb_midi_endpoint_info) {
1858 .out_cables = 0x0001,
1869 USB_DEVICE(0x0582, 0x014d),
1870 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1871 /* .vendor_name = "BOSS", */
1872 /* .product_name = "GT-100", */
1873 .ifnum = QUIRK_ANY_INTERFACE,
1874 .type = QUIRK_COMPOSITE,
1875 .data = (const struct snd_usb_audio_quirk[]) {
1878 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1882 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1886 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1887 .data = & (const struct snd_usb_midi_endpoint_info) {
1888 .out_cables = 0x0001,
1899 /* Guillemot devices */
1902 * This is for the "Windows Edition" where the external MIDI ports are
1903 * the only MIDI ports; the control data is reported through HID
1904 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard
1905 * compliant USB MIDI ports for external MIDI and controls.
1907 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1908 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1909 .vendor_name = "Hercules",
1910 .product_name = "DJ Console (WE)",
1912 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1913 .data = & (const struct snd_usb_midi_endpoint_info) {
1914 .out_cables = 0x0001,
1920 /* Midiman/M-Audio devices */
1922 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1923 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1924 .vendor_name = "M-Audio",
1925 .product_name = "MidiSport 2x2",
1926 .ifnum = QUIRK_ANY_INTERFACE,
1927 .type = QUIRK_MIDI_MIDIMAN,
1928 .data = & (const struct snd_usb_midi_endpoint_info) {
1929 .out_cables = 0x0003,
1935 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1936 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1937 .vendor_name = "M-Audio",
1938 .product_name = "MidiSport 1x1",
1939 .ifnum = QUIRK_ANY_INTERFACE,
1940 .type = QUIRK_MIDI_MIDIMAN,
1941 .data = & (const struct snd_usb_midi_endpoint_info) {
1942 .out_cables = 0x0001,
1948 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1949 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1950 .vendor_name = "M-Audio",
1951 .product_name = "Keystation",
1952 .ifnum = QUIRK_ANY_INTERFACE,
1953 .type = QUIRK_MIDI_MIDIMAN,
1954 .data = & (const struct snd_usb_midi_endpoint_info) {
1955 .out_cables = 0x0001,
1961 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1962 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1963 .vendor_name = "M-Audio",
1964 .product_name = "MidiSport 4x4",
1965 .ifnum = QUIRK_ANY_INTERFACE,
1966 .type = QUIRK_MIDI_MIDIMAN,
1967 .data = & (const struct snd_usb_midi_endpoint_info) {
1968 .out_cables = 0x000f,
1975 * For hardware revision 1.05; in the later revisions (1.10 and
1976 * 1.21), 0x1031 is the ID for the device without firmware.
1977 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1979 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1980 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1981 .vendor_name = "M-Audio",
1982 .product_name = "MidiSport 8x8",
1983 .ifnum = QUIRK_ANY_INTERFACE,
1984 .type = QUIRK_MIDI_MIDIMAN,
1985 .data = & (const struct snd_usb_midi_endpoint_info) {
1986 .out_cables = 0x01ff,
1992 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1993 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1994 .vendor_name = "M-Audio",
1995 .product_name = "MidiSport 8x8",
1996 .ifnum = QUIRK_ANY_INTERFACE,
1997 .type = QUIRK_MIDI_MIDIMAN,
1998 .data = & (const struct snd_usb_midi_endpoint_info) {
1999 .out_cables = 0x01ff,
2005 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
2006 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2007 .vendor_name = "M-Audio",
2008 .product_name = "MidiSport 2x4",
2009 .ifnum = QUIRK_ANY_INTERFACE,
2010 .type = QUIRK_MIDI_MIDIMAN,
2011 .data = & (const struct snd_usb_midi_endpoint_info) {
2012 .out_cables = 0x000f,
2018 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
2019 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2020 .vendor_name = "M-Audio",
2021 .product_name = "Quattro",
2022 .ifnum = QUIRK_ANY_INTERFACE,
2023 .type = QUIRK_COMPOSITE,
2024 .data = & (const struct snd_usb_audio_quirk[]) {
2026 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
2027 * and share endpoints with the other interfaces.
2028 * Ignore them. The other interfaces can do 24 bits,
2029 * but captured samples are big-endian (see usbaudio.c).
2033 .type = QUIRK_IGNORE_INTERFACE
2037 .type = QUIRK_IGNORE_INTERFACE
2041 .type = QUIRK_IGNORE_INTERFACE
2045 .type = QUIRK_IGNORE_INTERFACE
2049 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2053 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2057 .type = QUIRK_IGNORE_INTERFACE
2061 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2065 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2069 .type = QUIRK_MIDI_MIDIMAN,
2070 .data = & (const struct snd_usb_midi_endpoint_info) {
2071 .out_cables = 0x0001,
2082 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
2083 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2084 .vendor_name = "M-Audio",
2085 .product_name = "AudioPhile",
2087 .type = QUIRK_MIDI_MIDIMAN,
2088 .data = & (const struct snd_usb_midi_endpoint_info) {
2089 .out_cables = 0x0001,
2095 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
2096 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2097 .vendor_name = "M-Audio",
2098 .product_name = "Ozone",
2100 .type = QUIRK_MIDI_MIDIMAN,
2101 .data = & (const struct snd_usb_midi_endpoint_info) {
2102 .out_cables = 0x0001,
2108 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
2109 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2110 .vendor_name = "M-Audio",
2111 .product_name = "OmniStudio",
2112 .ifnum = QUIRK_ANY_INTERFACE,
2113 .type = QUIRK_COMPOSITE,
2114 .data = & (const struct snd_usb_audio_quirk[]) {
2117 .type = QUIRK_IGNORE_INTERFACE
2121 .type = QUIRK_IGNORE_INTERFACE
2125 .type = QUIRK_IGNORE_INTERFACE
2129 .type = QUIRK_IGNORE_INTERFACE
2133 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2137 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2141 .type = QUIRK_IGNORE_INTERFACE
2145 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2149 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2153 .type = QUIRK_MIDI_MIDIMAN,
2154 .data = & (const struct snd_usb_midi_endpoint_info) {
2155 .out_cables = 0x0001,
2166 USB_DEVICE(0x0763, 0x2019),
2167 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2168 /* .vendor_name = "M-Audio", */
2169 /* .product_name = "Ozone Academic", */
2170 .ifnum = QUIRK_ANY_INTERFACE,
2171 .type = QUIRK_COMPOSITE,
2172 .data = & (const struct snd_usb_audio_quirk[]) {
2175 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2179 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2183 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2187 .type = QUIRK_MIDI_MIDIMAN,
2188 .data = & (const struct snd_usb_midi_endpoint_info) {
2189 .out_cables = 0x0001,
2200 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2201 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2202 /* .vendor_name = "M-Audio", */
2203 /* .product_name = "Fast Track C400", */
2204 .ifnum = QUIRK_ANY_INTERFACE,
2205 .type = QUIRK_COMPOSITE,
2206 .data = &(const struct snd_usb_audio_quirk[]) {
2209 .type = QUIRK_AUDIO_STANDARD_MIXER,
2214 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2215 .data = &(const struct audioformat) {
2216 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2221 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2224 .rates = SNDRV_PCM_RATE_44100 |
2225 SNDRV_PCM_RATE_48000 |
2226 SNDRV_PCM_RATE_88200 |
2227 SNDRV_PCM_RATE_96000,
2231 .rate_table = (unsigned int[]) {
2232 44100, 48000, 88200, 96000
2240 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2241 .data = &(const struct audioformat) {
2242 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2247 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2250 .rates = SNDRV_PCM_RATE_44100 |
2251 SNDRV_PCM_RATE_48000 |
2252 SNDRV_PCM_RATE_88200 |
2253 SNDRV_PCM_RATE_96000,
2257 .rate_table = (unsigned int[]) {
2258 44100, 48000, 88200, 96000
2265 .ifnum = -1 /* Interface = 4 */
2271 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2272 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2273 /* .vendor_name = "M-Audio", */
2274 /* .product_name = "Fast Track Ultra", */
2275 .ifnum = QUIRK_ANY_INTERFACE,
2276 .type = QUIRK_COMPOSITE,
2277 .data = & (const struct snd_usb_audio_quirk[]) {
2280 .type = QUIRK_AUDIO_STANDARD_MIXER,
2284 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2285 .data = & (const struct audioformat) {
2286 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2291 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2294 .rates = SNDRV_PCM_RATE_44100 |
2295 SNDRV_PCM_RATE_48000 |
2296 SNDRV_PCM_RATE_88200 |
2297 SNDRV_PCM_RATE_96000,
2301 .rate_table = (unsigned int[]) {
2302 44100, 48000, 88200, 96000
2308 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2309 .data = & (const struct audioformat) {
2310 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2315 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2318 .rates = SNDRV_PCM_RATE_44100 |
2319 SNDRV_PCM_RATE_48000 |
2320 SNDRV_PCM_RATE_88200 |
2321 SNDRV_PCM_RATE_96000,
2325 .rate_table = (unsigned int[]) {
2326 44100, 48000, 88200, 96000
2330 /* interface 3 (MIDI) is standard compliant */
2338 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2339 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2340 /* .vendor_name = "M-Audio", */
2341 /* .product_name = "Fast Track Ultra 8R", */
2342 .ifnum = QUIRK_ANY_INTERFACE,
2343 .type = QUIRK_COMPOSITE,
2344 .data = & (const struct snd_usb_audio_quirk[]) {
2347 .type = QUIRK_AUDIO_STANDARD_MIXER,
2351 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2352 .data = & (const struct audioformat) {
2353 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2358 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2361 .rates = SNDRV_PCM_RATE_44100 |
2362 SNDRV_PCM_RATE_48000 |
2363 SNDRV_PCM_RATE_88200 |
2364 SNDRV_PCM_RATE_96000,
2368 .rate_table = (unsigned int[]) {
2369 44100, 48000, 88200, 96000
2375 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2376 .data = & (const struct audioformat) {
2377 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2382 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2385 .rates = SNDRV_PCM_RATE_44100 |
2386 SNDRV_PCM_RATE_48000 |
2387 SNDRV_PCM_RATE_88200 |
2388 SNDRV_PCM_RATE_96000,
2392 .rate_table = (unsigned int[]) {
2393 44100, 48000, 88200, 96000
2397 /* interface 3 (MIDI) is standard compliant */
2407 USB_DEVICE(0x07cf, 0x6801),
2408 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2409 .vendor_name = "Casio",
2410 .product_name = "PL-40R",
2412 .type = QUIRK_MIDI_YAMAHA
2416 /* this ID is used by several devices without a product ID */
2417 USB_DEVICE(0x07cf, 0x6802),
2418 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2419 .vendor_name = "Casio",
2420 .product_name = "Keyboard",
2422 .type = QUIRK_MIDI_YAMAHA
2426 /* Mark of the Unicorn devices */
2428 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2429 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2430 USB_DEVICE_ID_MATCH_PRODUCT |
2431 USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2433 .idProduct = 0x0001,
2434 .bDeviceSubClass = 2,
2435 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2436 .vendor_name = "MOTU",
2437 .product_name = "Fastlane",
2438 .ifnum = QUIRK_ANY_INTERFACE,
2439 .type = QUIRK_COMPOSITE,
2440 .data = & (const struct snd_usb_audio_quirk[]) {
2443 .type = QUIRK_MIDI_RAW_BYTES
2447 .type = QUIRK_IGNORE_INTERFACE
2456 /* Emagic devices */
2458 USB_DEVICE(0x086a, 0x0001),
2459 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2460 .vendor_name = "Emagic",
2461 /* .product_name = "Unitor8", */
2463 .type = QUIRK_MIDI_EMAGIC,
2464 .data = & (const struct snd_usb_midi_endpoint_info) {
2465 .out_cables = 0x80ff,
2471 USB_DEVICE(0x086a, 0x0002),
2472 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2473 .vendor_name = "Emagic",
2474 /* .product_name = "AMT8", */
2476 .type = QUIRK_MIDI_EMAGIC,
2477 .data = & (const struct snd_usb_midi_endpoint_info) {
2478 .out_cables = 0x80ff,
2484 USB_DEVICE(0x086a, 0x0003),
2485 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2486 .vendor_name = "Emagic",
2487 /* .product_name = "MT4", */
2489 .type = QUIRK_MIDI_EMAGIC,
2490 .data = & (const struct snd_usb_midi_endpoint_info) {
2491 .out_cables = 0x800f,
2499 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2500 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2501 .vendor_name = "KORG, Inc.",
2502 /* .product_name = "PANDORA PX5D", */
2504 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2509 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2510 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2511 .vendor_name = "KORG, Inc.",
2512 /* .product_name = "ToneLab ST", */
2514 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2520 USB_DEVICE(0x09e8, 0x0062),
2521 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2522 .vendor_name = "AKAI",
2523 .product_name = "MPD16",
2525 .type = QUIRK_MIDI_AKAI,
2529 /* TerraTec devices */
2531 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2532 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2533 .vendor_name = "TerraTec",
2534 .product_name = "PHASE 26",
2536 .type = QUIRK_MIDI_STANDARD_INTERFACE
2540 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2541 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2542 .vendor_name = "TerraTec",
2543 .product_name = "PHASE 26",
2545 .type = QUIRK_MIDI_STANDARD_INTERFACE
2549 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2550 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2551 .vendor_name = "TerraTec",
2552 .product_name = "PHASE 26",
2554 .type = QUIRK_MIDI_STANDARD_INTERFACE
2558 USB_DEVICE(0x0ccd, 0x0028),
2559 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2560 .vendor_name = "TerraTec",
2561 .product_name = "Aureon5.1MkII",
2562 .ifnum = QUIRK_NO_INTERFACE
2566 USB_DEVICE(0x0ccd, 0x0035),
2567 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2568 .vendor_name = "Miditech",
2569 .product_name = "Play'n Roll",
2571 .type = QUIRK_MIDI_CME
2575 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2577 USB_DEVICE(0x103d, 0x0100),
2578 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2579 .vendor_name = "Stanton",
2580 .product_name = "ScratchAmp",
2581 .ifnum = QUIRK_NO_INTERFACE
2585 USB_DEVICE(0x103d, 0x0101),
2586 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2587 .vendor_name = "Stanton",
2588 .product_name = "ScratchAmp",
2589 .ifnum = QUIRK_NO_INTERFACE
2593 /* Novation EMS devices */
2595 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2596 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2597 .vendor_name = "Novation",
2598 .product_name = "ReMOTE Audio/XStation",
2600 .type = QUIRK_MIDI_NOVATION
2604 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2605 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2606 .vendor_name = "Novation",
2607 .product_name = "Speedio",
2609 .type = QUIRK_MIDI_NOVATION
2613 USB_DEVICE(0x1235, 0x000e),
2614 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2615 /* .vendor_name = "Novation", */
2616 /* .product_name = "Launchpad", */
2618 .type = QUIRK_MIDI_RAW_BYTES
2622 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2623 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2624 .vendor_name = "Novation",
2625 .product_name = "ReMOTE25",
2627 .type = QUIRK_MIDI_NOVATION
2631 /* Access Music devices */
2633 /* VirusTI Desktop */
2634 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2635 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2636 .ifnum = QUIRK_ANY_INTERFACE,
2637 .type = QUIRK_COMPOSITE,
2638 .data = &(const struct snd_usb_audio_quirk[]) {
2641 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2642 .data = &(const struct snd_usb_midi_endpoint_info) {
2643 .out_cables = 0x0003,
2649 .type = QUIRK_IGNORE_INTERFACE
2660 /* aka. Serato Scratch Live DJ Box */
2661 USB_DEVICE(0x13e5, 0x0001),
2662 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2663 .vendor_name = "Rane",
2664 .product_name = "SL-1",
2665 .ifnum = QUIRK_NO_INTERFACE
2669 /* Native Instruments MK2 series */
2671 /* Komplete Audio 6 */
2672 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2674 .idProduct = 0x1000,
2677 /* Traktor Audio 6 */
2678 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2680 .idProduct = 0x1010,
2683 /* Traktor Audio 10 */
2684 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2686 .idProduct = 0x1020,
2689 /* KeithMcMillen Stringport */
2691 USB_DEVICE(0x1f38, 0x0001),
2692 .bInterfaceClass = USB_CLASS_AUDIO,
2695 /* Miditech devices */
2697 USB_DEVICE(0x4752, 0x0011),
2698 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2699 .vendor_name = "Miditech",
2700 .product_name = "Midistart-2",
2702 .type = QUIRK_MIDI_CME
2706 /* Central Music devices */
2708 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2709 USB_DEVICE(0x7104, 0x2202),
2710 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2712 .type = QUIRK_MIDI_CME
2716 /* Hauppauge HVR-950Q and HVR-850 */
2718 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
2719 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2720 USB_DEVICE_ID_MATCH_INT_CLASS |
2721 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2722 .bInterfaceClass = USB_CLASS_AUDIO,
2723 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2724 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2725 .vendor_name = "Hauppauge",
2726 .product_name = "HVR-950Q",
2727 .ifnum = QUIRK_ANY_INTERFACE,
2728 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2732 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240),
2733 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2734 USB_DEVICE_ID_MATCH_INT_CLASS |
2735 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2736 .bInterfaceClass = USB_CLASS_AUDIO,
2737 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2738 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2739 .vendor_name = "Hauppauge",
2740 .product_name = "HVR-850",
2741 .ifnum = QUIRK_ANY_INTERFACE,
2742 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2746 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210),
2747 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2748 USB_DEVICE_ID_MATCH_INT_CLASS |
2749 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2750 .bInterfaceClass = USB_CLASS_AUDIO,
2751 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2752 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2753 .vendor_name = "Hauppauge",
2754 .product_name = "HVR-950Q",
2755 .ifnum = QUIRK_ANY_INTERFACE,
2756 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2760 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217),
2761 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2762 USB_DEVICE_ID_MATCH_INT_CLASS |
2763 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2764 .bInterfaceClass = USB_CLASS_AUDIO,
2765 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2766 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2767 .vendor_name = "Hauppauge",
2768 .product_name = "HVR-950Q",
2769 .ifnum = QUIRK_ANY_INTERFACE,
2770 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2774 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b),
2775 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2776 USB_DEVICE_ID_MATCH_INT_CLASS |
2777 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2778 .bInterfaceClass = USB_CLASS_AUDIO,
2779 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2780 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2781 .vendor_name = "Hauppauge",
2782 .product_name = "HVR-950Q",
2783 .ifnum = QUIRK_ANY_INTERFACE,
2784 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2788 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e),
2789 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2790 USB_DEVICE_ID_MATCH_INT_CLASS |
2791 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2792 .bInterfaceClass = USB_CLASS_AUDIO,
2793 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2794 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2795 .vendor_name = "Hauppauge",
2796 .product_name = "HVR-950Q",
2797 .ifnum = QUIRK_ANY_INTERFACE,
2798 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2802 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f),
2803 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2804 USB_DEVICE_ID_MATCH_INT_CLASS |
2805 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2806 .bInterfaceClass = USB_CLASS_AUDIO,
2807 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2808 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2809 .vendor_name = "Hauppauge",
2810 .product_name = "HVR-950Q",
2811 .ifnum = QUIRK_ANY_INTERFACE,
2812 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2816 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280),
2817 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2818 USB_DEVICE_ID_MATCH_INT_CLASS |
2819 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2820 .bInterfaceClass = USB_CLASS_AUDIO,
2821 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2822 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2823 .vendor_name = "Hauppauge",
2824 .product_name = "HVR-950Q",
2825 .ifnum = QUIRK_ANY_INTERFACE,
2826 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2830 USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008),
2831 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2832 USB_DEVICE_ID_MATCH_INT_CLASS |
2833 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2834 .bInterfaceClass = USB_CLASS_AUDIO,
2835 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2836 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2837 .vendor_name = "Hauppauge",
2838 .product_name = "HVR-950Q",
2839 .ifnum = QUIRK_ANY_INTERFACE,
2840 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2844 /* Digidesign Mbox */
2846 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2847 USB_DEVICE(0x0dba, 0x1000),
2848 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2849 .vendor_name = "Digidesign",
2850 .product_name = "MBox",
2851 .ifnum = QUIRK_ANY_INTERFACE,
2852 .type = QUIRK_COMPOSITE,
2853 .data = (const struct snd_usb_audio_quirk[]){
2856 .type = QUIRK_IGNORE_INTERFACE,
2860 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2861 .data = &(const struct audioformat) {
2862 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2867 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2870 .maxpacksize = 0x130,
2871 .rates = SNDRV_PCM_RATE_44100 |
2872 SNDRV_PCM_RATE_48000,
2876 .rate_table = (unsigned int[]) {
2889 /* Tascam US122 MKII - playback-only support */
2890 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2892 .idProduct = 0x8021,
2893 .bInterfaceClass = USB_CLASS_AUDIO,
2894 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2895 .vendor_name = "TASCAM",
2896 .product_name = "US122 MKII",
2897 .ifnum = QUIRK_ANY_INTERFACE,
2898 .type = QUIRK_COMPOSITE,
2899 .data = (const struct snd_usb_audio_quirk[]) {
2902 .type = QUIRK_IGNORE_INTERFACE
2906 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2907 .data = &(const struct audioformat) {
2908 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2913 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2915 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2916 .rates = SNDRV_PCM_RATE_44100 |
2917 SNDRV_PCM_RATE_48000 |
2918 SNDRV_PCM_RATE_88200 |
2919 SNDRV_PCM_RATE_96000,
2923 .rate_table = (unsigned int[]) {
2924 44100, 48000, 88200, 96000
2935 /* Microsoft XboxLive Headset/Xbox Communicator */
2937 USB_DEVICE(0x045e, 0x0283),
2938 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
2939 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2940 .vendor_name = "Microsoft",
2941 .product_name = "XboxLive Headset/Xbox Communicator",
2942 .ifnum = QUIRK_ANY_INTERFACE,
2943 .type = QUIRK_COMPOSITE,
2944 .data = &(const struct snd_usb_audio_quirk[]) {
2948 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2949 .data = &(const struct audioformat) {
2950 .formats = SNDRV_PCM_FMTBIT_S16_LE,
2958 .rates = SNDRV_PCM_RATE_CONTINUOUS,
2966 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2967 .data = &(const struct audioformat) {
2968 .formats = SNDRV_PCM_FMTBIT_S16_LE,
2976 .rates = SNDRV_PCM_RATE_CONTINUOUS,
2990 USB_DEVICE(0x200c, 0x100b),
2991 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
2992 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2993 .ifnum = QUIRK_ANY_INTERFACE,
2994 .type = QUIRK_COMPOSITE,
2995 .data = &(const struct snd_usb_audio_quirk[]) {
2998 .type = QUIRK_AUDIO_STANDARD_MIXER,
3002 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3003 .data = &(const struct audioformat) {
3004 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3009 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3011 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3012 .rates = SNDRV_PCM_RATE_44100 |
3013 SNDRV_PCM_RATE_48000,
3017 .rate_table = (unsigned int[]) {
3031 * Focusrite Scarlett 18i6
3033 * Avoid mixer creation, which otherwise fails because some of
3034 * the interface descriptor subtypes for interface 0 are
3035 * unknown. That should be fixed or worked-around but this at
3036 * least allows the device to be used successfully with a DAW
3037 * and an external mixer. See comments below about other
3038 * ignored interfaces.
3040 USB_DEVICE(0x1235, 0x8004),
3041 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3042 .vendor_name = "Focusrite",
3043 .product_name = "Scarlett 18i6",
3044 .ifnum = QUIRK_ANY_INTERFACE,
3045 .type = QUIRK_COMPOSITE,
3046 .data = & (const struct snd_usb_audio_quirk[]) {
3048 /* InterfaceSubClass 1 (Control Device) */
3050 .type = QUIRK_IGNORE_INTERFACE
3054 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3058 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3061 /* InterfaceSubClass 1 (Control Device) */
3063 .type = QUIRK_IGNORE_INTERFACE
3067 .type = QUIRK_MIDI_STANDARD_INTERFACE
3070 /* InterfaceSubClass 1 (Device Firmware Update) */
3072 .type = QUIRK_IGNORE_INTERFACE
3083 * Some USB MIDI devices don't have an audio control interface,
3084 * so we have to grab MIDI streaming interfaces here.
3086 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3087 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3088 .bInterfaceClass = USB_CLASS_AUDIO,
3089 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3090 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3091 .ifnum = QUIRK_ANY_INTERFACE,
3092 .type = QUIRK_MIDI_STANDARD_INTERFACE
3096 #undef USB_DEVICE_VENDOR_SPEC