1 /* SPDX-License-Identifier: GPL-2.0-or-later */
3 * ALSA USB Audio Driver
5 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>,
6 * Clemens Ladisch <clemens@ladisch.de>
10 * The contents of this file are part of the driver's id_table.
12 * In a perfect world, this file would be empty.
16 * Use this for devices where other interfaces are standard compliant,
17 * to prevent the quirk being applied to those interfaces. (To work with
18 * hotplugging, bDeviceClass must be set to USB_CLASS_PER_INTERFACE.)
20 #define USB_DEVICE_VENDOR_SPEC(vend, prod) \
21 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | \
22 USB_DEVICE_ID_MATCH_PRODUCT | \
23 USB_DEVICE_ID_MATCH_INT_CLASS, \
26 .bInterfaceClass = USB_CLASS_VENDOR_SPEC
28 /* A standard entry matching with vid/pid and the audio class/subclass */
29 #define USB_AUDIO_DEVICE(vend, prod) \
30 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
31 USB_DEVICE_ID_MATCH_INT_CLASS | \
32 USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
35 .bInterfaceClass = USB_CLASS_AUDIO, \
36 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
40 USB_DEVICE(0x0403, 0xb8d8),
41 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
42 /* .vendor_name = "STARR LABS", */
43 /* .product_name = "Starr Labs MIDI USB device", */
45 .type = QUIRK_MIDI_FTDI
51 USB_DEVICE(0x041e, 0x0005),
52 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
54 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
55 .data = &(const struct audioformat) {
56 .formats = SNDRV_PCM_FMTBIT_S16_LE,
62 .ep_attr = USB_ENDPOINT_XFER_ISOC,
64 .rates = SNDRV_PCM_RATE_CONTINUOUS,
72 { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f02) },
74 { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f04) },
75 /* E-Mu Tracker Pre */
76 { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f0a) },
78 { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f19) },
79 /* Ktmicro Usb_audio device */
80 { USB_DEVICE_VENDOR_SPEC(0x31b2, 0x0011) },
83 * Creative Technology, Ltd Live! Cam Sync HD [VF0770]
84 * The device advertises 8 formats, but only a rate of 48kHz is honored by the
85 * hardware and 24 bits give chopped audio, so only report the one working
89 USB_AUDIO_DEVICE(0x041e, 0x4095),
90 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
91 .ifnum = QUIRK_ANY_INTERFACE,
92 .type = QUIRK_COMPOSITE,
93 .data = &(const struct snd_usb_audio_quirk[]) {
96 .type = QUIRK_AUDIO_STANDARD_MIXER,
100 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
101 .data = &(const struct audioformat) {
102 .formats = SNDRV_PCM_FMTBIT_S16_LE,
110 .rates = SNDRV_PCM_RATE_48000,
114 .rate_table = (unsigned int[]) { 48000 },
126 * When not ignored, causes instability issues for some users, forcing them to
127 * skip the entire module.
130 USB_DEVICE(0x0424, 0xb832),
131 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
132 .vendor_name = "Standard Microsystems Corp.",
133 .product_name = "HP Wireless Audio",
134 .ifnum = QUIRK_ANY_INTERFACE,
135 .type = QUIRK_COMPOSITE,
136 .data = (const struct snd_usb_audio_quirk[]) {
140 .type = QUIRK_IGNORE_INTERFACE,
145 .type = QUIRK_IGNORE_INTERFACE,
150 .type = QUIRK_IGNORE_INTERFACE,
152 /* HID Device, .ifnum = 3 */
161 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
162 * class matches do not take effect without an explicit ID match.
164 { USB_AUDIO_DEVICE(0x046d, 0x0850) },
165 { USB_AUDIO_DEVICE(0x046d, 0x08ae) },
166 { USB_AUDIO_DEVICE(0x046d, 0x08c6) },
167 { USB_AUDIO_DEVICE(0x046d, 0x08f0) },
168 { USB_AUDIO_DEVICE(0x046d, 0x08f5) },
169 { USB_AUDIO_DEVICE(0x046d, 0x08f6) },
170 { USB_AUDIO_DEVICE(0x046d, 0x0990) },
176 #define YAMAHA_DEVICE(id, name) { \
177 USB_DEVICE(0x0499, id), \
178 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
179 .vendor_name = "Yamaha", \
180 .product_name = name, \
181 .ifnum = QUIRK_ANY_INTERFACE, \
182 .type = QUIRK_MIDI_YAMAHA \
185 #define YAMAHA_INTERFACE(id, intf, name) { \
186 USB_DEVICE_VENDOR_SPEC(0x0499, id), \
187 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
188 .vendor_name = "Yamaha", \
189 .product_name = name, \
191 .type = QUIRK_MIDI_YAMAHA \
194 YAMAHA_DEVICE(0x1000, "UX256"),
195 YAMAHA_DEVICE(0x1001, "MU1000"),
196 YAMAHA_DEVICE(0x1002, "MU2000"),
197 YAMAHA_DEVICE(0x1003, "MU500"),
198 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
199 YAMAHA_DEVICE(0x1005, "MOTIF6"),
200 YAMAHA_DEVICE(0x1006, "MOTIF7"),
201 YAMAHA_DEVICE(0x1007, "MOTIF8"),
202 YAMAHA_DEVICE(0x1008, "UX96"),
203 YAMAHA_DEVICE(0x1009, "UX16"),
204 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
205 YAMAHA_DEVICE(0x100c, "UC-MX"),
206 YAMAHA_DEVICE(0x100d, "UC-KX"),
207 YAMAHA_DEVICE(0x100e, "S08"),
208 YAMAHA_DEVICE(0x100f, "CLP-150"),
209 YAMAHA_DEVICE(0x1010, "CLP-170"),
210 YAMAHA_DEVICE(0x1011, "P-250"),
211 YAMAHA_DEVICE(0x1012, "TYROS"),
212 YAMAHA_DEVICE(0x1013, "PF-500"),
213 YAMAHA_DEVICE(0x1014, "S90"),
214 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
215 YAMAHA_DEVICE(0x1016, "MDP-5"),
216 YAMAHA_DEVICE(0x1017, "CVP-204"),
217 YAMAHA_DEVICE(0x1018, "CVP-206"),
218 YAMAHA_DEVICE(0x1019, "CVP-208"),
219 YAMAHA_DEVICE(0x101a, "CVP-210"),
220 YAMAHA_DEVICE(0x101b, "PSR-1100"),
221 YAMAHA_DEVICE(0x101c, "PSR-2100"),
222 YAMAHA_DEVICE(0x101d, "CLP-175"),
223 YAMAHA_DEVICE(0x101e, "PSR-K1"),
224 YAMAHA_DEVICE(0x101f, "EZ-J24"),
225 YAMAHA_DEVICE(0x1020, "EZ-250i"),
226 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
227 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
228 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
229 YAMAHA_DEVICE(0x1024, "CVP-301"),
230 YAMAHA_DEVICE(0x1025, "CVP-303"),
231 YAMAHA_DEVICE(0x1026, "CVP-305"),
232 YAMAHA_DEVICE(0x1027, "CVP-307"),
233 YAMAHA_DEVICE(0x1028, "CVP-309"),
234 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
235 YAMAHA_DEVICE(0x102a, "PSR-1500"),
236 YAMAHA_DEVICE(0x102b, "PSR-3000"),
237 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
238 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
239 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
240 YAMAHA_DEVICE(0x1032, "DGX-305"),
241 YAMAHA_DEVICE(0x1033, "DGX-505"),
242 YAMAHA_DEVICE(0x1034, NULL),
243 YAMAHA_DEVICE(0x1035, NULL),
244 YAMAHA_DEVICE(0x1036, NULL),
245 YAMAHA_DEVICE(0x1037, NULL),
246 YAMAHA_DEVICE(0x1038, NULL),
247 YAMAHA_DEVICE(0x1039, NULL),
248 YAMAHA_DEVICE(0x103a, NULL),
249 YAMAHA_DEVICE(0x103b, NULL),
250 YAMAHA_DEVICE(0x103c, NULL),
251 YAMAHA_DEVICE(0x103d, NULL),
252 YAMAHA_DEVICE(0x103e, NULL),
253 YAMAHA_DEVICE(0x103f, NULL),
254 YAMAHA_DEVICE(0x1040, NULL),
255 YAMAHA_DEVICE(0x1041, NULL),
256 YAMAHA_DEVICE(0x1042, NULL),
257 YAMAHA_DEVICE(0x1043, NULL),
258 YAMAHA_DEVICE(0x1044, NULL),
259 YAMAHA_DEVICE(0x1045, NULL),
260 YAMAHA_INTERFACE(0x104e, 0, NULL),
261 YAMAHA_DEVICE(0x104f, NULL),
262 YAMAHA_DEVICE(0x1050, NULL),
263 YAMAHA_DEVICE(0x1051, NULL),
264 YAMAHA_DEVICE(0x1052, NULL),
265 YAMAHA_INTERFACE(0x1053, 0, NULL),
266 YAMAHA_INTERFACE(0x1054, 0, NULL),
267 YAMAHA_DEVICE(0x1055, NULL),
268 YAMAHA_DEVICE(0x1056, NULL),
269 YAMAHA_DEVICE(0x1057, NULL),
270 YAMAHA_DEVICE(0x1058, NULL),
271 YAMAHA_DEVICE(0x1059, NULL),
272 YAMAHA_DEVICE(0x105a, NULL),
273 YAMAHA_DEVICE(0x105b, NULL),
274 YAMAHA_DEVICE(0x105c, NULL),
275 YAMAHA_DEVICE(0x105d, NULL),
277 USB_DEVICE(0x0499, 0x1503),
278 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
279 /* .vendor_name = "Yamaha", */
280 /* .product_name = "MOX6/MOX8", */
281 .ifnum = QUIRK_ANY_INTERFACE,
282 .type = QUIRK_COMPOSITE,
283 .data = (const struct snd_usb_audio_quirk[]) {
286 .type = QUIRK_AUDIO_STANDARD_INTERFACE
290 .type = QUIRK_AUDIO_STANDARD_INTERFACE
294 .type = QUIRK_MIDI_YAMAHA
303 USB_DEVICE(0x0499, 0x1507),
304 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
305 /* .vendor_name = "Yamaha", */
306 /* .product_name = "THR10", */
307 .ifnum = QUIRK_ANY_INTERFACE,
308 .type = QUIRK_COMPOSITE,
309 .data = (const struct snd_usb_audio_quirk[]) {
312 .type = QUIRK_AUDIO_STANDARD_INTERFACE
316 .type = QUIRK_AUDIO_STANDARD_INTERFACE
320 .type = QUIRK_MIDI_YAMAHA
329 USB_DEVICE(0x0499, 0x1509),
330 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
331 /* .vendor_name = "Yamaha", */
332 /* .product_name = "Steinberg UR22", */
333 .ifnum = QUIRK_ANY_INTERFACE,
334 .type = QUIRK_COMPOSITE,
335 .data = (const struct snd_usb_audio_quirk[]) {
338 .type = QUIRK_AUDIO_STANDARD_INTERFACE
342 .type = QUIRK_AUDIO_STANDARD_INTERFACE
346 .type = QUIRK_MIDI_YAMAHA
350 .type = QUIRK_IGNORE_INTERFACE
359 USB_DEVICE(0x0499, 0x150a),
360 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
361 /* .vendor_name = "Yamaha", */
362 /* .product_name = "THR5A", */
363 .ifnum = QUIRK_ANY_INTERFACE,
364 .type = QUIRK_COMPOSITE,
365 .data = (const struct snd_usb_audio_quirk[]) {
368 .type = QUIRK_AUDIO_STANDARD_INTERFACE
372 .type = QUIRK_AUDIO_STANDARD_INTERFACE
376 .type = QUIRK_MIDI_YAMAHA
385 USB_DEVICE(0x0499, 0x150c),
386 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
387 /* .vendor_name = "Yamaha", */
388 /* .product_name = "THR10C", */
389 .ifnum = QUIRK_ANY_INTERFACE,
390 .type = QUIRK_COMPOSITE,
391 .data = (const struct snd_usb_audio_quirk[]) {
394 .type = QUIRK_AUDIO_STANDARD_INTERFACE
398 .type = QUIRK_AUDIO_STANDARD_INTERFACE
402 .type = QUIRK_MIDI_YAMAHA
410 YAMAHA_DEVICE(0x2000, "DGP-7"),
411 YAMAHA_DEVICE(0x2001, "DGP-5"),
412 YAMAHA_DEVICE(0x2002, NULL),
413 YAMAHA_DEVICE(0x2003, NULL),
414 YAMAHA_DEVICE(0x5000, "CS1D"),
415 YAMAHA_DEVICE(0x5001, "DSP1D"),
416 YAMAHA_DEVICE(0x5002, "DME32"),
417 YAMAHA_DEVICE(0x5003, "DM2000"),
418 YAMAHA_DEVICE(0x5004, "02R96"),
419 YAMAHA_DEVICE(0x5005, "ACU16-C"),
420 YAMAHA_DEVICE(0x5006, "NHB32-C"),
421 YAMAHA_DEVICE(0x5007, "DM1000"),
422 YAMAHA_DEVICE(0x5008, "01V96"),
423 YAMAHA_DEVICE(0x5009, "SPX2000"),
424 YAMAHA_DEVICE(0x500a, "PM5D"),
425 YAMAHA_DEVICE(0x500b, "DME64N"),
426 YAMAHA_DEVICE(0x500c, "DME24N"),
427 YAMAHA_DEVICE(0x500d, NULL),
428 YAMAHA_DEVICE(0x500e, NULL),
429 YAMAHA_DEVICE(0x500f, NULL),
430 YAMAHA_DEVICE(0x7000, "DTX"),
431 YAMAHA_DEVICE(0x7010, "UB99"),
433 #undef YAMAHA_INTERFACE
434 /* this catches most recent vendor-specific Yamaha devices */
436 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
437 USB_DEVICE_ID_MATCH_INT_CLASS,
439 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
440 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
441 .ifnum = QUIRK_ANY_INTERFACE,
442 .type = QUIRK_AUTODETECT
447 * Roland/RolandED/Edirol/BOSS devices
450 USB_DEVICE(0x0582, 0x0000),
451 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
452 .vendor_name = "Roland",
453 .product_name = "UA-100",
454 .ifnum = QUIRK_ANY_INTERFACE,
455 .type = QUIRK_COMPOSITE,
456 .data = (const struct snd_usb_audio_quirk[]) {
459 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
460 .data = & (const struct audioformat) {
461 .formats = SNDRV_PCM_FMTBIT_S16_LE,
469 .rates = SNDRV_PCM_RATE_CONTINUOUS,
476 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
477 .data = & (const struct audioformat) {
478 .formats = SNDRV_PCM_FMTBIT_S16_LE,
483 .attributes = UAC_EP_CS_ATTR_FILL_MAX,
486 .rates = SNDRV_PCM_RATE_CONTINUOUS,
493 .type = QUIRK_MIDI_FIXED_ENDPOINT,
494 .data = & (const struct snd_usb_midi_endpoint_info) {
495 .out_cables = 0x0007,
506 USB_DEVICE(0x0582, 0x0002),
507 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
508 .vendor_name = "EDIROL",
509 .product_name = "UM-4",
510 .ifnum = QUIRK_ANY_INTERFACE,
511 .type = QUIRK_COMPOSITE,
512 .data = (const struct snd_usb_audio_quirk[]) {
515 .type = QUIRK_IGNORE_INTERFACE
519 .type = QUIRK_IGNORE_INTERFACE
523 .type = QUIRK_MIDI_FIXED_ENDPOINT,
524 .data = & (const struct snd_usb_midi_endpoint_info) {
525 .out_cables = 0x000f,
536 USB_DEVICE(0x0582, 0x0003),
537 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
538 .vendor_name = "Roland",
539 .product_name = "SC-8850",
540 .ifnum = QUIRK_ANY_INTERFACE,
541 .type = QUIRK_COMPOSITE,
542 .data = (const struct snd_usb_audio_quirk[]) {
545 .type = QUIRK_IGNORE_INTERFACE
549 .type = QUIRK_IGNORE_INTERFACE
553 .type = QUIRK_MIDI_FIXED_ENDPOINT,
554 .data = & (const struct snd_usb_midi_endpoint_info) {
555 .out_cables = 0x003f,
566 USB_DEVICE(0x0582, 0x0004),
567 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
568 .vendor_name = "Roland",
569 .product_name = "U-8",
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 = 0x0005,
596 /* Has ID 0x0099 when not in "Advanced Driver" mode.
597 * The UM-2EX has only one input, but we cannot detect this. */
598 USB_DEVICE(0x0582, 0x0005),
599 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
600 .vendor_name = "EDIROL",
601 .product_name = "UM-2",
602 .ifnum = QUIRK_ANY_INTERFACE,
603 .type = QUIRK_COMPOSITE,
604 .data = (const struct snd_usb_audio_quirk[]) {
607 .type = QUIRK_IGNORE_INTERFACE
611 .type = QUIRK_IGNORE_INTERFACE
615 .type = QUIRK_MIDI_FIXED_ENDPOINT,
616 .data = & (const struct snd_usb_midi_endpoint_info) {
617 .out_cables = 0x0003,
628 USB_DEVICE(0x0582, 0x0007),
629 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
630 .vendor_name = "Roland",
631 .product_name = "SC-8820",
632 .ifnum = QUIRK_ANY_INTERFACE,
633 .type = QUIRK_COMPOSITE,
634 .data = (const struct snd_usb_audio_quirk[]) {
637 .type = QUIRK_IGNORE_INTERFACE
641 .type = QUIRK_IGNORE_INTERFACE
645 .type = QUIRK_MIDI_FIXED_ENDPOINT,
646 .data = & (const struct snd_usb_midi_endpoint_info) {
647 .out_cables = 0x0013,
658 USB_DEVICE(0x0582, 0x0008),
659 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
660 .vendor_name = "Roland",
661 .product_name = "PC-300",
662 .ifnum = QUIRK_ANY_INTERFACE,
663 .type = QUIRK_COMPOSITE,
664 .data = (const struct snd_usb_audio_quirk[]) {
667 .type = QUIRK_IGNORE_INTERFACE
671 .type = QUIRK_IGNORE_INTERFACE
675 .type = QUIRK_MIDI_FIXED_ENDPOINT,
676 .data = & (const struct snd_usb_midi_endpoint_info) {
677 .out_cables = 0x0001,
688 /* has ID 0x009d when not in "Advanced Driver" mode */
689 USB_DEVICE(0x0582, 0x0009),
690 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
691 .vendor_name = "EDIROL",
692 .product_name = "UM-1",
693 .ifnum = QUIRK_ANY_INTERFACE,
694 .type = QUIRK_COMPOSITE,
695 .data = (const struct snd_usb_audio_quirk[]) {
698 .type = QUIRK_IGNORE_INTERFACE
702 .type = QUIRK_IGNORE_INTERFACE
706 .type = QUIRK_MIDI_FIXED_ENDPOINT,
707 .data = & (const struct snd_usb_midi_endpoint_info) {
708 .out_cables = 0x0001,
719 USB_DEVICE(0x0582, 0x000b),
720 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
721 .vendor_name = "Roland",
722 .product_name = "SK-500",
723 .ifnum = QUIRK_ANY_INTERFACE,
724 .type = QUIRK_COMPOSITE,
725 .data = (const struct snd_usb_audio_quirk[]) {
728 .type = QUIRK_IGNORE_INTERFACE
732 .type = QUIRK_IGNORE_INTERFACE
736 .type = QUIRK_MIDI_FIXED_ENDPOINT,
737 .data = & (const struct snd_usb_midi_endpoint_info) {
738 .out_cables = 0x0013,
749 /* thanks to Emiliano Grilli <emillo@libero.it>
750 * for helping researching this data */
751 USB_DEVICE(0x0582, 0x000c),
752 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
753 .vendor_name = "Roland",
754 .product_name = "SC-D70",
755 .ifnum = QUIRK_ANY_INTERFACE,
756 .type = QUIRK_COMPOSITE,
757 .data = (const struct snd_usb_audio_quirk[]) {
760 .type = QUIRK_AUDIO_STANDARD_INTERFACE
764 .type = QUIRK_AUDIO_STANDARD_INTERFACE
768 .type = QUIRK_MIDI_FIXED_ENDPOINT,
769 .data = & (const struct snd_usb_midi_endpoint_info) {
770 .out_cables = 0x0007,
781 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
782 * If the advanced mode switch at the back of the unit is off, the
783 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
784 * but offers only 16-bit PCM.
785 * In advanced mode, the UA-5 will output S24_3LE samples (two
786 * channels) at the rate indicated on the front switch, including
787 * the 96kHz sample rate.
789 USB_DEVICE(0x0582, 0x0010),
790 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
791 .vendor_name = "EDIROL",
792 .product_name = "UA-5",
793 .ifnum = QUIRK_ANY_INTERFACE,
794 .type = QUIRK_COMPOSITE,
795 .data = (const struct snd_usb_audio_quirk[]) {
798 .type = QUIRK_AUDIO_STANDARD_INTERFACE
802 .type = QUIRK_AUDIO_STANDARD_INTERFACE
811 /* has ID 0x0013 when not in "Advanced Driver" mode */
812 USB_DEVICE(0x0582, 0x0012),
813 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
814 .vendor_name = "Roland",
815 .product_name = "XV-5050",
817 .type = QUIRK_MIDI_FIXED_ENDPOINT,
818 .data = & (const struct snd_usb_midi_endpoint_info) {
819 .out_cables = 0x0001,
825 /* has ID 0x0015 when not in "Advanced Driver" mode */
826 USB_DEVICE(0x0582, 0x0014),
827 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
828 .vendor_name = "EDIROL",
829 .product_name = "UM-880",
831 .type = QUIRK_MIDI_FIXED_ENDPOINT,
832 .data = & (const struct snd_usb_midi_endpoint_info) {
833 .out_cables = 0x01ff,
839 /* has ID 0x0017 when not in "Advanced Driver" mode */
840 USB_DEVICE(0x0582, 0x0016),
841 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
842 .vendor_name = "EDIROL",
843 .product_name = "SD-90",
844 .ifnum = QUIRK_ANY_INTERFACE,
845 .type = QUIRK_COMPOSITE,
846 .data = (const struct snd_usb_audio_quirk[]) {
849 .type = QUIRK_AUDIO_STANDARD_INTERFACE
853 .type = QUIRK_AUDIO_STANDARD_INTERFACE
857 .type = QUIRK_MIDI_FIXED_ENDPOINT,
858 .data = & (const struct snd_usb_midi_endpoint_info) {
859 .out_cables = 0x000f,
870 /* has ID 0x001c when not in "Advanced Driver" mode */
871 USB_DEVICE(0x0582, 0x001b),
872 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
873 .vendor_name = "Roland",
874 .product_name = "MMP-2",
875 .ifnum = QUIRK_ANY_INTERFACE,
876 .type = QUIRK_COMPOSITE,
877 .data = (const struct snd_usb_audio_quirk[]) {
880 .type = QUIRK_IGNORE_INTERFACE
884 .type = QUIRK_IGNORE_INTERFACE
888 .type = QUIRK_MIDI_FIXED_ENDPOINT,
889 .data = & (const struct snd_usb_midi_endpoint_info) {
890 .out_cables = 0x0001,
901 /* has ID 0x001e when not in "Advanced Driver" mode */
902 USB_DEVICE(0x0582, 0x001d),
903 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
904 .vendor_name = "Roland",
905 .product_name = "V-SYNTH",
907 .type = QUIRK_MIDI_FIXED_ENDPOINT,
908 .data = & (const struct snd_usb_midi_endpoint_info) {
909 .out_cables = 0x0001,
915 /* has ID 0x0024 when not in "Advanced Driver" mode */
916 USB_DEVICE(0x0582, 0x0023),
917 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
918 .vendor_name = "EDIROL",
919 .product_name = "UM-550",
921 .type = QUIRK_MIDI_FIXED_ENDPOINT,
922 .data = & (const struct snd_usb_midi_endpoint_info) {
923 .out_cables = 0x003f,
930 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
931 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
934 USB_DEVICE(0x0582, 0x0025),
935 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
936 .vendor_name = "EDIROL",
937 .product_name = "UA-20",
938 .ifnum = QUIRK_ANY_INTERFACE,
939 .type = QUIRK_COMPOSITE,
940 .data = (const struct snd_usb_audio_quirk[]) {
943 .type = QUIRK_IGNORE_INTERFACE
947 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
948 .data = & (const struct audioformat) {
949 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
957 .rates = SNDRV_PCM_RATE_CONTINUOUS,
964 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
965 .data = & (const struct audioformat) {
966 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
974 .rates = SNDRV_PCM_RATE_CONTINUOUS,
981 .type = QUIRK_MIDI_FIXED_ENDPOINT,
982 .data = & (const struct snd_usb_midi_endpoint_info) {
983 .out_cables = 0x0001,
994 /* has ID 0x0028 when not in "Advanced Driver" mode */
995 USB_DEVICE(0x0582, 0x0027),
996 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
997 .vendor_name = "EDIROL",
998 .product_name = "SD-20",
1000 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1001 .data = & (const struct snd_usb_midi_endpoint_info) {
1002 .out_cables = 0x0003,
1008 /* has ID 0x002a when not in "Advanced Driver" mode */
1009 USB_DEVICE(0x0582, 0x0029),
1010 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1011 .vendor_name = "EDIROL",
1012 .product_name = "SD-80",
1014 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1015 .data = & (const struct snd_usb_midi_endpoint_info) {
1016 .out_cables = 0x000f,
1022 * This quirk is for the "Advanced" modes of the Edirol UA-700.
1023 * If the sample format switch is not in an advanced setting, the
1024 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
1025 * but offers only 16-bit PCM and no MIDI.
1027 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
1028 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1029 .vendor_name = "EDIROL",
1030 .product_name = "UA-700",
1031 .ifnum = QUIRK_ANY_INTERFACE,
1032 .type = QUIRK_COMPOSITE,
1033 .data = (const struct snd_usb_audio_quirk[]) {
1036 .type = QUIRK_AUDIO_EDIROL_UAXX
1040 .type = QUIRK_AUDIO_EDIROL_UAXX
1044 .type = QUIRK_AUDIO_EDIROL_UAXX
1053 /* has ID 0x002e when not in "Advanced Driver" mode */
1054 USB_DEVICE(0x0582, 0x002d),
1055 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1056 .vendor_name = "Roland",
1057 .product_name = "XV-2020",
1059 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1060 .data = & (const struct snd_usb_midi_endpoint_info) {
1061 .out_cables = 0x0001,
1067 /* has ID 0x0030 when not in "Advanced Driver" mode */
1068 USB_DEVICE(0x0582, 0x002f),
1069 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1070 .vendor_name = "Roland",
1071 .product_name = "VariOS",
1073 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1074 .data = & (const struct snd_usb_midi_endpoint_info) {
1075 .out_cables = 0x0007,
1081 /* has ID 0x0034 when not in "Advanced Driver" mode */
1082 USB_DEVICE(0x0582, 0x0033),
1083 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1084 .vendor_name = "EDIROL",
1085 .product_name = "PCR",
1087 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1088 .data = & (const struct snd_usb_midi_endpoint_info) {
1089 .out_cables = 0x0003,
1096 * Has ID 0x0038 when not in "Advanced Driver" mode;
1097 * later revisions use IDs 0x0054 and 0x00a2.
1099 USB_DEVICE(0x0582, 0x0037),
1100 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1101 .vendor_name = "Roland",
1102 .product_name = "Digital Piano",
1104 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1105 .data = & (const struct snd_usb_midi_endpoint_info) {
1106 .out_cables = 0x0001,
1113 * This quirk is for the "Advanced Driver" mode. If off, the GS-10
1114 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1117 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1118 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1119 .vendor_name = "BOSS",
1120 .product_name = "GS-10",
1121 .ifnum = QUIRK_ANY_INTERFACE,
1122 .type = QUIRK_COMPOSITE,
1123 .data = & (const struct snd_usb_audio_quirk[]) {
1126 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1130 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1134 .type = QUIRK_MIDI_STANDARD_INTERFACE
1143 /* has ID 0x0041 when not in "Advanced Driver" mode */
1144 USB_DEVICE(0x0582, 0x0040),
1145 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1146 .vendor_name = "Roland",
1147 .product_name = "GI-20",
1149 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1150 .data = & (const struct snd_usb_midi_endpoint_info) {
1151 .out_cables = 0x0001,
1157 /* has ID 0x0043 when not in "Advanced Driver" mode */
1158 USB_DEVICE(0x0582, 0x0042),
1159 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1160 .vendor_name = "Roland",
1161 .product_name = "RS-70",
1163 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1164 .data = & (const struct snd_usb_midi_endpoint_info) {
1165 .out_cables = 0x0001,
1171 /* has ID 0x0049 when not in "Advanced Driver" mode */
1172 USB_DEVICE(0x0582, 0x0047),
1173 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1174 /* .vendor_name = "EDIROL", */
1175 /* .product_name = "UR-80", */
1176 .ifnum = QUIRK_ANY_INTERFACE,
1177 .type = QUIRK_COMPOSITE,
1178 .data = (const struct snd_usb_audio_quirk[]) {
1179 /* in the 96 kHz modes, only interface 1 is there */
1182 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1186 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1195 /* has ID 0x004a when not in "Advanced Driver" mode */
1196 USB_DEVICE(0x0582, 0x0048),
1197 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1198 /* .vendor_name = "EDIROL", */
1199 /* .product_name = "UR-80", */
1201 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1202 .data = & (const struct snd_usb_midi_endpoint_info) {
1203 .out_cables = 0x0003,
1209 /* has ID 0x004e when not in "Advanced Driver" mode */
1210 USB_DEVICE(0x0582, 0x004c),
1211 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1212 .vendor_name = "EDIROL",
1213 .product_name = "PCR-A",
1214 .ifnum = QUIRK_ANY_INTERFACE,
1215 .type = QUIRK_COMPOSITE,
1216 .data = (const struct snd_usb_audio_quirk[]) {
1219 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1223 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1232 /* has ID 0x004f when not in "Advanced Driver" mode */
1233 USB_DEVICE(0x0582, 0x004d),
1234 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1235 .vendor_name = "EDIROL",
1236 .product_name = "PCR-A",
1238 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1239 .data = & (const struct snd_usb_midi_endpoint_info) {
1240 .out_cables = 0x0003,
1247 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1248 * is standard compliant, but has only 16-bit PCM.
1250 USB_DEVICE(0x0582, 0x0050),
1251 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1252 .vendor_name = "EDIROL",
1253 .product_name = "UA-3FX",
1254 .ifnum = QUIRK_ANY_INTERFACE,
1255 .type = QUIRK_COMPOSITE,
1256 .data = (const struct snd_usb_audio_quirk[]) {
1259 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1263 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1272 USB_DEVICE(0x0582, 0x0052),
1273 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1274 .vendor_name = "EDIROL",
1275 .product_name = "UM-1SX",
1277 .type = QUIRK_MIDI_STANDARD_INTERFACE
1281 USB_DEVICE(0x0582, 0x0060),
1282 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1283 .vendor_name = "Roland",
1284 .product_name = "EXR Series",
1286 .type = QUIRK_MIDI_STANDARD_INTERFACE
1290 /* has ID 0x0066 when not in "Advanced Driver" mode */
1291 USB_DEVICE(0x0582, 0x0064),
1292 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1293 /* .vendor_name = "EDIROL", */
1294 /* .product_name = "PCR-1", */
1295 .ifnum = QUIRK_ANY_INTERFACE,
1296 .type = QUIRK_COMPOSITE,
1297 .data = (const struct snd_usb_audio_quirk[]) {
1300 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1304 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1313 /* has ID 0x0067 when not in "Advanced Driver" mode */
1314 USB_DEVICE(0x0582, 0x0065),
1315 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1316 /* .vendor_name = "EDIROL", */
1317 /* .product_name = "PCR-1", */
1319 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1320 .data = & (const struct snd_usb_midi_endpoint_info) {
1321 .out_cables = 0x0001,
1327 /* has ID 0x006e when not in "Advanced Driver" mode */
1328 USB_DEVICE(0x0582, 0x006d),
1329 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1330 .vendor_name = "Roland",
1331 .product_name = "FANTOM-X",
1333 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1334 .data = & (const struct snd_usb_midi_endpoint_info) {
1335 .out_cables = 0x0001,
1341 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1342 * If the switch is not in an advanced setting, the UA-25 has
1343 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1344 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1346 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1347 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1348 .vendor_name = "EDIROL",
1349 .product_name = "UA-25",
1350 .ifnum = QUIRK_ANY_INTERFACE,
1351 .type = QUIRK_COMPOSITE,
1352 .data = (const struct snd_usb_audio_quirk[]) {
1355 .type = QUIRK_AUDIO_EDIROL_UAXX
1359 .type = QUIRK_AUDIO_EDIROL_UAXX
1363 .type = QUIRK_AUDIO_EDIROL_UAXX
1372 /* has ID 0x0076 when not in "Advanced Driver" mode */
1373 USB_DEVICE(0x0582, 0x0075),
1374 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1375 .vendor_name = "BOSS",
1376 .product_name = "DR-880",
1378 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1379 .data = & (const struct snd_usb_midi_endpoint_info) {
1380 .out_cables = 0x0001,
1386 /* has ID 0x007b when not in "Advanced Driver" mode */
1387 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1388 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1389 .vendor_name = "Roland",
1390 /* "RD" or "RD-700SX"? */
1392 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1393 .data = & (const struct snd_usb_midi_endpoint_info) {
1394 .out_cables = 0x0003,
1400 /* has ID 0x0081 when not in "Advanced Driver" mode */
1401 USB_DEVICE(0x0582, 0x0080),
1402 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1403 .vendor_name = "Roland",
1404 .product_name = "G-70",
1406 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1407 .data = & (const struct snd_usb_midi_endpoint_info) {
1408 .out_cables = 0x0001,
1414 /* has ID 0x008c when not in "Advanced Driver" mode */
1415 USB_DEVICE(0x0582, 0x008b),
1416 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1417 .vendor_name = "EDIROL",
1418 .product_name = "PC-50",
1420 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1421 .data = & (const struct snd_usb_midi_endpoint_info) {
1422 .out_cables = 0x0001,
1429 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1430 * is standard compliant, but has only 16-bit PCM and no MIDI.
1432 USB_DEVICE(0x0582, 0x00a3),
1433 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1434 .vendor_name = "EDIROL",
1435 .product_name = "UA-4FX",
1436 .ifnum = QUIRK_ANY_INTERFACE,
1437 .type = QUIRK_COMPOSITE,
1438 .data = (const struct snd_usb_audio_quirk[]) {
1441 .type = QUIRK_AUDIO_EDIROL_UAXX
1445 .type = QUIRK_AUDIO_EDIROL_UAXX
1449 .type = QUIRK_AUDIO_EDIROL_UAXX
1459 USB_DEVICE(0x0582, 0x00c4),
1460 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1461 .ifnum = QUIRK_ANY_INTERFACE,
1462 .type = QUIRK_COMPOSITE,
1463 .data = (const struct snd_usb_audio_quirk[]) {
1466 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1470 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1474 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1475 .data = & (const struct snd_usb_midi_endpoint_info) {
1476 .out_cables = 0x0001,
1487 /* Advanced modes of the Edirol UA-25EX.
1488 * For the standard mode, UA-25EX has ID 0582:00e7, which
1489 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1491 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1492 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1493 .vendor_name = "EDIROL",
1494 .product_name = "UA-25EX",
1495 .ifnum = QUIRK_ANY_INTERFACE,
1496 .type = QUIRK_COMPOSITE,
1497 .data = (const struct snd_usb_audio_quirk[]) {
1500 .type = QUIRK_AUDIO_EDIROL_UAXX
1504 .type = QUIRK_AUDIO_EDIROL_UAXX
1508 .type = QUIRK_AUDIO_EDIROL_UAXX
1518 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1519 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1521 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1522 .data = & (const struct snd_usb_midi_endpoint_info) {
1523 .out_cables = 0x0007,
1530 USB_DEVICE(0x0582, 0x0113),
1531 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1532 .ifnum = QUIRK_ANY_INTERFACE,
1533 .type = QUIRK_COMPOSITE,
1534 .data = (const struct snd_usb_audio_quirk[]) {
1537 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1541 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1545 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1546 .data = & (const struct snd_usb_midi_endpoint_info) {
1547 .out_cables = 0x0001,
1558 /* only 44.1 kHz works at the moment */
1559 USB_DEVICE(0x0582, 0x0120),
1560 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1561 /* .vendor_name = "Roland", */
1562 /* .product_name = "OCTO-CAPTURE", */
1563 .ifnum = QUIRK_ANY_INTERFACE,
1564 .type = QUIRK_COMPOSITE,
1565 .data = (const struct snd_usb_audio_quirk[]) {
1568 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1569 .data = & (const struct audioformat) {
1570 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1577 .rates = SNDRV_PCM_RATE_44100,
1581 .rate_table = (unsigned int[]) { 44100 }
1586 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1587 .data = & (const struct audioformat) {
1588 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1595 .rates = SNDRV_PCM_RATE_44100,
1599 .rate_table = (unsigned int[]) { 44100 }
1604 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1605 .data = & (const struct snd_usb_midi_endpoint_info) {
1606 .out_cables = 0x0001,
1612 .type = QUIRK_IGNORE_INTERFACE
1616 .type = QUIRK_IGNORE_INTERFACE
1625 /* only 44.1 kHz works at the moment */
1626 USB_DEVICE(0x0582, 0x012f),
1627 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1628 /* .vendor_name = "Roland", */
1629 /* .product_name = "QUAD-CAPTURE", */
1630 .ifnum = QUIRK_ANY_INTERFACE,
1631 .type = QUIRK_COMPOSITE,
1632 .data = (const struct snd_usb_audio_quirk[]) {
1635 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1636 .data = & (const struct audioformat) {
1637 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1644 .rates = SNDRV_PCM_RATE_44100,
1648 .rate_table = (unsigned int[]) { 44100 }
1653 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1654 .data = & (const struct audioformat) {
1655 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1662 .rates = SNDRV_PCM_RATE_44100,
1666 .rate_table = (unsigned int[]) { 44100 }
1671 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1672 .data = & (const struct snd_usb_midi_endpoint_info) {
1673 .out_cables = 0x0001,
1679 .type = QUIRK_IGNORE_INTERFACE
1683 .type = QUIRK_IGNORE_INTERFACE
1692 USB_DEVICE(0x0582, 0x0159),
1693 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1694 /* .vendor_name = "Roland", */
1695 /* .product_name = "UA-22", */
1696 .ifnum = QUIRK_ANY_INTERFACE,
1697 .type = QUIRK_COMPOSITE,
1698 .data = (const struct snd_usb_audio_quirk[]) {
1701 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1705 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1709 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1710 .data = & (const struct snd_usb_midi_endpoint_info) {
1711 .out_cables = 0x0001,
1721 /* this catches most recent vendor-specific Roland devices */
1723 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1724 USB_DEVICE_ID_MATCH_INT_CLASS,
1726 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1727 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1728 .ifnum = QUIRK_ANY_INTERFACE,
1729 .type = QUIRK_AUTODETECT
1733 /* Guillemot devices */
1736 * This is for the "Windows Edition" where the external MIDI ports are
1737 * the only MIDI ports; the control data is reported through HID
1738 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard
1739 * compliant USB MIDI ports for external MIDI and controls.
1741 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1742 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1743 .vendor_name = "Hercules",
1744 .product_name = "DJ Console (WE)",
1746 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1747 .data = & (const struct snd_usb_midi_endpoint_info) {
1748 .out_cables = 0x0001,
1754 /* Midiman/M-Audio devices */
1756 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1757 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1758 .vendor_name = "M-Audio",
1759 .product_name = "MidiSport 2x2",
1760 .ifnum = QUIRK_ANY_INTERFACE,
1761 .type = QUIRK_MIDI_MIDIMAN,
1762 .data = & (const struct snd_usb_midi_endpoint_info) {
1763 .out_cables = 0x0003,
1769 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1770 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1771 .vendor_name = "M-Audio",
1772 .product_name = "MidiSport 1x1",
1773 .ifnum = QUIRK_ANY_INTERFACE,
1774 .type = QUIRK_MIDI_MIDIMAN,
1775 .data = & (const struct snd_usb_midi_endpoint_info) {
1776 .out_cables = 0x0001,
1782 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1783 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1784 .vendor_name = "M-Audio",
1785 .product_name = "Keystation",
1786 .ifnum = QUIRK_ANY_INTERFACE,
1787 .type = QUIRK_MIDI_MIDIMAN,
1788 .data = & (const struct snd_usb_midi_endpoint_info) {
1789 .out_cables = 0x0001,
1795 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1796 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1797 .vendor_name = "M-Audio",
1798 .product_name = "MidiSport 4x4",
1799 .ifnum = QUIRK_ANY_INTERFACE,
1800 .type = QUIRK_MIDI_MIDIMAN,
1801 .data = & (const struct snd_usb_midi_endpoint_info) {
1802 .out_cables = 0x000f,
1809 * For hardware revision 1.05; in the later revisions (1.10 and
1810 * 1.21), 0x1031 is the ID for the device without firmware.
1811 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1813 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1814 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1815 .vendor_name = "M-Audio",
1816 .product_name = "MidiSport 8x8",
1817 .ifnum = QUIRK_ANY_INTERFACE,
1818 .type = QUIRK_MIDI_MIDIMAN,
1819 .data = & (const struct snd_usb_midi_endpoint_info) {
1820 .out_cables = 0x01ff,
1826 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1827 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1828 .vendor_name = "M-Audio",
1829 .product_name = "MidiSport 8x8",
1830 .ifnum = QUIRK_ANY_INTERFACE,
1831 .type = QUIRK_MIDI_MIDIMAN,
1832 .data = & (const struct snd_usb_midi_endpoint_info) {
1833 .out_cables = 0x01ff,
1839 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1840 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1841 .vendor_name = "M-Audio",
1842 .product_name = "MidiSport 2x4",
1843 .ifnum = QUIRK_ANY_INTERFACE,
1844 .type = QUIRK_MIDI_MIDIMAN,
1845 .data = & (const struct snd_usb_midi_endpoint_info) {
1846 .out_cables = 0x000f,
1852 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1853 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1854 .vendor_name = "M-Audio",
1855 .product_name = "Quattro",
1856 .ifnum = QUIRK_ANY_INTERFACE,
1857 .type = QUIRK_COMPOSITE,
1858 .data = & (const struct snd_usb_audio_quirk[]) {
1860 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1861 * and share endpoints with the other interfaces.
1862 * Ignore them. The other interfaces can do 24 bits,
1863 * but captured samples are big-endian (see usbaudio.c).
1867 .type = QUIRK_IGNORE_INTERFACE
1871 .type = QUIRK_IGNORE_INTERFACE
1875 .type = QUIRK_IGNORE_INTERFACE
1879 .type = QUIRK_IGNORE_INTERFACE
1883 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1887 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1891 .type = QUIRK_IGNORE_INTERFACE
1895 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1899 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1903 .type = QUIRK_MIDI_MIDIMAN,
1904 .data = & (const struct snd_usb_midi_endpoint_info) {
1905 .out_cables = 0x0001,
1916 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1917 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1918 .vendor_name = "M-Audio",
1919 .product_name = "AudioPhile",
1921 .type = QUIRK_MIDI_MIDIMAN,
1922 .data = & (const struct snd_usb_midi_endpoint_info) {
1923 .out_cables = 0x0001,
1929 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1930 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1931 .vendor_name = "M-Audio",
1932 .product_name = "Ozone",
1934 .type = QUIRK_MIDI_MIDIMAN,
1935 .data = & (const struct snd_usb_midi_endpoint_info) {
1936 .out_cables = 0x0001,
1942 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1943 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1944 .vendor_name = "M-Audio",
1945 .product_name = "OmniStudio",
1946 .ifnum = QUIRK_ANY_INTERFACE,
1947 .type = QUIRK_COMPOSITE,
1948 .data = & (const struct snd_usb_audio_quirk[]) {
1951 .type = QUIRK_IGNORE_INTERFACE
1955 .type = QUIRK_IGNORE_INTERFACE
1959 .type = QUIRK_IGNORE_INTERFACE
1963 .type = QUIRK_IGNORE_INTERFACE
1967 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1971 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1975 .type = QUIRK_IGNORE_INTERFACE
1979 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1983 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1987 .type = QUIRK_MIDI_MIDIMAN,
1988 .data = & (const struct snd_usb_midi_endpoint_info) {
1989 .out_cables = 0x0001,
2000 USB_DEVICE(0x0763, 0x2019),
2001 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2002 /* .vendor_name = "M-Audio", */
2003 /* .product_name = "Ozone Academic", */
2004 .ifnum = QUIRK_ANY_INTERFACE,
2005 .type = QUIRK_COMPOSITE,
2006 .data = & (const struct snd_usb_audio_quirk[]) {
2009 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2013 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2017 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2021 .type = QUIRK_MIDI_MIDIMAN,
2022 .data = & (const struct snd_usb_midi_endpoint_info) {
2023 .out_cables = 0x0001,
2035 USB_DEVICE_VENDOR_SPEC(0x0763, 0x201a),
2038 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2039 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2040 /* .vendor_name = "M-Audio", */
2041 /* .product_name = "Fast Track C400", */
2042 .ifnum = QUIRK_ANY_INTERFACE,
2043 .type = QUIRK_COMPOSITE,
2044 .data = &(const struct snd_usb_audio_quirk[]) {
2047 .type = QUIRK_AUDIO_STANDARD_MIXER,
2052 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2053 .data = &(const struct audioformat) {
2054 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2059 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2062 .rates = SNDRV_PCM_RATE_44100 |
2063 SNDRV_PCM_RATE_48000 |
2064 SNDRV_PCM_RATE_88200 |
2065 SNDRV_PCM_RATE_96000,
2069 .rate_table = (unsigned int[]) {
2070 44100, 48000, 88200, 96000
2078 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2079 .data = &(const struct audioformat) {
2080 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2085 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2088 .rates = SNDRV_PCM_RATE_44100 |
2089 SNDRV_PCM_RATE_48000 |
2090 SNDRV_PCM_RATE_88200 |
2091 SNDRV_PCM_RATE_96000,
2095 .rate_table = (unsigned int[]) {
2096 44100, 48000, 88200, 96000
2103 .ifnum = -1 /* Interface = 4 */
2109 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2110 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2111 /* .vendor_name = "M-Audio", */
2112 /* .product_name = "Fast Track C600", */
2113 .ifnum = QUIRK_ANY_INTERFACE,
2114 .type = QUIRK_COMPOSITE,
2115 .data = &(const struct snd_usb_audio_quirk[]) {
2118 .type = QUIRK_AUDIO_STANDARD_MIXER,
2123 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2124 .data = &(const struct audioformat) {
2125 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2130 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2133 .rates = SNDRV_PCM_RATE_44100 |
2134 SNDRV_PCM_RATE_48000 |
2135 SNDRV_PCM_RATE_88200 |
2136 SNDRV_PCM_RATE_96000,
2140 .rate_table = (unsigned int[]) {
2141 44100, 48000, 88200, 96000
2149 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2150 .data = &(const struct audioformat) {
2151 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2156 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2159 .rates = SNDRV_PCM_RATE_44100 |
2160 SNDRV_PCM_RATE_48000 |
2161 SNDRV_PCM_RATE_88200 |
2162 SNDRV_PCM_RATE_96000,
2166 .rate_table = (unsigned int[]) {
2167 44100, 48000, 88200, 96000
2174 .ifnum = -1 /* Interface = 4 */
2180 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2181 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2182 /* .vendor_name = "M-Audio", */
2183 /* .product_name = "Fast Track Ultra", */
2184 .ifnum = QUIRK_ANY_INTERFACE,
2185 .type = QUIRK_COMPOSITE,
2186 .data = & (const struct snd_usb_audio_quirk[]) {
2189 .type = QUIRK_AUDIO_STANDARD_MIXER,
2193 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2194 .data = & (const struct audioformat) {
2195 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2200 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2203 .rates = SNDRV_PCM_RATE_44100 |
2204 SNDRV_PCM_RATE_48000 |
2205 SNDRV_PCM_RATE_88200 |
2206 SNDRV_PCM_RATE_96000,
2210 .rate_table = (unsigned int[]) {
2211 44100, 48000, 88200, 96000
2217 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2218 .data = & (const struct audioformat) {
2219 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2224 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2227 .rates = SNDRV_PCM_RATE_44100 |
2228 SNDRV_PCM_RATE_48000 |
2229 SNDRV_PCM_RATE_88200 |
2230 SNDRV_PCM_RATE_96000,
2234 .rate_table = (unsigned int[]) {
2235 44100, 48000, 88200, 96000
2239 /* interface 3 (MIDI) is standard compliant */
2247 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2248 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2249 /* .vendor_name = "M-Audio", */
2250 /* .product_name = "Fast Track Ultra 8R", */
2251 .ifnum = QUIRK_ANY_INTERFACE,
2252 .type = QUIRK_COMPOSITE,
2253 .data = & (const struct snd_usb_audio_quirk[]) {
2256 .type = QUIRK_AUDIO_STANDARD_MIXER,
2260 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2261 .data = & (const struct audioformat) {
2262 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2267 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2270 .rates = SNDRV_PCM_RATE_44100 |
2271 SNDRV_PCM_RATE_48000 |
2272 SNDRV_PCM_RATE_88200 |
2273 SNDRV_PCM_RATE_96000,
2277 .rate_table = (unsigned int[]) {
2278 44100, 48000, 88200, 96000
2284 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2285 .data = & (const struct audioformat) {
2286 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2291 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2294 .rates = SNDRV_PCM_RATE_44100 |
2295 SNDRV_PCM_RATE_48000 |
2296 SNDRV_PCM_RATE_88200 |
2297 SNDRV_PCM_RATE_96000,
2301 .rate_table = (unsigned int[]) {
2302 44100, 48000, 88200, 96000
2306 /* interface 3 (MIDI) is standard compliant */
2316 USB_DEVICE(0x07cf, 0x6801),
2317 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2318 .vendor_name = "Casio",
2319 .product_name = "PL-40R",
2321 .type = QUIRK_MIDI_YAMAHA
2325 /* this ID is used by several devices without a product ID */
2326 USB_DEVICE(0x07cf, 0x6802),
2327 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2328 .vendor_name = "Casio",
2329 .product_name = "Keyboard",
2331 .type = QUIRK_MIDI_YAMAHA
2335 /* Mark of the Unicorn devices */
2337 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2338 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2339 USB_DEVICE_ID_MATCH_PRODUCT |
2340 USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2342 .idProduct = 0x0001,
2343 .bDeviceSubClass = 2,
2344 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2345 .vendor_name = "MOTU",
2346 .product_name = "Fastlane",
2347 .ifnum = QUIRK_ANY_INTERFACE,
2348 .type = QUIRK_COMPOSITE,
2349 .data = & (const struct snd_usb_audio_quirk[]) {
2352 .type = QUIRK_MIDI_RAW_BYTES
2356 .type = QUIRK_IGNORE_INTERFACE
2365 /* Emagic devices */
2367 USB_DEVICE(0x086a, 0x0001),
2368 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2369 .vendor_name = "Emagic",
2370 .product_name = "Unitor8",
2372 .type = QUIRK_MIDI_EMAGIC,
2373 .data = & (const struct snd_usb_midi_endpoint_info) {
2374 .out_cables = 0x80ff,
2380 USB_DEVICE(0x086a, 0x0002),
2381 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2382 .vendor_name = "Emagic",
2383 /* .product_name = "AMT8", */
2385 .type = QUIRK_MIDI_EMAGIC,
2386 .data = & (const struct snd_usb_midi_endpoint_info) {
2387 .out_cables = 0x80ff,
2393 USB_DEVICE(0x086a, 0x0003),
2394 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2395 .vendor_name = "Emagic",
2396 /* .product_name = "MT4", */
2398 .type = QUIRK_MIDI_EMAGIC,
2399 .data = & (const struct snd_usb_midi_endpoint_info) {
2400 .out_cables = 0x800f,
2408 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2409 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2410 .vendor_name = "KORG, Inc.",
2411 /* .product_name = "PANDORA PX5D", */
2413 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2418 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2419 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2420 .vendor_name = "KORG, Inc.",
2421 /* .product_name = "ToneLab ST", */
2423 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2428 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0204),
2429 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2430 .vendor_name = "KORG, Inc.",
2431 /* .product_name = "ToneLab EX", */
2433 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2439 USB_DEVICE(0x09e8, 0x0062),
2440 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2441 .vendor_name = "AKAI",
2442 .product_name = "MPD16",
2444 .type = QUIRK_MIDI_AKAI,
2449 /* Akai MPC Element */
2450 USB_DEVICE(0x09e8, 0x0021),
2451 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2452 .ifnum = QUIRK_ANY_INTERFACE,
2453 .type = QUIRK_COMPOSITE,
2454 .data = & (const struct snd_usb_audio_quirk[]) {
2457 .type = QUIRK_IGNORE_INTERFACE
2461 .type = QUIRK_MIDI_STANDARD_INTERFACE
2470 /* Steinberg devices */
2473 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2474 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2475 .ifnum = QUIRK_ANY_INTERFACE,
2476 .type = QUIRK_COMPOSITE,
2477 .data = & (const struct snd_usb_audio_quirk[]) {
2480 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2484 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2488 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2492 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2493 .data = &(const struct snd_usb_midi_endpoint_info) {
2494 .out_cables = 0x0001,
2506 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2507 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2508 .ifnum = QUIRK_ANY_INTERFACE,
2509 .type = QUIRK_COMPOSITE,
2510 .data = & (const struct snd_usb_audio_quirk[]) {
2513 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2517 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2521 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2525 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2526 .data = &(const struct snd_usb_midi_endpoint_info) {
2527 .out_cables = 0x0001,
2538 /* TerraTec devices */
2540 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2541 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2542 .vendor_name = "TerraTec",
2543 .product_name = "PHASE 26",
2545 .type = QUIRK_MIDI_STANDARD_INTERFACE
2549 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2550 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2551 .vendor_name = "TerraTec",
2552 .product_name = "PHASE 26",
2554 .type = QUIRK_MIDI_STANDARD_INTERFACE
2558 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2559 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2560 .vendor_name = "TerraTec",
2561 .product_name = "PHASE 26",
2563 .type = QUIRK_MIDI_STANDARD_INTERFACE
2567 USB_DEVICE(0x0ccd, 0x0035),
2568 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2569 .vendor_name = "Miditech",
2570 .product_name = "Play'n Roll",
2572 .type = QUIRK_MIDI_CME
2576 /* Novation EMS devices */
2578 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2579 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2580 .vendor_name = "Novation",
2581 .product_name = "ReMOTE Audio/XStation",
2583 .type = QUIRK_MIDI_NOVATION
2587 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2588 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2589 .vendor_name = "Novation",
2590 .product_name = "Speedio",
2592 .type = QUIRK_MIDI_NOVATION
2596 USB_DEVICE(0x1235, 0x000a),
2597 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2598 /* .vendor_name = "Novation", */
2599 /* .product_name = "Nocturn", */
2601 .type = QUIRK_MIDI_RAW_BYTES
2605 USB_DEVICE(0x1235, 0x000e),
2606 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2607 /* .vendor_name = "Novation", */
2608 /* .product_name = "Launchpad", */
2610 .type = QUIRK_MIDI_RAW_BYTES
2614 USB_DEVICE(0x1235, 0x0010),
2615 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2616 .vendor_name = "Focusrite",
2617 .product_name = "Saffire 6 USB",
2618 .ifnum = QUIRK_ANY_INTERFACE,
2619 .type = QUIRK_COMPOSITE,
2620 .data = (const struct snd_usb_audio_quirk[]) {
2623 .type = QUIRK_AUDIO_STANDARD_MIXER,
2627 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2628 .data = &(const struct audioformat) {
2629 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2634 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2636 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2638 .maxpacksize = 0x024c,
2639 .rates = SNDRV_PCM_RATE_44100 |
2640 SNDRV_PCM_RATE_48000,
2644 .rate_table = (unsigned int[]) {
2651 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2652 .data = &(const struct audioformat) {
2653 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2660 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2662 .maxpacksize = 0x0126,
2663 .rates = SNDRV_PCM_RATE_44100 |
2664 SNDRV_PCM_RATE_48000,
2668 .rate_table = (unsigned int[]) {
2675 .type = QUIRK_MIDI_RAW_BYTES
2684 USB_DEVICE(0x1235, 0x0018),
2685 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2686 .vendor_name = "Novation",
2687 .product_name = "Twitch",
2688 .ifnum = QUIRK_ANY_INTERFACE,
2689 .type = QUIRK_COMPOSITE,
2690 .data = (const struct snd_usb_audio_quirk[]) {
2693 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2694 .data = & (const struct audioformat) {
2695 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2700 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2702 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2703 .rates = SNDRV_PCM_RATE_44100 |
2704 SNDRV_PCM_RATE_48000,
2708 .rate_table = (unsigned int[]) {
2715 .type = QUIRK_MIDI_RAW_BYTES
2724 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2725 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2726 .vendor_name = "Novation",
2727 .product_name = "ReMOTE25",
2729 .type = QUIRK_MIDI_NOVATION
2733 /* Access Music devices */
2735 /* VirusTI Desktop */
2736 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2737 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2738 .ifnum = QUIRK_ANY_INTERFACE,
2739 .type = QUIRK_COMPOSITE,
2740 .data = &(const struct snd_usb_audio_quirk[]) {
2743 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2744 .data = &(const struct snd_usb_midi_endpoint_info) {
2745 .out_cables = 0x0003,
2751 .type = QUIRK_IGNORE_INTERFACE
2760 /* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */
2762 USB_DEVICE(0x17aa, 0x1046),
2763 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2764 .ifnum = QUIRK_ANY_INTERFACE,
2765 .type = QUIRK_SETUP_DISABLE_AUTOSUSPEND
2768 /* Lenovo ThinkStation P620 Internal Speaker + Front Headset */
2770 USB_DEVICE(0x17aa, 0x104d),
2771 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2772 .ifnum = QUIRK_ANY_INTERFACE,
2773 .type = QUIRK_SETUP_DISABLE_AUTOSUSPEND
2777 /* Native Instruments MK2 series */
2779 /* Komplete Audio 6 */
2780 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2782 .idProduct = 0x1000,
2785 /* Traktor Audio 6 */
2786 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2788 .idProduct = 0x1010,
2791 /* Traktor Audio 10 */
2792 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2794 .idProduct = 0x1020,
2797 /* QinHeng devices */
2799 USB_DEVICE(0x1a86, 0x752d),
2800 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2801 .vendor_name = "QinHeng",
2802 .product_name = "CH345",
2804 .type = QUIRK_MIDI_CH345
2808 /* KeithMcMillen Stringport */
2809 { USB_DEVICE(0x1f38, 0x0001) }, /* FIXME: should be more restrictive matching */
2811 /* Miditech devices */
2813 USB_DEVICE(0x4752, 0x0011),
2814 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2815 .vendor_name = "Miditech",
2816 .product_name = "Midistart-2",
2818 .type = QUIRK_MIDI_CME
2822 /* Central Music devices */
2824 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2825 USB_DEVICE(0x7104, 0x2202),
2826 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2828 .type = QUIRK_MIDI_CME
2833 * Auvitek au0828 devices with audio interface.
2834 * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
2835 * Please notice that some drivers are DVB only, and don't need to be
2836 * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2839 #define AU0828_DEVICE(vid, pid, vname, pname) { \
2840 USB_AUDIO_DEVICE(vid, pid), \
2841 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2842 .vendor_name = vname, \
2843 .product_name = pname, \
2844 .ifnum = QUIRK_ANY_INTERFACE, \
2845 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
2846 .shares_media_device = 1, \
2850 AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2851 AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2852 AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
2853 AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
2854 AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
2855 AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
2856 AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
2857 AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
2858 AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
2859 AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
2860 AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
2861 AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
2862 AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
2863 AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
2864 AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
2865 AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
2866 AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
2868 /* Syntek STK1160 */
2870 USB_AUDIO_DEVICE(0x05e1, 0x0408),
2871 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2872 .vendor_name = "Syntek",
2873 .product_name = "STK1160",
2874 .ifnum = QUIRK_ANY_INTERFACE,
2875 .type = QUIRK_AUDIO_ALIGN_TRANSFER
2879 /* Digidesign Mbox */
2881 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2882 USB_DEVICE(0x0dba, 0x1000),
2883 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2884 .vendor_name = "Digidesign",
2885 .product_name = "MBox",
2886 .ifnum = QUIRK_ANY_INTERFACE,
2887 .type = QUIRK_COMPOSITE,
2888 .data = (const struct snd_usb_audio_quirk[]){
2891 .type = QUIRK_AUDIO_STANDARD_MIXER,
2895 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2896 .data = &(const struct audioformat) {
2897 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2904 .ep_attr = USB_ENDPOINT_XFER_ISOC |
2905 USB_ENDPOINT_SYNC_SYNC,
2906 .maxpacksize = 0x130,
2907 .rates = SNDRV_PCM_RATE_48000,
2911 .rate_table = (unsigned int[]) {
2918 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2919 .data = &(const struct audioformat) {
2920 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2927 .ep_attr = USB_ENDPOINT_XFER_ISOC |
2928 USB_ENDPOINT_SYNC_ASYNC,
2929 .maxpacksize = 0x130,
2930 .rates = SNDRV_PCM_RATE_48000,
2934 .rate_table = (unsigned int[]) {
2946 /* DIGIDESIGN MBOX 2 */
2948 USB_DEVICE(0x0dba, 0x3000),
2949 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2950 .vendor_name = "Digidesign",
2951 .product_name = "Mbox 2",
2952 .ifnum = QUIRK_ANY_INTERFACE,
2953 .type = QUIRK_COMPOSITE,
2954 .data = (const struct snd_usb_audio_quirk[]) {
2957 .type = QUIRK_IGNORE_INTERFACE
2961 .type = QUIRK_IGNORE_INTERFACE
2965 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2966 .data = &(const struct audioformat) {
2967 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2974 .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
2975 .rates = SNDRV_PCM_RATE_48000,
2979 .rate_table = (unsigned int[]) {
2986 .type = QUIRK_IGNORE_INTERFACE
2990 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2991 .data = &(const struct audioformat) {
2992 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2997 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2999 .ep_attr = USB_ENDPOINT_SYNC_SYNC,
3000 .rates = SNDRV_PCM_RATE_48000,
3004 .rate_table = (unsigned int[]) {
3011 .type = QUIRK_IGNORE_INTERFACE
3015 .type = QUIRK_MIDI_MIDIMAN,
3016 .data = &(const struct snd_usb_midi_endpoint_info) {
3018 .out_cables = 0x0001,
3020 .in_interval = 0x01,
3031 /* Tascam US122 MKII - playback-only support */
3032 USB_DEVICE_VENDOR_SPEC(0x0644, 0x8021),
3033 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3034 .vendor_name = "TASCAM",
3035 .product_name = "US122 MKII",
3036 .ifnum = QUIRK_ANY_INTERFACE,
3037 .type = QUIRK_COMPOSITE,
3038 .data = (const struct snd_usb_audio_quirk[]) {
3041 .type = QUIRK_IGNORE_INTERFACE
3045 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3046 .data = &(const struct audioformat) {
3047 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3052 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3054 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3055 .rates = SNDRV_PCM_RATE_44100 |
3056 SNDRV_PCM_RATE_48000 |
3057 SNDRV_PCM_RATE_88200 |
3058 SNDRV_PCM_RATE_96000,
3062 .rate_table = (unsigned int[]) {
3063 44100, 48000, 88200, 96000
3074 /* Microsoft XboxLive Headset/Xbox Communicator */
3076 USB_DEVICE(0x045e, 0x0283),
3077 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3078 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3079 .vendor_name = "Microsoft",
3080 .product_name = "XboxLive Headset/Xbox Communicator",
3081 .ifnum = QUIRK_ANY_INTERFACE,
3082 .type = QUIRK_COMPOSITE,
3083 .data = &(const struct snd_usb_audio_quirk[]) {
3087 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3088 .data = &(const struct audioformat) {
3089 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3097 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3105 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3106 .data = &(const struct audioformat) {
3107 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3115 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3129 USB_DEVICE(0x200c, 0x100b),
3130 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3131 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3132 .ifnum = QUIRK_ANY_INTERFACE,
3133 .type = QUIRK_COMPOSITE,
3134 .data = &(const struct snd_usb_audio_quirk[]) {
3137 .type = QUIRK_AUDIO_STANDARD_MIXER,
3141 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3142 .data = &(const struct audioformat) {
3143 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3148 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3150 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3151 .rates = SNDRV_PCM_RATE_44100 |
3152 SNDRV_PCM_RATE_48000,
3156 .rate_table = (unsigned int[]) {
3170 * ZOOM R16/24 in audio interface mode.
3171 * Playback requires an extra four byte LE length indicator
3172 * at the start of each isochronous packet. This quirk is
3173 * enabled in create_standard_audio_quirk().
3175 USB_DEVICE(0x1686, 0x00dd),
3176 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3177 .ifnum = QUIRK_ANY_INTERFACE,
3178 .type = QUIRK_COMPOSITE,
3179 .data = (const struct snd_usb_audio_quirk[]) {
3183 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3188 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3193 .type = QUIRK_MIDI_STANDARD_INTERFACE
3204 * Some USB MIDI devices don't have an audio control interface,
3205 * so we have to grab MIDI streaming interfaces here.
3207 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3208 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3209 .bInterfaceClass = USB_CLASS_AUDIO,
3210 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3211 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3212 .ifnum = QUIRK_ANY_INTERFACE,
3213 .type = QUIRK_MIDI_STANDARD_INTERFACE
3219 USB_DEVICE(0x13e5, 0x0001),
3220 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3221 .ifnum = QUIRK_ANY_INTERFACE,
3222 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3226 /* disabled due to regression for other devices;
3227 * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3232 * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3233 * ID, but it looks like the product ID actually is only for Nura.
3234 * The capture interface does not work at all (even on Windows),
3235 * and only the 48 kHz sample rate works for the playback interface.
3237 USB_DEVICE(0x0a12, 0x1243),
3238 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3239 .ifnum = QUIRK_ANY_INTERFACE,
3240 .type = QUIRK_COMPOSITE,
3241 .data = (const struct snd_usb_audio_quirk[]) {
3244 .type = QUIRK_AUDIO_STANDARD_MIXER,
3249 .type = QUIRK_IGNORE_INTERFACE,
3254 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3255 .data = &(const struct audioformat) {
3256 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3261 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3262 UAC_EP_CS_ATTR_SAMPLE_RATE,
3264 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3265 .rates = SNDRV_PCM_RATE_48000,
3269 .rate_table = (unsigned int[]) {
3280 #endif /* disabled */
3284 * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3285 * even though it advertises more. The capture interface doesn't work
3288 USB_DEVICE(0x19b5, 0x0021),
3289 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3290 .ifnum = QUIRK_ANY_INTERFACE,
3291 .type = QUIRK_COMPOSITE,
3292 .data = (const struct snd_usb_audio_quirk[]) {
3295 .type = QUIRK_AUDIO_STANDARD_MIXER,
3300 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3301 .data = &(const struct audioformat) {
3302 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3307 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3308 UAC_EP_CS_ATTR_SAMPLE_RATE,
3310 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3311 .rates = SNDRV_PCM_RATE_48000,
3315 .rate_table = (unsigned int[]) {
3326 /* Dell WD19 Dock */
3328 USB_DEVICE(0x0bda, 0x402e),
3329 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3330 .ifnum = QUIRK_ANY_INTERFACE,
3331 .type = QUIRK_SETUP_FMT_AFTER_RESUME
3334 /* MOTU Microbook II */
3336 USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004),
3337 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3338 .vendor_name = "MOTU",
3339 .product_name = "MicroBookII",
3340 .ifnum = QUIRK_ANY_INTERFACE,
3341 .type = QUIRK_COMPOSITE,
3342 .data = (const struct snd_usb_audio_quirk[]) {
3345 .type = QUIRK_AUDIO_STANDARD_MIXER,
3349 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3350 .data = &(const struct audioformat) {
3351 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3358 .rates = SNDRV_PCM_RATE_96000,
3359 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3360 USB_ENDPOINT_SYNC_ASYNC,
3364 .maxpacksize = 0x00d8,
3365 .rate_table = (unsigned int[]) {
3372 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3373 .data = &(const struct audioformat) {
3374 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3381 .rates = SNDRV_PCM_RATE_96000,
3382 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3383 USB_ENDPOINT_SYNC_ASYNC,
3387 .maxpacksize = 0x0120,
3388 .rate_table = (unsigned int[]) {
3401 * PIONEER DJ DDJ-SX3
3402 * PCM is 12 channels out, 10 channels in @ 44.1 fixed
3403 * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
3404 * The feedback for the output is the input.
3406 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
3407 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3408 .ifnum = QUIRK_ANY_INTERFACE,
3409 .type = QUIRK_COMPOSITE,
3410 .data = (const struct snd_usb_audio_quirk[]) {
3413 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3414 .data = &(const struct audioformat) {
3415 .formats = SNDRV_PCM_FMTBIT_S32_LE,
3421 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3422 USB_ENDPOINT_SYNC_ASYNC,
3423 .rates = SNDRV_PCM_RATE_44100,
3427 .rate_table = (unsigned int[]) { 44100 }
3432 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3433 .data = &(const struct audioformat) {
3434 .formats = SNDRV_PCM_FMTBIT_S32_LE,
3440 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3441 USB_ENDPOINT_SYNC_ASYNC|
3442 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3443 .rates = SNDRV_PCM_RATE_44100,
3447 .rate_table = (unsigned int[]) { 44100 }
3458 * Pioneer DJ DJM-250MK2
3459 * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
3460 * and 8 channels in @ 48 fixed (endpoint 0x82).
3462 * Both playback and recording is working, even simultaneously.
3464 * Playback channels could be mapped to:
3469 * Recording channels could be mapped to:
3478 * There is remaining problem with recording directly from PHONO/LINE.
3479 * If we map a channel to:
3480 * - CH1 Control Tone PHONO
3481 * - CH1 Control Tone LINE
3482 * - CH2 Control Tone PHONO
3483 * - CH2 Control Tone LINE
3485 * There is no signal even on other operating systems with official drivers.
3486 * The signal appears only when a supported application is started.
3487 * This needs to be investigated yet...
3488 * (there is quite a lot communication on the USB in both directions)
3490 * In current version this mixer could be used for playback
3491 * and for recording from vinyls (through Post CH* Fader)
3492 * but not for DVS (Digital Vinyl Systems) like in Mixxx.
3494 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3495 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3496 .ifnum = QUIRK_ANY_INTERFACE,
3497 .type = QUIRK_COMPOSITE,
3498 .data = (const struct snd_usb_audio_quirk[]) {
3501 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3502 .data = &(const struct audioformat) {
3503 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3504 .channels = 8, // outputs
3509 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3510 USB_ENDPOINT_SYNC_ASYNC,
3511 .rates = SNDRV_PCM_RATE_48000,
3515 .rate_table = (unsigned int[]) { 48000 }
3520 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3521 .data = &(const struct audioformat) {
3522 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3523 .channels = 8, // inputs
3528 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3529 USB_ENDPOINT_SYNC_ASYNC|
3530 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3531 .rates = SNDRV_PCM_RATE_48000,
3535 .rate_table = (unsigned int[]) { 48000 }
3547 * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3548 * The feedback for the output is the dummy input.
3550 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3551 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3552 .ifnum = QUIRK_ANY_INTERFACE,
3553 .type = QUIRK_COMPOSITE,
3554 .data = (const struct snd_usb_audio_quirk[]) {
3557 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3558 .data = &(const struct audioformat) {
3559 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3565 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3566 USB_ENDPOINT_SYNC_ASYNC,
3567 .rates = SNDRV_PCM_RATE_44100,
3571 .rate_table = (unsigned int[]) { 44100 }
3576 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3577 .data = &(const struct audioformat) {
3578 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3584 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3585 USB_ENDPOINT_SYNC_ASYNC|
3586 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3587 .rates = SNDRV_PCM_RATE_44100,
3591 .rate_table = (unsigned int[]) { 44100 }
3603 * Pioneer DJ DJM-900NXS2
3604 * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE
3606 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a),
3607 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3608 .ifnum = QUIRK_ANY_INTERFACE,
3609 .type = QUIRK_COMPOSITE,
3610 .data = (const struct snd_usb_audio_quirk[]) {
3613 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3614 .data = &(const struct audioformat) {
3615 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3621 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3622 USB_ENDPOINT_SYNC_ASYNC,
3623 .rates = SNDRV_PCM_RATE_44100|
3624 SNDRV_PCM_RATE_48000|
3625 SNDRV_PCM_RATE_96000,
3629 .rate_table = (unsigned int[]) {
3636 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3637 .data = &(const struct audioformat) {
3638 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3644 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3645 USB_ENDPOINT_SYNC_ASYNC|
3646 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3647 .rates = SNDRV_PCM_RATE_44100|
3648 SNDRV_PCM_RATE_48000|
3649 SNDRV_PCM_RATE_96000,
3653 .rate_table = (unsigned int[]) {
3666 * MacroSilicon MS2100/MS2106 based AV capture cards
3668 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3669 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if
3670 * they pretend to be 96kHz mono as a workaround for stereo being broken
3673 * They also have an issue with initial stream alignment that causes the
3674 * channels to be swapped and out of phase, which is dealt with in quirks.c.
3677 USB_AUDIO_DEVICE(0x534d, 0x0021),
3678 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3679 .vendor_name = "MacroSilicon",
3680 .product_name = "MS210x",
3681 .ifnum = QUIRK_ANY_INTERFACE,
3682 .type = QUIRK_COMPOSITE,
3683 .data = &(const struct snd_usb_audio_quirk[]) {
3686 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
3690 .type = QUIRK_AUDIO_STANDARD_MIXER,
3694 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3695 .data = &(const struct audioformat) {
3696 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3703 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3704 USB_ENDPOINT_SYNC_ASYNC,
3705 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3718 * MacroSilicon MS2109 based HDMI capture cards
3720 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3721 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if
3722 * they pretend to be 96kHz mono as a workaround for stereo being broken
3725 * They also have an issue with initial stream alignment that causes the
3726 * channels to be swapped and out of phase, which is dealt with in quirks.c.
3729 USB_AUDIO_DEVICE(0x534d, 0x2109),
3730 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3731 .vendor_name = "MacroSilicon",
3732 .product_name = "MS2109",
3733 .ifnum = QUIRK_ANY_INTERFACE,
3734 .type = QUIRK_COMPOSITE,
3735 .data = &(const struct snd_usb_audio_quirk[]) {
3738 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
3742 .type = QUIRK_AUDIO_STANDARD_MIXER,
3746 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3747 .data = &(const struct audioformat) {
3748 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3755 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3756 USB_ENDPOINT_SYNC_ASYNC,
3757 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3771 * Change order of interfaces loaded
3773 USB_DEVICE(0x1395, 0x0300),
3774 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3775 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3776 .ifnum = QUIRK_ANY_INTERFACE,
3777 .type = QUIRK_COMPOSITE,
3778 .data = &(const struct snd_usb_audio_quirk[]) {
3782 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3787 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3792 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3801 /* Advanced modes of the Mythware XA001AU.
3802 * For the standard mode, Mythware XA001AU has ID ffad:a001
3804 USB_DEVICE_VENDOR_SPEC(0xffad, 0xa001),
3805 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3806 .vendor_name = "Mythware",
3807 .product_name = "XA001AU",
3808 .ifnum = QUIRK_ANY_INTERFACE,
3809 .type = QUIRK_COMPOSITE,
3810 .data = (const struct snd_usb_audio_quirk[]) {
3813 .type = QUIRK_IGNORE_INTERFACE,
3817 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3821 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3830 #undef USB_DEVICE_VENDOR_SPEC
3831 #undef USB_AUDIO_DEVICE