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, 0x2080),
2201 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2202 /* .vendor_name = "M-Audio", */
2203 /* .product_name = "Fast Track Ultra", */
2204 .ifnum = QUIRK_ANY_INTERFACE,
2205 .type = QUIRK_COMPOSITE,
2206 .data = & (const struct snd_usb_audio_quirk[]) {
2209 .type = QUIRK_AUDIO_STANDARD_MIXER,
2213 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2214 .data = & (const struct audioformat) {
2215 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2220 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2223 .rates = SNDRV_PCM_RATE_44100 |
2224 SNDRV_PCM_RATE_48000 |
2225 SNDRV_PCM_RATE_88200 |
2226 SNDRV_PCM_RATE_96000,
2230 .rate_table = (unsigned int[]) {
2231 44100, 48000, 88200, 96000
2237 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2238 .data = & (const struct audioformat) {
2239 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2244 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2247 .rates = SNDRV_PCM_RATE_44100 |
2248 SNDRV_PCM_RATE_48000 |
2249 SNDRV_PCM_RATE_88200 |
2250 SNDRV_PCM_RATE_96000,
2254 .rate_table = (unsigned int[]) {
2255 44100, 48000, 88200, 96000
2259 /* interface 3 (MIDI) is standard compliant */
2267 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2268 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2269 /* .vendor_name = "M-Audio", */
2270 /* .product_name = "Fast Track Ultra 8R", */
2271 .ifnum = QUIRK_ANY_INTERFACE,
2272 .type = QUIRK_COMPOSITE,
2273 .data = & (const struct snd_usb_audio_quirk[]) {
2276 .type = QUIRK_AUDIO_STANDARD_MIXER,
2280 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2281 .data = & (const struct audioformat) {
2282 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2287 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2290 .rates = SNDRV_PCM_RATE_44100 |
2291 SNDRV_PCM_RATE_48000 |
2292 SNDRV_PCM_RATE_88200 |
2293 SNDRV_PCM_RATE_96000,
2297 .rate_table = (unsigned int[]) {
2298 44100, 48000, 88200, 96000
2304 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2305 .data = & (const struct audioformat) {
2306 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2311 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2314 .rates = SNDRV_PCM_RATE_44100 |
2315 SNDRV_PCM_RATE_48000 |
2316 SNDRV_PCM_RATE_88200 |
2317 SNDRV_PCM_RATE_96000,
2321 .rate_table = (unsigned int[]) {
2322 44100, 48000, 88200, 96000
2326 /* interface 3 (MIDI) is standard compliant */
2336 USB_DEVICE(0x07cf, 0x6801),
2337 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2338 .vendor_name = "Casio",
2339 .product_name = "PL-40R",
2341 .type = QUIRK_MIDI_YAMAHA
2345 /* this ID is used by several devices without a product ID */
2346 USB_DEVICE(0x07cf, 0x6802),
2347 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2348 .vendor_name = "Casio",
2349 .product_name = "Keyboard",
2351 .type = QUIRK_MIDI_YAMAHA
2355 /* Mark of the Unicorn devices */
2357 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2358 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2359 USB_DEVICE_ID_MATCH_PRODUCT |
2360 USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2362 .idProduct = 0x0001,
2363 .bDeviceSubClass = 2,
2364 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2365 .vendor_name = "MOTU",
2366 .product_name = "Fastlane",
2367 .ifnum = QUIRK_ANY_INTERFACE,
2368 .type = QUIRK_COMPOSITE,
2369 .data = & (const struct snd_usb_audio_quirk[]) {
2372 .type = QUIRK_MIDI_RAW_BYTES
2376 .type = QUIRK_IGNORE_INTERFACE
2385 /* Emagic devices */
2387 USB_DEVICE(0x086a, 0x0001),
2388 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2389 .vendor_name = "Emagic",
2390 /* .product_name = "Unitor8", */
2392 .type = QUIRK_MIDI_EMAGIC,
2393 .data = & (const struct snd_usb_midi_endpoint_info) {
2394 .out_cables = 0x80ff,
2400 USB_DEVICE(0x086a, 0x0002),
2401 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2402 .vendor_name = "Emagic",
2403 /* .product_name = "AMT8", */
2405 .type = QUIRK_MIDI_EMAGIC,
2406 .data = & (const struct snd_usb_midi_endpoint_info) {
2407 .out_cables = 0x80ff,
2413 USB_DEVICE(0x086a, 0x0003),
2414 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2415 .vendor_name = "Emagic",
2416 /* .product_name = "MT4", */
2418 .type = QUIRK_MIDI_EMAGIC,
2419 .data = & (const struct snd_usb_midi_endpoint_info) {
2420 .out_cables = 0x800f,
2428 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2429 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2430 .vendor_name = "KORG, Inc.",
2431 /* .product_name = "PANDORA PX5D", */
2433 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2438 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2439 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2440 .vendor_name = "KORG, Inc.",
2441 /* .product_name = "ToneLab ST", */
2443 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2449 USB_DEVICE(0x09e8, 0x0062),
2450 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2451 .vendor_name = "AKAI",
2452 .product_name = "MPD16",
2454 .type = QUIRK_MIDI_AKAI,
2458 /* TerraTec devices */
2460 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2461 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2462 .vendor_name = "TerraTec",
2463 .product_name = "PHASE 26",
2465 .type = QUIRK_MIDI_STANDARD_INTERFACE
2469 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2470 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2471 .vendor_name = "TerraTec",
2472 .product_name = "PHASE 26",
2474 .type = QUIRK_MIDI_STANDARD_INTERFACE
2478 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2479 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2480 .vendor_name = "TerraTec",
2481 .product_name = "PHASE 26",
2483 .type = QUIRK_MIDI_STANDARD_INTERFACE
2487 USB_DEVICE(0x0ccd, 0x0028),
2488 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2489 .vendor_name = "TerraTec",
2490 .product_name = "Aureon5.1MkII",
2491 .ifnum = QUIRK_NO_INTERFACE
2495 USB_DEVICE(0x0ccd, 0x0035),
2496 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2497 .vendor_name = "Miditech",
2498 .product_name = "Play'n Roll",
2500 .type = QUIRK_MIDI_CME
2504 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2506 USB_DEVICE(0x103d, 0x0100),
2507 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2508 .vendor_name = "Stanton",
2509 .product_name = "ScratchAmp",
2510 .ifnum = QUIRK_NO_INTERFACE
2514 USB_DEVICE(0x103d, 0x0101),
2515 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2516 .vendor_name = "Stanton",
2517 .product_name = "ScratchAmp",
2518 .ifnum = QUIRK_NO_INTERFACE
2522 /* Novation EMS devices */
2524 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2525 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2526 .vendor_name = "Novation",
2527 .product_name = "ReMOTE Audio/XStation",
2529 .type = QUIRK_MIDI_NOVATION
2533 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2534 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2535 .vendor_name = "Novation",
2536 .product_name = "Speedio",
2538 .type = QUIRK_MIDI_NOVATION
2542 USB_DEVICE(0x1235, 0x000e),
2543 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2544 /* .vendor_name = "Novation", */
2545 /* .product_name = "Launchpad", */
2547 .type = QUIRK_MIDI_RAW_BYTES
2551 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2552 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2553 .vendor_name = "Novation",
2554 .product_name = "ReMOTE25",
2556 .type = QUIRK_MIDI_NOVATION
2560 /* Access Music devices */
2562 /* VirusTI Desktop */
2563 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2564 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2565 .ifnum = QUIRK_ANY_INTERFACE,
2566 .type = QUIRK_COMPOSITE,
2567 .data = &(const struct snd_usb_audio_quirk[]) {
2570 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2571 .data = &(const struct snd_usb_midi_endpoint_info) {
2572 .out_cables = 0x0003,
2578 .type = QUIRK_IGNORE_INTERFACE
2589 /* aka. Serato Scratch Live DJ Box */
2590 USB_DEVICE(0x13e5, 0x0001),
2591 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2592 .vendor_name = "Rane",
2593 .product_name = "SL-1",
2594 .ifnum = QUIRK_NO_INTERFACE
2598 /* Native Instruments MK2 series */
2600 /* Komplete Audio 6 */
2601 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2603 .idProduct = 0x1000,
2606 /* Traktor Audio 6 */
2607 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2609 .idProduct = 0x1010,
2612 /* Traktor Audio 10 */
2613 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2615 .idProduct = 0x1020,
2618 /* KeithMcMillen Stringport */
2620 USB_DEVICE(0x1f38, 0x0001),
2621 .bInterfaceClass = USB_CLASS_AUDIO,
2624 /* Miditech devices */
2626 USB_DEVICE(0x4752, 0x0011),
2627 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2628 .vendor_name = "Miditech",
2629 .product_name = "Midistart-2",
2631 .type = QUIRK_MIDI_CME
2635 /* Central Music devices */
2637 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2638 USB_DEVICE(0x7104, 0x2202),
2639 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2641 .type = QUIRK_MIDI_CME
2645 /* Hauppauge HVR-950Q and HVR-850 */
2647 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
2648 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2649 USB_DEVICE_ID_MATCH_INT_CLASS |
2650 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2651 .bInterfaceClass = USB_CLASS_AUDIO,
2652 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2653 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2654 .vendor_name = "Hauppauge",
2655 .product_name = "HVR-950Q",
2656 .ifnum = QUIRK_ANY_INTERFACE,
2657 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2661 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240),
2662 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2663 USB_DEVICE_ID_MATCH_INT_CLASS |
2664 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2665 .bInterfaceClass = USB_CLASS_AUDIO,
2666 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2667 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2668 .vendor_name = "Hauppauge",
2669 .product_name = "HVR-850",
2670 .ifnum = QUIRK_ANY_INTERFACE,
2671 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2675 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210),
2676 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2677 USB_DEVICE_ID_MATCH_INT_CLASS |
2678 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2679 .bInterfaceClass = USB_CLASS_AUDIO,
2680 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2681 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2682 .vendor_name = "Hauppauge",
2683 .product_name = "HVR-950Q",
2684 .ifnum = QUIRK_ANY_INTERFACE,
2685 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2689 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217),
2690 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2691 USB_DEVICE_ID_MATCH_INT_CLASS |
2692 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2693 .bInterfaceClass = USB_CLASS_AUDIO,
2694 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2695 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2696 .vendor_name = "Hauppauge",
2697 .product_name = "HVR-950Q",
2698 .ifnum = QUIRK_ANY_INTERFACE,
2699 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2703 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b),
2704 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2705 USB_DEVICE_ID_MATCH_INT_CLASS |
2706 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2707 .bInterfaceClass = USB_CLASS_AUDIO,
2708 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2709 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2710 .vendor_name = "Hauppauge",
2711 .product_name = "HVR-950Q",
2712 .ifnum = QUIRK_ANY_INTERFACE,
2713 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2717 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e),
2718 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2719 USB_DEVICE_ID_MATCH_INT_CLASS |
2720 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2721 .bInterfaceClass = USB_CLASS_AUDIO,
2722 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2723 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2724 .vendor_name = "Hauppauge",
2725 .product_name = "HVR-950Q",
2726 .ifnum = QUIRK_ANY_INTERFACE,
2727 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2731 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f),
2732 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2733 USB_DEVICE_ID_MATCH_INT_CLASS |
2734 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2735 .bInterfaceClass = USB_CLASS_AUDIO,
2736 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2737 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2738 .vendor_name = "Hauppauge",
2739 .product_name = "HVR-950Q",
2740 .ifnum = QUIRK_ANY_INTERFACE,
2741 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2745 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280),
2746 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2747 USB_DEVICE_ID_MATCH_INT_CLASS |
2748 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2749 .bInterfaceClass = USB_CLASS_AUDIO,
2750 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2751 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2752 .vendor_name = "Hauppauge",
2753 .product_name = "HVR-950Q",
2754 .ifnum = QUIRK_ANY_INTERFACE,
2755 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2759 USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008),
2760 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2761 USB_DEVICE_ID_MATCH_INT_CLASS |
2762 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2763 .bInterfaceClass = USB_CLASS_AUDIO,
2764 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2765 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2766 .vendor_name = "Hauppauge",
2767 .product_name = "HVR-950Q",
2768 .ifnum = QUIRK_ANY_INTERFACE,
2769 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2773 /* Digidesign Mbox */
2775 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2776 USB_DEVICE(0x0dba, 0x1000),
2777 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2778 .vendor_name = "Digidesign",
2779 .product_name = "MBox",
2780 .ifnum = QUIRK_ANY_INTERFACE,
2781 .type = QUIRK_COMPOSITE,
2782 .data = (const struct snd_usb_audio_quirk[]){
2785 .type = QUIRK_IGNORE_INTERFACE,
2789 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2790 .data = &(const struct audioformat) {
2791 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2796 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2799 .maxpacksize = 0x130,
2800 .rates = SNDRV_PCM_RATE_44100 |
2801 SNDRV_PCM_RATE_48000,
2805 .rate_table = (unsigned int[]) {
2818 /* Tascam US122 MKII - playback-only support */
2819 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2821 .idProduct = 0x8021,
2822 .bInterfaceClass = USB_CLASS_AUDIO,
2823 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2824 .vendor_name = "TASCAM",
2825 .product_name = "US122 MKII",
2826 .ifnum = QUIRK_ANY_INTERFACE,
2827 .type = QUIRK_COMPOSITE,
2828 .data = (const struct snd_usb_audio_quirk[]) {
2831 .type = QUIRK_IGNORE_INTERFACE
2835 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2836 .data = &(const struct audioformat) {
2837 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2842 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2844 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2845 .rates = SNDRV_PCM_RATE_44100 |
2846 SNDRV_PCM_RATE_48000 |
2847 SNDRV_PCM_RATE_88200 |
2848 SNDRV_PCM_RATE_96000,
2852 .rate_table = (unsigned int[]) {
2853 44100, 48000, 88200, 96000
2864 /* Microsoft XboxLive Headset/Xbox Communicator */
2866 USB_DEVICE(0x045e, 0x0283),
2867 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
2868 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2869 .vendor_name = "Microsoft",
2870 .product_name = "XboxLive Headset/Xbox Communicator",
2871 .ifnum = QUIRK_ANY_INTERFACE,
2872 .type = QUIRK_COMPOSITE,
2873 .data = &(const struct snd_usb_audio_quirk[]) {
2877 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2878 .data = &(const struct audioformat) {
2879 .formats = SNDRV_PCM_FMTBIT_S16_LE,
2887 .rates = SNDRV_PCM_RATE_CONTINUOUS,
2895 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2896 .data = &(const struct audioformat) {
2897 .formats = SNDRV_PCM_FMTBIT_S16_LE,
2905 .rates = SNDRV_PCM_RATE_CONTINUOUS,
2919 USB_DEVICE(0x200c, 0x100b),
2920 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
2921 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2922 .ifnum = QUIRK_ANY_INTERFACE,
2923 .type = QUIRK_COMPOSITE,
2924 .data = &(const struct snd_usb_audio_quirk[]) {
2927 .type = QUIRK_AUDIO_STANDARD_MIXER,
2931 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2932 .data = &(const struct audioformat) {
2933 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2938 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2940 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
2941 .rates = SNDRV_PCM_RATE_44100 |
2942 SNDRV_PCM_RATE_48000,
2946 .rate_table = (unsigned int[]) {
2960 * Focusrite Scarlett 18i6
2962 * Avoid mixer creation, which otherwise fails because some of
2963 * the interface descriptor subtypes for interface 0 are
2964 * unknown. That should be fixed or worked-around but this at
2965 * least allows the device to be used successfully with a DAW
2966 * and an external mixer. See comments below about other
2967 * ignored interfaces.
2969 USB_DEVICE(0x1235, 0x8004),
2970 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2971 .vendor_name = "Focusrite",
2972 .product_name = "Scarlett 18i6",
2973 .ifnum = QUIRK_ANY_INTERFACE,
2974 .type = QUIRK_COMPOSITE,
2975 .data = & (const struct snd_usb_audio_quirk[]) {
2977 /* InterfaceSubClass 1 (Control Device) */
2979 .type = QUIRK_IGNORE_INTERFACE
2983 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2987 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2990 /* InterfaceSubClass 1 (Control Device) */
2992 .type = QUIRK_IGNORE_INTERFACE
2996 .type = QUIRK_MIDI_STANDARD_INTERFACE
2999 /* InterfaceSubClass 1 (Device Firmware Update) */
3001 .type = QUIRK_IGNORE_INTERFACE
3012 * Some USB MIDI devices don't have an audio control interface,
3013 * so we have to grab MIDI streaming interfaces here.
3015 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3016 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3017 .bInterfaceClass = USB_CLASS_AUDIO,
3018 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3019 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3020 .ifnum = QUIRK_ANY_INTERFACE,
3021 .type = QUIRK_MIDI_STANDARD_INTERFACE
3025 #undef USB_DEVICE_VENDOR_SPEC