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
43 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
44 * class matches do not take effect without an explicit ID match.
47 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
48 USB_DEVICE_ID_MATCH_INT_CLASS |
49 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
52 .bInterfaceClass = USB_CLASS_AUDIO,
53 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
56 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
57 USB_DEVICE_ID_MATCH_INT_CLASS |
58 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
61 .bInterfaceClass = USB_CLASS_AUDIO,
62 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
65 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
66 USB_DEVICE_ID_MATCH_INT_CLASS |
67 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
70 .bInterfaceClass = USB_CLASS_AUDIO,
71 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
74 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
75 USB_DEVICE_ID_MATCH_INT_CLASS |
76 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
79 .bInterfaceClass = USB_CLASS_AUDIO,
80 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
87 #define YAMAHA_DEVICE(id, name) { \
88 USB_DEVICE(0x0499, id), \
89 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
90 .vendor_name = "Yamaha", \
91 .product_name = name, \
92 .ifnum = QUIRK_ANY_INTERFACE, \
93 .type = QUIRK_MIDI_YAMAHA \
96 #define YAMAHA_INTERFACE(id, intf, name) { \
97 USB_DEVICE_VENDOR_SPEC(0x0499, id), \
98 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
99 .vendor_name = "Yamaha", \
100 .product_name = name, \
102 .type = QUIRK_MIDI_YAMAHA \
105 YAMAHA_DEVICE(0x1000, "UX256"),
106 YAMAHA_DEVICE(0x1001, "MU1000"),
107 YAMAHA_DEVICE(0x1002, "MU2000"),
108 YAMAHA_DEVICE(0x1003, "MU500"),
109 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
110 YAMAHA_DEVICE(0x1005, "MOTIF6"),
111 YAMAHA_DEVICE(0x1006, "MOTIF7"),
112 YAMAHA_DEVICE(0x1007, "MOTIF8"),
113 YAMAHA_DEVICE(0x1008, "UX96"),
114 YAMAHA_DEVICE(0x1009, "UX16"),
115 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
116 YAMAHA_DEVICE(0x100c, "UC-MX"),
117 YAMAHA_DEVICE(0x100d, "UC-KX"),
118 YAMAHA_DEVICE(0x100e, "S08"),
119 YAMAHA_DEVICE(0x100f, "CLP-150"),
120 YAMAHA_DEVICE(0x1010, "CLP-170"),
121 YAMAHA_DEVICE(0x1011, "P-250"),
122 YAMAHA_DEVICE(0x1012, "TYROS"),
123 YAMAHA_DEVICE(0x1013, "PF-500"),
124 YAMAHA_DEVICE(0x1014, "S90"),
125 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
126 YAMAHA_DEVICE(0x1016, "MDP-5"),
127 YAMAHA_DEVICE(0x1017, "CVP-204"),
128 YAMAHA_DEVICE(0x1018, "CVP-206"),
129 YAMAHA_DEVICE(0x1019, "CVP-208"),
130 YAMAHA_DEVICE(0x101a, "CVP-210"),
131 YAMAHA_DEVICE(0x101b, "PSR-1100"),
132 YAMAHA_DEVICE(0x101c, "PSR-2100"),
133 YAMAHA_DEVICE(0x101d, "CLP-175"),
134 YAMAHA_DEVICE(0x101e, "PSR-K1"),
135 YAMAHA_DEVICE(0x101f, "EZ-J24"),
136 YAMAHA_DEVICE(0x1020, "EZ-250i"),
137 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
138 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
139 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
140 YAMAHA_DEVICE(0x1024, "CVP-301"),
141 YAMAHA_DEVICE(0x1025, "CVP-303"),
142 YAMAHA_DEVICE(0x1026, "CVP-305"),
143 YAMAHA_DEVICE(0x1027, "CVP-307"),
144 YAMAHA_DEVICE(0x1028, "CVP-309"),
145 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
146 YAMAHA_DEVICE(0x102a, "PSR-1500"),
147 YAMAHA_DEVICE(0x102b, "PSR-3000"),
148 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
149 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
150 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
151 YAMAHA_DEVICE(0x1032, "DGX-305"),
152 YAMAHA_DEVICE(0x1033, "DGX-505"),
153 YAMAHA_DEVICE(0x1034, NULL),
154 YAMAHA_DEVICE(0x1035, NULL),
155 YAMAHA_DEVICE(0x1036, NULL),
156 YAMAHA_DEVICE(0x1037, NULL),
157 YAMAHA_DEVICE(0x1038, NULL),
158 YAMAHA_DEVICE(0x1039, NULL),
159 YAMAHA_DEVICE(0x103a, NULL),
160 YAMAHA_DEVICE(0x103b, NULL),
161 YAMAHA_DEVICE(0x103c, NULL),
162 YAMAHA_DEVICE(0x103d, NULL),
163 YAMAHA_DEVICE(0x103e, NULL),
164 YAMAHA_DEVICE(0x103f, NULL),
165 YAMAHA_DEVICE(0x1040, NULL),
166 YAMAHA_DEVICE(0x1041, NULL),
167 YAMAHA_DEVICE(0x1042, NULL),
168 YAMAHA_DEVICE(0x1043, NULL),
169 YAMAHA_DEVICE(0x1044, NULL),
170 YAMAHA_DEVICE(0x1045, NULL),
171 YAMAHA_DEVICE(0x2000, "DGP-7"),
172 YAMAHA_DEVICE(0x2001, "DGP-5"),
173 YAMAHA_DEVICE(0x2002, NULL),
174 YAMAHA_DEVICE(0x5000, "CS1D"),
175 YAMAHA_DEVICE(0x5001, "DSP1D"),
176 YAMAHA_DEVICE(0x5002, "DME32"),
177 YAMAHA_DEVICE(0x5003, "DM2000"),
178 YAMAHA_DEVICE(0x5004, "02R96"),
179 YAMAHA_DEVICE(0x5005, "ACU16-C"),
180 YAMAHA_DEVICE(0x5006, "NHB32-C"),
181 YAMAHA_DEVICE(0x5007, "DM1000"),
182 YAMAHA_DEVICE(0x5008, "01V96"),
183 YAMAHA_DEVICE(0x5009, "SPX2000"),
184 YAMAHA_DEVICE(0x500a, "PM5D"),
185 YAMAHA_DEVICE(0x500b, "DME64N"),
186 YAMAHA_DEVICE(0x500c, "DME24N"),
187 YAMAHA_DEVICE(0x500d, NULL),
188 YAMAHA_DEVICE(0x500e, NULL),
189 YAMAHA_DEVICE(0x500f, NULL),
190 YAMAHA_DEVICE(0x7000, "DTX"),
191 YAMAHA_DEVICE(0x7010, "UB99"),
193 #undef YAMAHA_INTERFACE
196 * Roland/RolandED/Edirol/BOSS devices
199 USB_DEVICE(0x0582, 0x0000),
200 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
201 .vendor_name = "Roland",
202 .product_name = "UA-100",
203 .ifnum = QUIRK_ANY_INTERFACE,
204 .type = QUIRK_COMPOSITE,
205 .data = (const struct snd_usb_audio_quirk[]) {
208 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
209 .data = & (const struct audioformat) {
210 .format = SNDRV_PCM_FORMAT_S16_LE,
218 .rates = SNDRV_PCM_RATE_CONTINUOUS,
225 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
226 .data = & (const struct audioformat) {
227 .format = SNDRV_PCM_FORMAT_S16_LE,
232 .attributes = EP_CS_ATTR_FILL_MAX,
235 .rates = SNDRV_PCM_RATE_CONTINUOUS,
242 .type = QUIRK_MIDI_FIXED_ENDPOINT,
243 .data = & (const struct snd_usb_midi_endpoint_info) {
244 .out_cables = 0x0007,
255 USB_DEVICE(0x0582, 0x0002),
256 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
257 .vendor_name = "EDIROL",
258 .product_name = "UM-4",
259 .ifnum = QUIRK_ANY_INTERFACE,
260 .type = QUIRK_COMPOSITE,
261 .data = (const struct snd_usb_audio_quirk[]) {
264 .type = QUIRK_IGNORE_INTERFACE
268 .type = QUIRK_IGNORE_INTERFACE
272 .type = QUIRK_MIDI_FIXED_ENDPOINT,
273 .data = & (const struct snd_usb_midi_endpoint_info) {
274 .out_cables = 0x000f,
285 USB_DEVICE(0x0582, 0x0003),
286 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
287 .vendor_name = "Roland",
288 .product_name = "SC-8850",
289 .ifnum = QUIRK_ANY_INTERFACE,
290 .type = QUIRK_COMPOSITE,
291 .data = (const struct snd_usb_audio_quirk[]) {
294 .type = QUIRK_IGNORE_INTERFACE
298 .type = QUIRK_IGNORE_INTERFACE
302 .type = QUIRK_MIDI_FIXED_ENDPOINT,
303 .data = & (const struct snd_usb_midi_endpoint_info) {
304 .out_cables = 0x003f,
315 USB_DEVICE(0x0582, 0x0004),
316 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
317 .vendor_name = "Roland",
318 .product_name = "U-8",
319 .ifnum = QUIRK_ANY_INTERFACE,
320 .type = QUIRK_COMPOSITE,
321 .data = (const struct snd_usb_audio_quirk[]) {
324 .type = QUIRK_IGNORE_INTERFACE
328 .type = QUIRK_IGNORE_INTERFACE
332 .type = QUIRK_MIDI_FIXED_ENDPOINT,
333 .data = & (const struct snd_usb_midi_endpoint_info) {
334 .out_cables = 0x0005,
345 /* Has ID 0x0099 when not in "Advanced Driver" mode.
346 * The UM-2EX has only one input, but we cannot detect this. */
347 USB_DEVICE(0x0582, 0x0005),
348 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
349 .vendor_name = "EDIROL",
350 .product_name = "UM-2",
351 .ifnum = QUIRK_ANY_INTERFACE,
352 .type = QUIRK_COMPOSITE,
353 .data = (const struct snd_usb_audio_quirk[]) {
356 .type = QUIRK_IGNORE_INTERFACE
360 .type = QUIRK_IGNORE_INTERFACE
364 .type = QUIRK_MIDI_FIXED_ENDPOINT,
365 .data = & (const struct snd_usb_midi_endpoint_info) {
366 .out_cables = 0x0003,
377 USB_DEVICE(0x0582, 0x0007),
378 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
379 .vendor_name = "Roland",
380 .product_name = "SC-8820",
381 .ifnum = QUIRK_ANY_INTERFACE,
382 .type = QUIRK_COMPOSITE,
383 .data = (const struct snd_usb_audio_quirk[]) {
386 .type = QUIRK_IGNORE_INTERFACE
390 .type = QUIRK_IGNORE_INTERFACE
394 .type = QUIRK_MIDI_FIXED_ENDPOINT,
395 .data = & (const struct snd_usb_midi_endpoint_info) {
396 .out_cables = 0x0013,
407 USB_DEVICE(0x0582, 0x0008),
408 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
409 .vendor_name = "Roland",
410 .product_name = "PC-300",
411 .ifnum = QUIRK_ANY_INTERFACE,
412 .type = QUIRK_COMPOSITE,
413 .data = (const struct snd_usb_audio_quirk[]) {
416 .type = QUIRK_IGNORE_INTERFACE
420 .type = QUIRK_IGNORE_INTERFACE
424 .type = QUIRK_MIDI_FIXED_ENDPOINT,
425 .data = & (const struct snd_usb_midi_endpoint_info) {
426 .out_cables = 0x0001,
437 /* has ID 0x009d when not in "Advanced Driver" mode */
438 USB_DEVICE(0x0582, 0x0009),
439 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
440 .vendor_name = "EDIROL",
441 .product_name = "UM-1",
442 .ifnum = QUIRK_ANY_INTERFACE,
443 .type = QUIRK_COMPOSITE,
444 .data = (const struct snd_usb_audio_quirk[]) {
447 .type = QUIRK_IGNORE_INTERFACE
451 .type = QUIRK_IGNORE_INTERFACE
455 .type = QUIRK_MIDI_FIXED_ENDPOINT,
456 .data = & (const struct snd_usb_midi_endpoint_info) {
457 .out_cables = 0x0001,
468 USB_DEVICE(0x0582, 0x000b),
469 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
470 .vendor_name = "Roland",
471 .product_name = "SK-500",
472 .ifnum = QUIRK_ANY_INTERFACE,
473 .type = QUIRK_COMPOSITE,
474 .data = (const struct snd_usb_audio_quirk[]) {
477 .type = QUIRK_IGNORE_INTERFACE
481 .type = QUIRK_IGNORE_INTERFACE
485 .type = QUIRK_MIDI_FIXED_ENDPOINT,
486 .data = & (const struct snd_usb_midi_endpoint_info) {
487 .out_cables = 0x0013,
498 /* thanks to Emiliano Grilli <emillo@libero.it>
499 * for helping researching this data */
500 USB_DEVICE(0x0582, 0x000c),
501 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
502 .vendor_name = "Roland",
503 .product_name = "SC-D70",
504 .ifnum = QUIRK_ANY_INTERFACE,
505 .type = QUIRK_COMPOSITE,
506 .data = (const struct snd_usb_audio_quirk[]) {
509 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
510 .data = & (const struct audioformat) {
511 .format = SNDRV_PCM_FORMAT_S24_3LE,
519 .rates = SNDRV_PCM_RATE_CONTINUOUS,
526 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
527 .data = & (const struct audioformat) {
528 .format = SNDRV_PCM_FORMAT_S24_3LE,
536 .rates = SNDRV_PCM_RATE_CONTINUOUS,
543 .type = QUIRK_MIDI_FIXED_ENDPOINT,
544 .data = & (const struct snd_usb_midi_endpoint_info) {
545 .out_cables = 0x0007,
556 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
557 * If the advanced mode switch at the back of the unit is off, the
558 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
559 * but offers only 16-bit PCM.
560 * In advanced mode, the UA-5 will output S24_3LE samples (two
561 * channels) at the rate indicated on the front switch, including
562 * the 96kHz sample rate.
564 USB_DEVICE(0x0582, 0x0010),
565 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
566 .vendor_name = "EDIROL",
567 .product_name = "UA-5",
568 .ifnum = QUIRK_ANY_INTERFACE,
569 .type = QUIRK_COMPOSITE,
570 .data = (const struct snd_usb_audio_quirk[]) {
573 .type = QUIRK_AUDIO_STANDARD_INTERFACE
577 .type = QUIRK_AUDIO_STANDARD_INTERFACE
586 /* has ID 0x0013 when not in "Advanced Driver" mode */
587 USB_DEVICE(0x0582, 0x0012),
588 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
589 .vendor_name = "Roland",
590 .product_name = "XV-5050",
592 .type = QUIRK_MIDI_FIXED_ENDPOINT,
593 .data = & (const struct snd_usb_midi_endpoint_info) {
594 .out_cables = 0x0001,
600 /* has ID 0x0015 when not in "Advanced Driver" mode */
601 USB_DEVICE(0x0582, 0x0014),
602 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
603 .vendor_name = "EDIROL",
604 .product_name = "UM-880",
606 .type = QUIRK_MIDI_FIXED_ENDPOINT,
607 .data = & (const struct snd_usb_midi_endpoint_info) {
608 .out_cables = 0x01ff,
614 /* has ID 0x0017 when not in "Advanced Driver" mode */
615 USB_DEVICE(0x0582, 0x0016),
616 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
617 .vendor_name = "EDIROL",
618 .product_name = "SD-90",
619 .ifnum = QUIRK_ANY_INTERFACE,
620 .type = QUIRK_COMPOSITE,
621 .data = (const struct snd_usb_audio_quirk[]) {
624 .type = QUIRK_IGNORE_INTERFACE
628 .type = QUIRK_IGNORE_INTERFACE
632 .type = QUIRK_MIDI_FIXED_ENDPOINT,
633 .data = & (const struct snd_usb_midi_endpoint_info) {
634 .out_cables = 0x000f,
645 /* has ID 0x001c when not in "Advanced Driver" mode */
646 USB_DEVICE(0x0582, 0x001b),
647 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
648 .vendor_name = "Roland",
649 .product_name = "MMP-2",
650 .ifnum = QUIRK_ANY_INTERFACE,
651 .type = QUIRK_COMPOSITE,
652 .data = (const struct snd_usb_audio_quirk[]) {
655 .type = QUIRK_IGNORE_INTERFACE
659 .type = QUIRK_IGNORE_INTERFACE
663 .type = QUIRK_MIDI_FIXED_ENDPOINT,
664 .data = & (const struct snd_usb_midi_endpoint_info) {
665 .out_cables = 0x0001,
676 /* has ID 0x001e when not in "Advanced Driver" mode */
677 USB_DEVICE(0x0582, 0x001d),
678 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
679 .vendor_name = "Roland",
680 .product_name = "V-SYNTH",
682 .type = QUIRK_MIDI_FIXED_ENDPOINT,
683 .data = & (const struct snd_usb_midi_endpoint_info) {
684 .out_cables = 0x0001,
690 /* has ID 0x0024 when not in "Advanced Driver" mode */
691 USB_DEVICE(0x0582, 0x0023),
692 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
693 .vendor_name = "EDIROL",
694 .product_name = "UM-550",
696 .type = QUIRK_MIDI_FIXED_ENDPOINT,
697 .data = & (const struct snd_usb_midi_endpoint_info) {
698 .out_cables = 0x003f,
705 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
706 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
709 USB_DEVICE(0x0582, 0x0025),
710 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
711 .vendor_name = "EDIROL",
712 .product_name = "UA-20",
713 .ifnum = QUIRK_ANY_INTERFACE,
714 .type = QUIRK_COMPOSITE,
715 .data = (const struct snd_usb_audio_quirk[]) {
718 .type = QUIRK_IGNORE_INTERFACE
722 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
723 .data = & (const struct audioformat) {
724 .format = SNDRV_PCM_FORMAT_S24_3LE,
732 .rates = SNDRV_PCM_RATE_CONTINUOUS,
739 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
740 .data = & (const struct audioformat) {
741 .format = SNDRV_PCM_FORMAT_S24_3LE,
749 .rates = SNDRV_PCM_RATE_CONTINUOUS,
756 .type = QUIRK_MIDI_FIXED_ENDPOINT,
757 .data = & (const struct snd_usb_midi_endpoint_info) {
758 .out_cables = 0x0001,
769 /* has ID 0x0028 when not in "Advanced Driver" mode */
770 USB_DEVICE(0x0582, 0x0027),
771 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
772 .vendor_name = "EDIROL",
773 .product_name = "SD-20",
775 .type = QUIRK_MIDI_FIXED_ENDPOINT,
776 .data = & (const struct snd_usb_midi_endpoint_info) {
777 .out_cables = 0x0003,
783 /* has ID 0x002a when not in "Advanced Driver" mode */
784 USB_DEVICE(0x0582, 0x0029),
785 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
786 .vendor_name = "EDIROL",
787 .product_name = "SD-80",
789 .type = QUIRK_MIDI_FIXED_ENDPOINT,
790 .data = & (const struct snd_usb_midi_endpoint_info) {
791 .out_cables = 0x000f,
797 * This quirk is for the "Advanced" modes of the Edirol UA-700.
798 * If the sample format switch is not in an advanced setting, the
799 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
800 * but offers only 16-bit PCM and no MIDI.
802 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
803 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
804 .vendor_name = "EDIROL",
805 .product_name = "UA-700",
806 .ifnum = QUIRK_ANY_INTERFACE,
807 .type = QUIRK_COMPOSITE,
808 .data = (const struct snd_usb_audio_quirk[]) {
811 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
815 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
819 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
828 /* has ID 0x002e when not in "Advanced Driver" mode */
829 USB_DEVICE(0x0582, 0x002d),
830 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
831 .vendor_name = "Roland",
832 .product_name = "XV-2020",
834 .type = QUIRK_MIDI_FIXED_ENDPOINT,
835 .data = & (const struct snd_usb_midi_endpoint_info) {
836 .out_cables = 0x0001,
842 /* has ID 0x0030 when not in "Advanced Driver" mode */
843 USB_DEVICE(0x0582, 0x002f),
844 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
845 .vendor_name = "Roland",
846 .product_name = "VariOS",
848 .type = QUIRK_MIDI_FIXED_ENDPOINT,
849 .data = & (const struct snd_usb_midi_endpoint_info) {
850 .out_cables = 0x0007,
856 /* has ID 0x0034 when not in "Advanced Driver" mode */
857 USB_DEVICE(0x0582, 0x0033),
858 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
859 .vendor_name = "EDIROL",
860 .product_name = "PCR",
862 .type = QUIRK_MIDI_FIXED_ENDPOINT,
863 .data = & (const struct snd_usb_midi_endpoint_info) {
864 .out_cables = 0x0003,
869 /* TODO: add Roland M-1000 support */
872 * Has ID 0x0038 when not in "Advanced Driver" mode;
873 * later revisions use IDs 0x0054 and 0x00a2.
875 USB_DEVICE(0x0582, 0x0037),
876 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
877 .vendor_name = "Roland",
878 .product_name = "Digital Piano",
880 .type = QUIRK_MIDI_FIXED_ENDPOINT,
881 .data = & (const struct snd_usb_midi_endpoint_info) {
882 .out_cables = 0x0001,
889 * This quirk is for the "Advanced Driver" mode. If off, the GS-10
890 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
893 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
894 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
895 .vendor_name = "BOSS",
896 .product_name = "GS-10",
897 .ifnum = QUIRK_ANY_INTERFACE,
898 .type = QUIRK_COMPOSITE,
899 .data = & (const struct snd_usb_audio_quirk[]) {
902 .type = QUIRK_AUDIO_STANDARD_INTERFACE
906 .type = QUIRK_AUDIO_STANDARD_INTERFACE
910 .type = QUIRK_MIDI_STANDARD_INTERFACE
919 /* has ID 0x0041 when not in "Advanced Driver" mode */
920 USB_DEVICE(0x0582, 0x0040),
921 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
922 .vendor_name = "Roland",
923 .product_name = "GI-20",
925 .type = QUIRK_MIDI_FIXED_ENDPOINT,
926 .data = & (const struct snd_usb_midi_endpoint_info) {
927 .out_cables = 0x0001,
933 /* has ID 0x0043 when not in "Advanced Driver" mode */
934 USB_DEVICE(0x0582, 0x0042),
935 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
936 .vendor_name = "Roland",
937 .product_name = "RS-70",
939 .type = QUIRK_MIDI_FIXED_ENDPOINT,
940 .data = & (const struct snd_usb_midi_endpoint_info) {
941 .out_cables = 0x0001,
947 USB_DEVICE(0x0582, 0x0044),
948 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
949 .vendor_name = "Roland",
950 .product_name = "UA-1000",
951 .ifnum = QUIRK_ANY_INTERFACE,
952 .type = QUIRK_COMPOSITE,
953 .data = (const struct snd_usb_audio_quirk[]) {
956 .type = QUIRK_AUDIO_EDIROL_UA1000
960 .type = QUIRK_AUDIO_EDIROL_UA1000
964 .type = QUIRK_MIDI_FIXED_ENDPOINT,
965 .data = & (const struct snd_usb_midi_endpoint_info) {
966 .out_cables = 0x0003,
977 /* has ID 0x004a when not in "Advanced Driver" mode */
978 USB_DEVICE(0x0582, 0x0048),
979 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
980 .vendor_name = "EDIROL",
981 .product_name = "UR-80",
983 .type = QUIRK_MIDI_FIXED_ENDPOINT,
984 .data = & (const struct snd_usb_midi_endpoint_info) {
985 .out_cables = 0x0003,
990 /* TODO: add Edirol M-100FX support */
992 /* has ID 0x004e when not in "Advanced Driver" mode */
993 USB_DEVICE(0x0582, 0x004c),
994 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
995 .vendor_name = "EDIROL",
996 .product_name = "PCR-A",
997 .ifnum = QUIRK_ANY_INTERFACE,
998 .type = QUIRK_COMPOSITE,
999 .data = (const struct snd_usb_audio_quirk[]) {
1002 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1006 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1015 /* has ID 0x004f when not in "Advanced Driver" mode */
1016 USB_DEVICE(0x0582, 0x004d),
1017 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1018 .vendor_name = "EDIROL",
1019 .product_name = "PCR-A",
1021 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1022 .data = & (const struct snd_usb_midi_endpoint_info) {
1023 .out_cables = 0x0003,
1030 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1031 * is standard compliant, but has only 16-bit PCM.
1033 USB_DEVICE(0x0582, 0x0050),
1034 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1035 .vendor_name = "EDIROL",
1036 .product_name = "UA-3FX",
1037 .ifnum = QUIRK_ANY_INTERFACE,
1038 .type = QUIRK_COMPOSITE,
1039 .data = (const struct snd_usb_audio_quirk[]) {
1042 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1046 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1055 USB_DEVICE(0x0582, 0x0052),
1056 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1057 .vendor_name = "EDIROL",
1058 .product_name = "UM-1SX",
1060 .type = QUIRK_MIDI_STANDARD_INTERFACE
1063 /* TODO: add Roland EXR support */
1065 /* has ID 0x0067 when not in "Advanced Driver" mode */
1066 USB_DEVICE(0x0582, 0x0065),
1067 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1068 .vendor_name = "EDIROL",
1069 .product_name = "PCR-1",
1071 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1072 .data = & (const struct snd_usb_midi_endpoint_info) {
1073 .out_cables = 0x0001,
1079 /* has ID 0x006b when not in "Advanced Driver" mode */
1080 USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1081 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1082 .vendor_name = "Roland",
1083 .product_name = "SP-606",
1085 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1086 .data = & (const struct snd_usb_midi_endpoint_info) {
1087 .out_cables = 0x0001,
1093 /* has ID 0x006e when not in "Advanced Driver" mode */
1094 USB_DEVICE(0x0582, 0x006d),
1095 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1096 .vendor_name = "Roland",
1097 .product_name = "FANTOM-X",
1099 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1100 .data = & (const struct snd_usb_midi_endpoint_info) {
1101 .out_cables = 0x0001,
1107 USB_DEVICE(0x582, 0x00a6),
1108 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1109 .vendor_name = "Roland",
1110 .product_name = "Juno-G",
1112 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1113 .data = & (const struct snd_usb_midi_endpoint_info) {
1114 .out_cables = 0x0001,
1120 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1121 * If the switch is not in an advanced setting, the UA-25 has
1122 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1123 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1125 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1126 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1127 .vendor_name = "EDIROL",
1128 .product_name = "UA-25",
1129 .ifnum = QUIRK_ANY_INTERFACE,
1130 .type = QUIRK_COMPOSITE,
1131 .data = (const struct snd_usb_audio_quirk[]) {
1134 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1138 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1142 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1151 /* has ID 0x0076 when not in "Advanced Driver" mode */
1152 USB_DEVICE(0x0582, 0x0075),
1153 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1154 .vendor_name = "BOSS",
1155 .product_name = "DR-880",
1157 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1158 .data = & (const struct snd_usb_midi_endpoint_info) {
1159 .out_cables = 0x0001,
1165 /* has ID 0x007b when not in "Advanced Driver" mode */
1166 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1167 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1168 .vendor_name = "Roland",
1169 /* "RD" or "RD-700SX"? */
1171 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1172 .data = & (const struct snd_usb_midi_endpoint_info) {
1173 .out_cables = 0x0003,
1178 /* Roland UA-101 in High-Speed Mode only */
1180 USB_DEVICE(0x0582, 0x007d),
1181 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1182 .vendor_name = "Roland",
1183 .product_name = "UA-101",
1184 .ifnum = QUIRK_ANY_INTERFACE,
1185 .type = QUIRK_COMPOSITE,
1186 .data = (const struct snd_usb_audio_quirk[]) {
1189 .type = QUIRK_AUDIO_EDIROL_UA101
1193 .type = QUIRK_AUDIO_EDIROL_UA101
1197 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1198 .data = & (const struct snd_usb_midi_endpoint_info) {
1199 .out_cables = 0x0001,
1210 /* has ID 0x0081 when not in "Advanced Driver" mode */
1211 USB_DEVICE(0x0582, 0x0080),
1212 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1213 .vendor_name = "Roland",
1214 .product_name = "G-70",
1216 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1217 .data = & (const struct snd_usb_midi_endpoint_info) {
1218 .out_cables = 0x0001,
1223 /* TODO: add Roland V-SYNTH XT support */
1224 /* TODO: add BOSS GT-PRO support */
1226 /* has ID 0x008c when not in "Advanced Driver" mode */
1227 USB_DEVICE(0x0582, 0x008b),
1228 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1229 .vendor_name = "EDIROL",
1230 .product_name = "PC-50",
1232 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1233 .data = & (const struct snd_usb_midi_endpoint_info) {
1234 .out_cables = 0x0001,
1239 /* TODO: add Edirol PC-80 support */
1240 /* TODO: add Edirol UA-1EX support */
1242 USB_DEVICE(0x0582, 0x009a),
1243 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1244 .vendor_name = "EDIROL",
1245 .product_name = "UM-3EX",
1247 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1248 .data = & (const struct snd_usb_midi_endpoint_info) {
1249 .out_cables = 0x000f,
1254 /* TODO: add Edirol MD-P1 support */
1257 USB_DEVICE(0x0582, 0x00ad),
1258 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1259 .vendor_name = "Roland",
1260 .product_name = "SH-201",
1261 .ifnum = QUIRK_ANY_INTERFACE,
1262 .type = QUIRK_COMPOSITE,
1263 .data = (const struct snd_usb_audio_quirk[]) {
1266 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1270 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1274 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1275 .data = & (const struct snd_usb_midi_endpoint_info) {
1276 .out_cables = 0x0001,
1287 /* Guillemot devices */
1290 * This is for the "Windows Edition" where the external MIDI ports are
1291 * the only MIDI ports; the control data is reported through HID
1292 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard
1293 * compliant USB MIDI ports for external MIDI and controls.
1295 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1296 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1297 .vendor_name = "Hercules",
1298 .product_name = "DJ Console (WE)",
1300 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1301 .data = & (const struct snd_usb_midi_endpoint_info) {
1302 .out_cables = 0x0001,
1308 /* Midiman/M-Audio devices */
1310 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1311 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1312 .vendor_name = "M-Audio",
1313 .product_name = "MidiSport 2x2",
1314 .ifnum = QUIRK_ANY_INTERFACE,
1315 .type = QUIRK_MIDI_MIDIMAN,
1316 .data = & (const struct snd_usb_midi_endpoint_info) {
1317 .out_cables = 0x0003,
1323 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1324 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1325 .vendor_name = "M-Audio",
1326 .product_name = "MidiSport 1x1",
1327 .ifnum = QUIRK_ANY_INTERFACE,
1328 .type = QUIRK_MIDI_MIDIMAN,
1329 .data = & (const struct snd_usb_midi_endpoint_info) {
1330 .out_cables = 0x0001,
1336 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1337 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1338 .vendor_name = "M-Audio",
1339 .product_name = "Keystation",
1340 .ifnum = QUIRK_ANY_INTERFACE,
1341 .type = QUIRK_MIDI_MIDIMAN,
1342 .data = & (const struct snd_usb_midi_endpoint_info) {
1343 .out_cables = 0x0001,
1349 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1350 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1351 .vendor_name = "M-Audio",
1352 .product_name = "MidiSport 4x4",
1353 .ifnum = QUIRK_ANY_INTERFACE,
1354 .type = QUIRK_MIDI_MIDIMAN,
1355 .data = & (const struct snd_usb_midi_endpoint_info) {
1356 .out_cables = 0x000f,
1363 * For hardware revision 1.05; in the later revisions (1.10 and
1364 * 1.21), 0x1031 is the ID for the device without firmware.
1365 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1367 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1368 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1369 .vendor_name = "M-Audio",
1370 .product_name = "MidiSport 8x8",
1371 .ifnum = QUIRK_ANY_INTERFACE,
1372 .type = QUIRK_MIDI_MIDIMAN,
1373 .data = & (const struct snd_usb_midi_endpoint_info) {
1374 .out_cables = 0x01ff,
1380 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1381 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1382 .vendor_name = "M-Audio",
1383 .product_name = "MidiSport 8x8",
1384 .ifnum = QUIRK_ANY_INTERFACE,
1385 .type = QUIRK_MIDI_MIDIMAN,
1386 .data = & (const struct snd_usb_midi_endpoint_info) {
1387 .out_cables = 0x01ff,
1393 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1394 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1395 .vendor_name = "M-Audio",
1396 .product_name = "MidiSport 2x4",
1397 .ifnum = QUIRK_ANY_INTERFACE,
1398 .type = QUIRK_MIDI_MIDIMAN,
1399 .data = & (const struct snd_usb_midi_endpoint_info) {
1400 .out_cables = 0x000f,
1406 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1407 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1408 .vendor_name = "M-Audio",
1409 .product_name = "Quattro",
1410 .ifnum = QUIRK_ANY_INTERFACE,
1411 .type = QUIRK_COMPOSITE,
1412 .data = & (const struct snd_usb_audio_quirk[]) {
1414 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1415 * and share endpoints with the other interfaces.
1416 * Ignore them. The other interfaces can do 24 bits,
1417 * but captured samples are big-endian (see usbaudio.c).
1421 .type = QUIRK_IGNORE_INTERFACE
1425 .type = QUIRK_IGNORE_INTERFACE
1429 .type = QUIRK_IGNORE_INTERFACE
1433 .type = QUIRK_IGNORE_INTERFACE
1437 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1441 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1445 .type = QUIRK_IGNORE_INTERFACE
1449 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1453 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1457 .type = QUIRK_MIDI_MIDIMAN,
1458 .data = & (const struct snd_usb_midi_endpoint_info) {
1459 .out_cables = 0x0001,
1470 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1471 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1472 .vendor_name = "M-Audio",
1473 .product_name = "AudioPhile",
1475 .type = QUIRK_MIDI_MIDIMAN,
1476 .data = & (const struct snd_usb_midi_endpoint_info) {
1477 .out_cables = 0x0001,
1483 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1484 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1485 .vendor_name = "M-Audio",
1486 .product_name = "Ozone",
1488 .type = QUIRK_MIDI_MIDIMAN,
1489 .data = & (const struct snd_usb_midi_endpoint_info) {
1490 .out_cables = 0x0001,
1496 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1497 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1498 .vendor_name = "M-Audio",
1499 .product_name = "OmniStudio",
1500 .ifnum = QUIRK_ANY_INTERFACE,
1501 .type = QUIRK_COMPOSITE,
1502 .data = & (const struct snd_usb_audio_quirk[]) {
1505 .type = QUIRK_IGNORE_INTERFACE
1509 .type = QUIRK_IGNORE_INTERFACE
1513 .type = QUIRK_IGNORE_INTERFACE
1517 .type = QUIRK_IGNORE_INTERFACE
1521 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1525 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1529 .type = QUIRK_IGNORE_INTERFACE
1533 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1537 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1541 .type = QUIRK_MIDI_MIDIMAN,
1542 .data = & (const struct snd_usb_midi_endpoint_info) {
1543 .out_cables = 0x0001,
1556 USB_DEVICE(0x07cf, 0x6801),
1557 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1558 .vendor_name = "Casio",
1559 .product_name = "PL-40R",
1561 .type = QUIRK_MIDI_YAMAHA
1565 /* this ID is used by several devices without a product ID */
1566 USB_DEVICE(0x07cf, 0x6802),
1567 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1568 .vendor_name = "Casio",
1569 .product_name = "Keyboard",
1571 .type = QUIRK_MIDI_YAMAHA
1575 /* Mark of the Unicorn devices */
1577 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1578 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1579 USB_DEVICE_ID_MATCH_PRODUCT |
1580 USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
1582 .idProduct = 0x0001,
1583 .bDeviceSubClass = 2,
1584 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1585 .vendor_name = "MOTU",
1586 .product_name = "Fastlane",
1587 .ifnum = QUIRK_ANY_INTERFACE,
1588 .type = QUIRK_COMPOSITE,
1589 .data = & (const struct snd_usb_audio_quirk[]) {
1592 .type = QUIRK_MIDI_RAW
1596 .type = QUIRK_IGNORE_INTERFACE
1606 /* Creative Sound Blaster MP3+ */
1607 USB_DEVICE(0x041e, 0x3010),
1608 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1609 .vendor_name = "Creative Labs",
1610 .product_name = "Sound Blaster MP3+",
1611 .ifnum = QUIRK_NO_INTERFACE
1616 /* Emagic devices */
1618 USB_DEVICE(0x086a, 0x0001),
1619 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1620 .vendor_name = "Emagic",
1621 /* .product_name = "Unitor8", */
1623 .type = QUIRK_MIDI_EMAGIC,
1624 .data = & (const struct snd_usb_midi_endpoint_info) {
1625 .out_cables = 0x80ff,
1631 USB_DEVICE(0x086a, 0x0002),
1632 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1633 .vendor_name = "Emagic",
1634 /* .product_name = "AMT8", */
1636 .type = QUIRK_MIDI_EMAGIC,
1637 .data = & (const struct snd_usb_midi_endpoint_info) {
1638 .out_cables = 0x80ff,
1644 USB_DEVICE(0x086a, 0x0003),
1645 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1646 .vendor_name = "Emagic",
1647 /* .product_name = "MT4", */
1649 .type = QUIRK_MIDI_EMAGIC,
1650 .data = & (const struct snd_usb_midi_endpoint_info) {
1651 .out_cables = 0x800f,
1657 /* TerraTec devices */
1659 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
1660 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1661 .vendor_name = "TerraTec",
1662 .product_name = "PHASE 26",
1664 .type = QUIRK_MIDI_STANDARD_INTERFACE
1668 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1669 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1670 .vendor_name = "TerraTec",
1671 .product_name = "PHASE 26",
1673 .type = QUIRK_MIDI_STANDARD_INTERFACE
1677 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
1678 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1679 .vendor_name = "TerraTec",
1680 .product_name = "PHASE 26",
1682 .type = QUIRK_MIDI_STANDARD_INTERFACE
1686 USB_DEVICE(0x0ccd, 0x0035),
1687 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1688 .vendor_name = "Miditech",
1689 .product_name = "Play'n Roll",
1691 .type = QUIRK_MIDI_CME
1695 /* Novation EMS devices */
1697 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
1698 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1699 .vendor_name = "Novation",
1700 .product_name = "ReMOTE Audio/XStation",
1702 .type = QUIRK_MIDI_NOVATION
1706 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
1707 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1708 .vendor_name = "Novation",
1709 .product_name = "Speedio",
1711 .type = QUIRK_MIDI_NOVATION
1715 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
1716 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1717 .vendor_name = "Novation",
1718 .product_name = "ReMOTE25",
1720 .type = QUIRK_MIDI_NOVATION
1724 /* Miditech devices */
1726 USB_DEVICE(0x4752, 0x0011),
1727 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1728 .vendor_name = "Miditech",
1729 .product_name = "Midistart-2",
1731 .type = QUIRK_MIDI_CME
1735 /* Central Music devices */
1737 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
1738 USB_DEVICE(0x7104, 0x2202),
1739 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1741 .type = QUIRK_MIDI_CME
1747 * Some USB MIDI devices don't have an audio control interface,
1748 * so we have to grab MIDI streaming interfaces here.
1750 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
1751 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
1752 .bInterfaceClass = USB_CLASS_AUDIO,
1753 .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
1754 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1755 .ifnum = QUIRK_ANY_INTERFACE,
1756 .type = QUIRK_MIDI_STANDARD_INTERFACE
1760 #undef USB_DEVICE_VENDOR_SPEC