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 #define QUIRK_RENAME_DEVICE(_vendor, _device) \
29 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
30 .vendor_name = _vendor, \
31 .product_name = _device, \
32 .ifnum = QUIRK_NO_INTERFACE \
35 #define QUIRK_DEVICE_PROFILE(_vendor, _device, _profile) \
36 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
37 .vendor_name = _vendor, \
38 .product_name = _device, \
39 .profile_name = _profile, \
40 .ifnum = QUIRK_NO_INTERFACE \
45 USB_DEVICE(0x0403, 0xb8d8),
46 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
47 /* .vendor_name = "STARR LABS", */
48 /* .product_name = "Starr Labs MIDI USB device", */
50 .type = QUIRK_MIDI_FTDI
56 USB_DEVICE(0x041e, 0x0005),
57 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
59 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
60 .data = &(const struct audioformat) {
61 .formats = SNDRV_PCM_FMTBIT_S16_LE,
67 .ep_attr = USB_ENDPOINT_XFER_ISOC,
69 .rates = SNDRV_PCM_RATE_CONTINUOUS,
76 /* Creative/E-Mu devices */
78 USB_DEVICE(0x041e, 0x3010),
79 QUIRK_RENAME_DEVICE("Creative Labs", "Sound Blaster MP3+")
81 /* Creative/Toshiba Multimedia Center SB-0500 */
83 USB_DEVICE(0x041e, 0x3048),
84 QUIRK_RENAME_DEVICE("Toshiba", "SB-0500")
88 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
91 .bInterfaceClass = USB_CLASS_AUDIO,
95 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
98 .bInterfaceClass = USB_CLASS_AUDIO,
101 /* E-Mu Tracker Pre */
102 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
105 .bInterfaceClass = USB_CLASS_AUDIO,
109 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
112 .bInterfaceClass = USB_CLASS_AUDIO,
117 * When not ignored, causes instability issues for some users, forcing them to
118 * blacklist the entire module.
121 USB_DEVICE(0x0424, 0xb832),
122 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
123 .vendor_name = "Standard Microsystems Corp.",
124 .product_name = "HP Wireless Audio",
125 .ifnum = QUIRK_ANY_INTERFACE,
126 .type = QUIRK_COMPOSITE,
127 .data = (const struct snd_usb_audio_quirk[]) {
131 .type = QUIRK_IGNORE_INTERFACE,
136 .type = QUIRK_IGNORE_INTERFACE,
141 .type = QUIRK_IGNORE_INTERFACE,
143 /* HID Device, .ifnum = 3 */
152 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
153 * class matches do not take effect without an explicit ID match.
156 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
157 USB_DEVICE_ID_MATCH_INT_CLASS |
158 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
161 .bInterfaceClass = USB_CLASS_AUDIO,
162 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
165 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
166 USB_DEVICE_ID_MATCH_INT_CLASS |
167 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
170 .bInterfaceClass = USB_CLASS_AUDIO,
171 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
174 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
175 USB_DEVICE_ID_MATCH_INT_CLASS |
176 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
179 .bInterfaceClass = USB_CLASS_AUDIO,
180 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
183 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
184 USB_DEVICE_ID_MATCH_INT_CLASS |
185 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
188 .bInterfaceClass = USB_CLASS_AUDIO,
189 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
192 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
193 USB_DEVICE_ID_MATCH_INT_CLASS |
194 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
197 .bInterfaceClass = USB_CLASS_AUDIO,
198 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
201 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
202 USB_DEVICE_ID_MATCH_INT_CLASS |
203 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
206 .bInterfaceClass = USB_CLASS_AUDIO,
207 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
210 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
211 USB_DEVICE_ID_MATCH_INT_CLASS |
212 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
215 .bInterfaceClass = USB_CLASS_AUDIO,
216 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
217 QUIRK_RENAME_DEVICE("Logitech, Inc.", "QuickCam Pro 9000")
224 #define YAMAHA_DEVICE(id, name) { \
225 USB_DEVICE(0x0499, id), \
226 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
227 .vendor_name = "Yamaha", \
228 .product_name = name, \
229 .ifnum = QUIRK_ANY_INTERFACE, \
230 .type = QUIRK_MIDI_YAMAHA \
233 #define YAMAHA_INTERFACE(id, intf, name) { \
234 USB_DEVICE_VENDOR_SPEC(0x0499, id), \
235 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
236 .vendor_name = "Yamaha", \
237 .product_name = name, \
239 .type = QUIRK_MIDI_YAMAHA \
242 YAMAHA_DEVICE(0x1000, "UX256"),
243 YAMAHA_DEVICE(0x1001, "MU1000"),
244 YAMAHA_DEVICE(0x1002, "MU2000"),
245 YAMAHA_DEVICE(0x1003, "MU500"),
246 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
247 YAMAHA_DEVICE(0x1005, "MOTIF6"),
248 YAMAHA_DEVICE(0x1006, "MOTIF7"),
249 YAMAHA_DEVICE(0x1007, "MOTIF8"),
250 YAMAHA_DEVICE(0x1008, "UX96"),
251 YAMAHA_DEVICE(0x1009, "UX16"),
252 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
253 YAMAHA_DEVICE(0x100c, "UC-MX"),
254 YAMAHA_DEVICE(0x100d, "UC-KX"),
255 YAMAHA_DEVICE(0x100e, "S08"),
256 YAMAHA_DEVICE(0x100f, "CLP-150"),
257 YAMAHA_DEVICE(0x1010, "CLP-170"),
258 YAMAHA_DEVICE(0x1011, "P-250"),
259 YAMAHA_DEVICE(0x1012, "TYROS"),
260 YAMAHA_DEVICE(0x1013, "PF-500"),
261 YAMAHA_DEVICE(0x1014, "S90"),
262 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
263 YAMAHA_DEVICE(0x1016, "MDP-5"),
264 YAMAHA_DEVICE(0x1017, "CVP-204"),
265 YAMAHA_DEVICE(0x1018, "CVP-206"),
266 YAMAHA_DEVICE(0x1019, "CVP-208"),
267 YAMAHA_DEVICE(0x101a, "CVP-210"),
268 YAMAHA_DEVICE(0x101b, "PSR-1100"),
269 YAMAHA_DEVICE(0x101c, "PSR-2100"),
270 YAMAHA_DEVICE(0x101d, "CLP-175"),
271 YAMAHA_DEVICE(0x101e, "PSR-K1"),
272 YAMAHA_DEVICE(0x101f, "EZ-J24"),
273 YAMAHA_DEVICE(0x1020, "EZ-250i"),
274 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
275 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
276 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
277 YAMAHA_DEVICE(0x1024, "CVP-301"),
278 YAMAHA_DEVICE(0x1025, "CVP-303"),
279 YAMAHA_DEVICE(0x1026, "CVP-305"),
280 YAMAHA_DEVICE(0x1027, "CVP-307"),
281 YAMAHA_DEVICE(0x1028, "CVP-309"),
282 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
283 YAMAHA_DEVICE(0x102a, "PSR-1500"),
284 YAMAHA_DEVICE(0x102b, "PSR-3000"),
285 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
286 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
287 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
288 YAMAHA_DEVICE(0x1032, "DGX-305"),
289 YAMAHA_DEVICE(0x1033, "DGX-505"),
290 YAMAHA_DEVICE(0x1034, NULL),
291 YAMAHA_DEVICE(0x1035, NULL),
292 YAMAHA_DEVICE(0x1036, NULL),
293 YAMAHA_DEVICE(0x1037, NULL),
294 YAMAHA_DEVICE(0x1038, NULL),
295 YAMAHA_DEVICE(0x1039, NULL),
296 YAMAHA_DEVICE(0x103a, NULL),
297 YAMAHA_DEVICE(0x103b, NULL),
298 YAMAHA_DEVICE(0x103c, NULL),
299 YAMAHA_DEVICE(0x103d, NULL),
300 YAMAHA_DEVICE(0x103e, NULL),
301 YAMAHA_DEVICE(0x103f, NULL),
302 YAMAHA_DEVICE(0x1040, NULL),
303 YAMAHA_DEVICE(0x1041, NULL),
304 YAMAHA_DEVICE(0x1042, NULL),
305 YAMAHA_DEVICE(0x1043, NULL),
306 YAMAHA_DEVICE(0x1044, NULL),
307 YAMAHA_DEVICE(0x1045, NULL),
308 YAMAHA_INTERFACE(0x104e, 0, NULL),
309 YAMAHA_DEVICE(0x104f, NULL),
310 YAMAHA_DEVICE(0x1050, NULL),
311 YAMAHA_DEVICE(0x1051, NULL),
312 YAMAHA_DEVICE(0x1052, NULL),
313 YAMAHA_INTERFACE(0x1053, 0, NULL),
314 YAMAHA_INTERFACE(0x1054, 0, NULL),
315 YAMAHA_DEVICE(0x1055, NULL),
316 YAMAHA_DEVICE(0x1056, NULL),
317 YAMAHA_DEVICE(0x1057, NULL),
318 YAMAHA_DEVICE(0x1058, NULL),
319 YAMAHA_DEVICE(0x1059, NULL),
320 YAMAHA_DEVICE(0x105a, NULL),
321 YAMAHA_DEVICE(0x105b, NULL),
322 YAMAHA_DEVICE(0x105c, NULL),
323 YAMAHA_DEVICE(0x105d, NULL),
325 USB_DEVICE(0x0499, 0x1503),
326 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
327 /* .vendor_name = "Yamaha", */
328 /* .product_name = "MOX6/MOX8", */
329 .ifnum = QUIRK_ANY_INTERFACE,
330 .type = QUIRK_COMPOSITE,
331 .data = (const struct snd_usb_audio_quirk[]) {
334 .type = QUIRK_AUDIO_STANDARD_INTERFACE
338 .type = QUIRK_AUDIO_STANDARD_INTERFACE
342 .type = QUIRK_MIDI_YAMAHA
351 USB_DEVICE(0x0499, 0x1507),
352 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
353 /* .vendor_name = "Yamaha", */
354 /* .product_name = "THR10", */
355 .ifnum = QUIRK_ANY_INTERFACE,
356 .type = QUIRK_COMPOSITE,
357 .data = (const struct snd_usb_audio_quirk[]) {
360 .type = QUIRK_AUDIO_STANDARD_INTERFACE
364 .type = QUIRK_AUDIO_STANDARD_INTERFACE
368 .type = QUIRK_MIDI_YAMAHA
377 USB_DEVICE(0x0499, 0x1509),
378 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
379 /* .vendor_name = "Yamaha", */
380 /* .product_name = "Steinberg UR22", */
381 .ifnum = QUIRK_ANY_INTERFACE,
382 .type = QUIRK_COMPOSITE,
383 .data = (const struct snd_usb_audio_quirk[]) {
386 .type = QUIRK_AUDIO_STANDARD_INTERFACE
390 .type = QUIRK_AUDIO_STANDARD_INTERFACE
394 .type = QUIRK_MIDI_YAMAHA
398 .type = QUIRK_IGNORE_INTERFACE
407 USB_DEVICE(0x0499, 0x150a),
408 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
409 /* .vendor_name = "Yamaha", */
410 /* .product_name = "THR5A", */
411 .ifnum = QUIRK_ANY_INTERFACE,
412 .type = QUIRK_COMPOSITE,
413 .data = (const struct snd_usb_audio_quirk[]) {
416 .type = QUIRK_AUDIO_STANDARD_INTERFACE
420 .type = QUIRK_AUDIO_STANDARD_INTERFACE
424 .type = QUIRK_MIDI_YAMAHA
433 USB_DEVICE(0x0499, 0x150c),
434 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
435 /* .vendor_name = "Yamaha", */
436 /* .product_name = "THR10C", */
437 .ifnum = QUIRK_ANY_INTERFACE,
438 .type = QUIRK_COMPOSITE,
439 .data = (const struct snd_usb_audio_quirk[]) {
442 .type = QUIRK_AUDIO_STANDARD_INTERFACE
446 .type = QUIRK_AUDIO_STANDARD_INTERFACE
450 .type = QUIRK_MIDI_YAMAHA
458 YAMAHA_DEVICE(0x2000, "DGP-7"),
459 YAMAHA_DEVICE(0x2001, "DGP-5"),
460 YAMAHA_DEVICE(0x2002, NULL),
461 YAMAHA_DEVICE(0x2003, NULL),
462 YAMAHA_DEVICE(0x5000, "CS1D"),
463 YAMAHA_DEVICE(0x5001, "DSP1D"),
464 YAMAHA_DEVICE(0x5002, "DME32"),
465 YAMAHA_DEVICE(0x5003, "DM2000"),
466 YAMAHA_DEVICE(0x5004, "02R96"),
467 YAMAHA_DEVICE(0x5005, "ACU16-C"),
468 YAMAHA_DEVICE(0x5006, "NHB32-C"),
469 YAMAHA_DEVICE(0x5007, "DM1000"),
470 YAMAHA_DEVICE(0x5008, "01V96"),
471 YAMAHA_DEVICE(0x5009, "SPX2000"),
472 YAMAHA_DEVICE(0x500a, "PM5D"),
473 YAMAHA_DEVICE(0x500b, "DME64N"),
474 YAMAHA_DEVICE(0x500c, "DME24N"),
475 YAMAHA_DEVICE(0x500d, NULL),
476 YAMAHA_DEVICE(0x500e, NULL),
477 YAMAHA_DEVICE(0x500f, NULL),
478 YAMAHA_DEVICE(0x7000, "DTX"),
479 YAMAHA_DEVICE(0x7010, "UB99"),
481 #undef YAMAHA_INTERFACE
482 /* this catches most recent vendor-specific Yamaha devices */
484 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
485 USB_DEVICE_ID_MATCH_INT_CLASS,
487 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
488 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
489 .ifnum = QUIRK_ANY_INTERFACE,
490 .type = QUIRK_AUTODETECT
495 * Roland/RolandED/Edirol/BOSS devices
498 USB_DEVICE(0x0582, 0x0000),
499 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
500 .vendor_name = "Roland",
501 .product_name = "UA-100",
502 .ifnum = QUIRK_ANY_INTERFACE,
503 .type = QUIRK_COMPOSITE,
504 .data = (const struct snd_usb_audio_quirk[]) {
507 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
508 .data = & (const struct audioformat) {
509 .formats = SNDRV_PCM_FMTBIT_S16_LE,
517 .rates = SNDRV_PCM_RATE_CONTINUOUS,
524 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
525 .data = & (const struct audioformat) {
526 .formats = SNDRV_PCM_FMTBIT_S16_LE,
531 .attributes = UAC_EP_CS_ATTR_FILL_MAX,
534 .rates = SNDRV_PCM_RATE_CONTINUOUS,
541 .type = QUIRK_MIDI_FIXED_ENDPOINT,
542 .data = & (const struct snd_usb_midi_endpoint_info) {
543 .out_cables = 0x0007,
554 USB_DEVICE(0x0582, 0x0002),
555 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
556 .vendor_name = "EDIROL",
557 .product_name = "UM-4",
558 .ifnum = QUIRK_ANY_INTERFACE,
559 .type = QUIRK_COMPOSITE,
560 .data = (const struct snd_usb_audio_quirk[]) {
563 .type = QUIRK_IGNORE_INTERFACE
567 .type = QUIRK_IGNORE_INTERFACE
571 .type = QUIRK_MIDI_FIXED_ENDPOINT,
572 .data = & (const struct snd_usb_midi_endpoint_info) {
573 .out_cables = 0x000f,
584 USB_DEVICE(0x0582, 0x0003),
585 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
586 .vendor_name = "Roland",
587 .product_name = "SC-8850",
588 .ifnum = QUIRK_ANY_INTERFACE,
589 .type = QUIRK_COMPOSITE,
590 .data = (const struct snd_usb_audio_quirk[]) {
593 .type = QUIRK_IGNORE_INTERFACE
597 .type = QUIRK_IGNORE_INTERFACE
601 .type = QUIRK_MIDI_FIXED_ENDPOINT,
602 .data = & (const struct snd_usb_midi_endpoint_info) {
603 .out_cables = 0x003f,
614 USB_DEVICE(0x0582, 0x0004),
615 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
616 .vendor_name = "Roland",
617 .product_name = "U-8",
618 .ifnum = QUIRK_ANY_INTERFACE,
619 .type = QUIRK_COMPOSITE,
620 .data = (const struct snd_usb_audio_quirk[]) {
623 .type = QUIRK_IGNORE_INTERFACE
627 .type = QUIRK_IGNORE_INTERFACE
631 .type = QUIRK_MIDI_FIXED_ENDPOINT,
632 .data = & (const struct snd_usb_midi_endpoint_info) {
633 .out_cables = 0x0005,
644 /* Has ID 0x0099 when not in "Advanced Driver" mode.
645 * The UM-2EX has only one input, but we cannot detect this. */
646 USB_DEVICE(0x0582, 0x0005),
647 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
648 .vendor_name = "EDIROL",
649 .product_name = "UM-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 = 0x0003,
676 USB_DEVICE(0x0582, 0x0007),
677 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
678 .vendor_name = "Roland",
679 .product_name = "SC-8820",
680 .ifnum = QUIRK_ANY_INTERFACE,
681 .type = QUIRK_COMPOSITE,
682 .data = (const struct snd_usb_audio_quirk[]) {
685 .type = QUIRK_IGNORE_INTERFACE
689 .type = QUIRK_IGNORE_INTERFACE
693 .type = QUIRK_MIDI_FIXED_ENDPOINT,
694 .data = & (const struct snd_usb_midi_endpoint_info) {
695 .out_cables = 0x0013,
706 USB_DEVICE(0x0582, 0x0008),
707 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
708 .vendor_name = "Roland",
709 .product_name = "PC-300",
710 .ifnum = QUIRK_ANY_INTERFACE,
711 .type = QUIRK_COMPOSITE,
712 .data = (const struct snd_usb_audio_quirk[]) {
715 .type = QUIRK_IGNORE_INTERFACE
719 .type = QUIRK_IGNORE_INTERFACE
723 .type = QUIRK_MIDI_FIXED_ENDPOINT,
724 .data = & (const struct snd_usb_midi_endpoint_info) {
725 .out_cables = 0x0001,
736 /* has ID 0x009d when not in "Advanced Driver" mode */
737 USB_DEVICE(0x0582, 0x0009),
738 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
739 .vendor_name = "EDIROL",
740 .product_name = "UM-1",
741 .ifnum = QUIRK_ANY_INTERFACE,
742 .type = QUIRK_COMPOSITE,
743 .data = (const struct snd_usb_audio_quirk[]) {
746 .type = QUIRK_IGNORE_INTERFACE
750 .type = QUIRK_IGNORE_INTERFACE
754 .type = QUIRK_MIDI_FIXED_ENDPOINT,
755 .data = & (const struct snd_usb_midi_endpoint_info) {
756 .out_cables = 0x0001,
767 USB_DEVICE(0x0582, 0x000b),
768 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
769 .vendor_name = "Roland",
770 .product_name = "SK-500",
771 .ifnum = QUIRK_ANY_INTERFACE,
772 .type = QUIRK_COMPOSITE,
773 .data = (const struct snd_usb_audio_quirk[]) {
776 .type = QUIRK_IGNORE_INTERFACE
780 .type = QUIRK_IGNORE_INTERFACE
784 .type = QUIRK_MIDI_FIXED_ENDPOINT,
785 .data = & (const struct snd_usb_midi_endpoint_info) {
786 .out_cables = 0x0013,
797 /* thanks to Emiliano Grilli <emillo@libero.it>
798 * for helping researching this data */
799 USB_DEVICE(0x0582, 0x000c),
800 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
801 .vendor_name = "Roland",
802 .product_name = "SC-D70",
803 .ifnum = QUIRK_ANY_INTERFACE,
804 .type = QUIRK_COMPOSITE,
805 .data = (const struct snd_usb_audio_quirk[]) {
808 .type = QUIRK_AUDIO_STANDARD_INTERFACE
812 .type = QUIRK_AUDIO_STANDARD_INTERFACE
816 .type = QUIRK_MIDI_FIXED_ENDPOINT,
817 .data = & (const struct snd_usb_midi_endpoint_info) {
818 .out_cables = 0x0007,
829 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
830 * If the advanced mode switch at the back of the unit is off, the
831 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
832 * but offers only 16-bit PCM.
833 * In advanced mode, the UA-5 will output S24_3LE samples (two
834 * channels) at the rate indicated on the front switch, including
835 * the 96kHz sample rate.
837 USB_DEVICE(0x0582, 0x0010),
838 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
839 .vendor_name = "EDIROL",
840 .product_name = "UA-5",
841 .ifnum = QUIRK_ANY_INTERFACE,
842 .type = QUIRK_COMPOSITE,
843 .data = (const struct snd_usb_audio_quirk[]) {
846 .type = QUIRK_AUDIO_STANDARD_INTERFACE
850 .type = QUIRK_AUDIO_STANDARD_INTERFACE
859 /* has ID 0x0013 when not in "Advanced Driver" mode */
860 USB_DEVICE(0x0582, 0x0012),
861 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
862 .vendor_name = "Roland",
863 .product_name = "XV-5050",
865 .type = QUIRK_MIDI_FIXED_ENDPOINT,
866 .data = & (const struct snd_usb_midi_endpoint_info) {
867 .out_cables = 0x0001,
873 /* has ID 0x0015 when not in "Advanced Driver" mode */
874 USB_DEVICE(0x0582, 0x0014),
875 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
876 .vendor_name = "EDIROL",
877 .product_name = "UM-880",
879 .type = QUIRK_MIDI_FIXED_ENDPOINT,
880 .data = & (const struct snd_usb_midi_endpoint_info) {
881 .out_cables = 0x01ff,
887 /* has ID 0x0017 when not in "Advanced Driver" mode */
888 USB_DEVICE(0x0582, 0x0016),
889 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
890 .vendor_name = "EDIROL",
891 .product_name = "SD-90",
892 .ifnum = QUIRK_ANY_INTERFACE,
893 .type = QUIRK_COMPOSITE,
894 .data = (const struct snd_usb_audio_quirk[]) {
897 .type = QUIRK_AUDIO_STANDARD_INTERFACE
901 .type = QUIRK_AUDIO_STANDARD_INTERFACE
905 .type = QUIRK_MIDI_FIXED_ENDPOINT,
906 .data = & (const struct snd_usb_midi_endpoint_info) {
907 .out_cables = 0x000f,
918 /* has ID 0x001c when not in "Advanced Driver" mode */
919 USB_DEVICE(0x0582, 0x001b),
920 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
921 .vendor_name = "Roland",
922 .product_name = "MMP-2",
923 .ifnum = QUIRK_ANY_INTERFACE,
924 .type = QUIRK_COMPOSITE,
925 .data = (const struct snd_usb_audio_quirk[]) {
928 .type = QUIRK_IGNORE_INTERFACE
932 .type = QUIRK_IGNORE_INTERFACE
936 .type = QUIRK_MIDI_FIXED_ENDPOINT,
937 .data = & (const struct snd_usb_midi_endpoint_info) {
938 .out_cables = 0x0001,
949 /* has ID 0x001e when not in "Advanced Driver" mode */
950 USB_DEVICE(0x0582, 0x001d),
951 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
952 .vendor_name = "Roland",
953 .product_name = "V-SYNTH",
955 .type = QUIRK_MIDI_FIXED_ENDPOINT,
956 .data = & (const struct snd_usb_midi_endpoint_info) {
957 .out_cables = 0x0001,
963 /* has ID 0x0024 when not in "Advanced Driver" mode */
964 USB_DEVICE(0x0582, 0x0023),
965 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
966 .vendor_name = "EDIROL",
967 .product_name = "UM-550",
969 .type = QUIRK_MIDI_FIXED_ENDPOINT,
970 .data = & (const struct snd_usb_midi_endpoint_info) {
971 .out_cables = 0x003f,
978 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
979 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
982 USB_DEVICE(0x0582, 0x0025),
983 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
984 .vendor_name = "EDIROL",
985 .product_name = "UA-20",
986 .ifnum = QUIRK_ANY_INTERFACE,
987 .type = QUIRK_COMPOSITE,
988 .data = (const struct snd_usb_audio_quirk[]) {
991 .type = QUIRK_IGNORE_INTERFACE
995 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
996 .data = & (const struct audioformat) {
997 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
1005 .rates = SNDRV_PCM_RATE_CONTINUOUS,
1012 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1013 .data = & (const struct audioformat) {
1014 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
1022 .rates = SNDRV_PCM_RATE_CONTINUOUS,
1029 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1030 .data = & (const struct snd_usb_midi_endpoint_info) {
1031 .out_cables = 0x0001,
1042 /* has ID 0x0028 when not in "Advanced Driver" mode */
1043 USB_DEVICE(0x0582, 0x0027),
1044 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1045 .vendor_name = "EDIROL",
1046 .product_name = "SD-20",
1048 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1049 .data = & (const struct snd_usb_midi_endpoint_info) {
1050 .out_cables = 0x0003,
1056 /* has ID 0x002a when not in "Advanced Driver" mode */
1057 USB_DEVICE(0x0582, 0x0029),
1058 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1059 .vendor_name = "EDIROL",
1060 .product_name = "SD-80",
1062 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1063 .data = & (const struct snd_usb_midi_endpoint_info) {
1064 .out_cables = 0x000f,
1070 * This quirk is for the "Advanced" modes of the Edirol UA-700.
1071 * If the sample format switch is not in an advanced setting, the
1072 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
1073 * but offers only 16-bit PCM and no MIDI.
1075 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
1076 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1077 .vendor_name = "EDIROL",
1078 .product_name = "UA-700",
1079 .ifnum = QUIRK_ANY_INTERFACE,
1080 .type = QUIRK_COMPOSITE,
1081 .data = (const struct snd_usb_audio_quirk[]) {
1084 .type = QUIRK_AUDIO_EDIROL_UAXX
1088 .type = QUIRK_AUDIO_EDIROL_UAXX
1092 .type = QUIRK_AUDIO_EDIROL_UAXX
1101 /* has ID 0x002e when not in "Advanced Driver" mode */
1102 USB_DEVICE(0x0582, 0x002d),
1103 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1104 .vendor_name = "Roland",
1105 .product_name = "XV-2020",
1107 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1108 .data = & (const struct snd_usb_midi_endpoint_info) {
1109 .out_cables = 0x0001,
1115 /* has ID 0x0030 when not in "Advanced Driver" mode */
1116 USB_DEVICE(0x0582, 0x002f),
1117 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1118 .vendor_name = "Roland",
1119 .product_name = "VariOS",
1121 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1122 .data = & (const struct snd_usb_midi_endpoint_info) {
1123 .out_cables = 0x0007,
1129 /* has ID 0x0034 when not in "Advanced Driver" mode */
1130 USB_DEVICE(0x0582, 0x0033),
1131 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1132 .vendor_name = "EDIROL",
1133 .product_name = "PCR",
1135 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1136 .data = & (const struct snd_usb_midi_endpoint_info) {
1137 .out_cables = 0x0003,
1144 * Has ID 0x0038 when not in "Advanced Driver" mode;
1145 * later revisions use IDs 0x0054 and 0x00a2.
1147 USB_DEVICE(0x0582, 0x0037),
1148 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1149 .vendor_name = "Roland",
1150 .product_name = "Digital Piano",
1152 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1153 .data = & (const struct snd_usb_midi_endpoint_info) {
1154 .out_cables = 0x0001,
1161 * This quirk is for the "Advanced Driver" mode. If off, the GS-10
1162 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1165 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1166 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1167 .vendor_name = "BOSS",
1168 .product_name = "GS-10",
1169 .ifnum = QUIRK_ANY_INTERFACE,
1170 .type = QUIRK_COMPOSITE,
1171 .data = & (const struct snd_usb_audio_quirk[]) {
1174 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1178 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1182 .type = QUIRK_MIDI_STANDARD_INTERFACE
1191 /* has ID 0x0041 when not in "Advanced Driver" mode */
1192 USB_DEVICE(0x0582, 0x0040),
1193 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1194 .vendor_name = "Roland",
1195 .product_name = "GI-20",
1197 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1198 .data = & (const struct snd_usb_midi_endpoint_info) {
1199 .out_cables = 0x0001,
1205 /* has ID 0x0043 when not in "Advanced Driver" mode */
1206 USB_DEVICE(0x0582, 0x0042),
1207 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1208 .vendor_name = "Roland",
1209 .product_name = "RS-70",
1211 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1212 .data = & (const struct snd_usb_midi_endpoint_info) {
1213 .out_cables = 0x0001,
1219 /* has ID 0x0049 when not in "Advanced Driver" mode */
1220 USB_DEVICE(0x0582, 0x0047),
1221 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1222 /* .vendor_name = "EDIROL", */
1223 /* .product_name = "UR-80", */
1224 .ifnum = QUIRK_ANY_INTERFACE,
1225 .type = QUIRK_COMPOSITE,
1226 .data = (const struct snd_usb_audio_quirk[]) {
1227 /* in the 96 kHz modes, only interface 1 is there */
1230 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1234 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1243 /* has ID 0x004a when not in "Advanced Driver" mode */
1244 USB_DEVICE(0x0582, 0x0048),
1245 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1246 /* .vendor_name = "EDIROL", */
1247 /* .product_name = "UR-80", */
1249 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1250 .data = & (const struct snd_usb_midi_endpoint_info) {
1251 .out_cables = 0x0003,
1257 /* has ID 0x004e when not in "Advanced Driver" mode */
1258 USB_DEVICE(0x0582, 0x004c),
1259 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1260 .vendor_name = "EDIROL",
1261 .product_name = "PCR-A",
1262 .ifnum = QUIRK_ANY_INTERFACE,
1263 .type = QUIRK_COMPOSITE,
1264 .data = (const struct snd_usb_audio_quirk[]) {
1267 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1271 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1280 /* has ID 0x004f when not in "Advanced Driver" mode */
1281 USB_DEVICE(0x0582, 0x004d),
1282 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1283 .vendor_name = "EDIROL",
1284 .product_name = "PCR-A",
1286 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1287 .data = & (const struct snd_usb_midi_endpoint_info) {
1288 .out_cables = 0x0003,
1295 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1296 * is standard compliant, but has only 16-bit PCM.
1298 USB_DEVICE(0x0582, 0x0050),
1299 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1300 .vendor_name = "EDIROL",
1301 .product_name = "UA-3FX",
1302 .ifnum = QUIRK_ANY_INTERFACE,
1303 .type = QUIRK_COMPOSITE,
1304 .data = (const struct snd_usb_audio_quirk[]) {
1307 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1311 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1320 USB_DEVICE(0x0582, 0x0052),
1321 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1322 .vendor_name = "EDIROL",
1323 .product_name = "UM-1SX",
1325 .type = QUIRK_MIDI_STANDARD_INTERFACE
1329 USB_DEVICE(0x0582, 0x0060),
1330 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1331 .vendor_name = "Roland",
1332 .product_name = "EXR Series",
1334 .type = QUIRK_MIDI_STANDARD_INTERFACE
1338 /* has ID 0x0066 when not in "Advanced Driver" mode */
1339 USB_DEVICE(0x0582, 0x0064),
1340 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1341 /* .vendor_name = "EDIROL", */
1342 /* .product_name = "PCR-1", */
1343 .ifnum = QUIRK_ANY_INTERFACE,
1344 .type = QUIRK_COMPOSITE,
1345 .data = (const struct snd_usb_audio_quirk[]) {
1348 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1352 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1361 /* has ID 0x0067 when not in "Advanced Driver" mode */
1362 USB_DEVICE(0x0582, 0x0065),
1363 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1364 /* .vendor_name = "EDIROL", */
1365 /* .product_name = "PCR-1", */
1367 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1368 .data = & (const struct snd_usb_midi_endpoint_info) {
1369 .out_cables = 0x0001,
1375 /* has ID 0x006e when not in "Advanced Driver" mode */
1376 USB_DEVICE(0x0582, 0x006d),
1377 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1378 .vendor_name = "Roland",
1379 .product_name = "FANTOM-X",
1381 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1382 .data = & (const struct snd_usb_midi_endpoint_info) {
1383 .out_cables = 0x0001,
1389 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1390 * If the switch is not in an advanced setting, the UA-25 has
1391 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1392 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1394 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1395 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1396 .vendor_name = "EDIROL",
1397 .product_name = "UA-25",
1398 .ifnum = QUIRK_ANY_INTERFACE,
1399 .type = QUIRK_COMPOSITE,
1400 .data = (const struct snd_usb_audio_quirk[]) {
1403 .type = QUIRK_AUDIO_EDIROL_UAXX
1407 .type = QUIRK_AUDIO_EDIROL_UAXX
1411 .type = QUIRK_AUDIO_EDIROL_UAXX
1420 /* has ID 0x0076 when not in "Advanced Driver" mode */
1421 USB_DEVICE(0x0582, 0x0075),
1422 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1423 .vendor_name = "BOSS",
1424 .product_name = "DR-880",
1426 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1427 .data = & (const struct snd_usb_midi_endpoint_info) {
1428 .out_cables = 0x0001,
1434 /* has ID 0x007b when not in "Advanced Driver" mode */
1435 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1436 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1437 .vendor_name = "Roland",
1438 /* "RD" or "RD-700SX"? */
1440 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1441 .data = & (const struct snd_usb_midi_endpoint_info) {
1442 .out_cables = 0x0003,
1448 /* has ID 0x0081 when not in "Advanced Driver" mode */
1449 USB_DEVICE(0x0582, 0x0080),
1450 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1451 .vendor_name = "Roland",
1452 .product_name = "G-70",
1454 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1455 .data = & (const struct snd_usb_midi_endpoint_info) {
1456 .out_cables = 0x0001,
1462 /* has ID 0x008c when not in "Advanced Driver" mode */
1463 USB_DEVICE(0x0582, 0x008b),
1464 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1465 .vendor_name = "EDIROL",
1466 .product_name = "PC-50",
1468 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1469 .data = & (const struct snd_usb_midi_endpoint_info) {
1470 .out_cables = 0x0001,
1477 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1478 * is standard compliant, but has only 16-bit PCM and no MIDI.
1480 USB_DEVICE(0x0582, 0x00a3),
1481 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1482 .vendor_name = "EDIROL",
1483 .product_name = "UA-4FX",
1484 .ifnum = QUIRK_ANY_INTERFACE,
1485 .type = QUIRK_COMPOSITE,
1486 .data = (const struct snd_usb_audio_quirk[]) {
1489 .type = QUIRK_AUDIO_EDIROL_UAXX
1493 .type = QUIRK_AUDIO_EDIROL_UAXX
1497 .type = QUIRK_AUDIO_EDIROL_UAXX
1507 USB_DEVICE(0x0582, 0x00c4),
1508 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1509 .ifnum = QUIRK_ANY_INTERFACE,
1510 .type = QUIRK_COMPOSITE,
1511 .data = (const struct snd_usb_audio_quirk[]) {
1514 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1518 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1522 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1523 .data = & (const struct snd_usb_midi_endpoint_info) {
1524 .out_cables = 0x0001,
1535 /* Advanced modes of the Edirol UA-25EX.
1536 * For the standard mode, UA-25EX has ID 0582:00e7, which
1537 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1539 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1540 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1541 .vendor_name = "EDIROL",
1542 .product_name = "UA-25EX",
1543 .ifnum = QUIRK_ANY_INTERFACE,
1544 .type = QUIRK_COMPOSITE,
1545 .data = (const struct snd_usb_audio_quirk[]) {
1548 .type = QUIRK_AUDIO_EDIROL_UAXX
1552 .type = QUIRK_AUDIO_EDIROL_UAXX
1556 .type = QUIRK_AUDIO_EDIROL_UAXX
1566 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1567 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1569 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1570 .data = & (const struct snd_usb_midi_endpoint_info) {
1571 .out_cables = 0x0007,
1578 USB_DEVICE(0x0582, 0x0113),
1579 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1580 .ifnum = QUIRK_ANY_INTERFACE,
1581 .type = QUIRK_COMPOSITE,
1582 .data = (const struct snd_usb_audio_quirk[]) {
1585 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1589 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1593 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1594 .data = & (const struct snd_usb_midi_endpoint_info) {
1595 .out_cables = 0x0001,
1606 /* only 44.1 kHz works at the moment */
1607 USB_DEVICE(0x0582, 0x0120),
1608 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1609 /* .vendor_name = "Roland", */
1610 /* .product_name = "OCTO-CAPTURE", */
1611 .ifnum = QUIRK_ANY_INTERFACE,
1612 .type = QUIRK_COMPOSITE,
1613 .data = (const struct snd_usb_audio_quirk[]) {
1616 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1617 .data = & (const struct audioformat) {
1618 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1625 .rates = SNDRV_PCM_RATE_44100,
1629 .rate_table = (unsigned int[]) { 44100 }
1634 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1635 .data = & (const struct audioformat) {
1636 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1643 .rates = SNDRV_PCM_RATE_44100,
1647 .rate_table = (unsigned int[]) { 44100 }
1652 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1653 .data = & (const struct snd_usb_midi_endpoint_info) {
1654 .out_cables = 0x0001,
1660 .type = QUIRK_IGNORE_INTERFACE
1664 .type = QUIRK_IGNORE_INTERFACE
1673 /* only 44.1 kHz works at the moment */
1674 USB_DEVICE(0x0582, 0x012f),
1675 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1676 /* .vendor_name = "Roland", */
1677 /* .product_name = "QUAD-CAPTURE", */
1678 .ifnum = QUIRK_ANY_INTERFACE,
1679 .type = QUIRK_COMPOSITE,
1680 .data = (const struct snd_usb_audio_quirk[]) {
1683 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1684 .data = & (const struct audioformat) {
1685 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1692 .rates = SNDRV_PCM_RATE_44100,
1696 .rate_table = (unsigned int[]) { 44100 }
1701 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1702 .data = & (const struct audioformat) {
1703 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1710 .rates = SNDRV_PCM_RATE_44100,
1714 .rate_table = (unsigned int[]) { 44100 }
1719 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1720 .data = & (const struct snd_usb_midi_endpoint_info) {
1721 .out_cables = 0x0001,
1727 .type = QUIRK_IGNORE_INTERFACE
1731 .type = QUIRK_IGNORE_INTERFACE
1740 USB_DEVICE(0x0582, 0x0159),
1741 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1742 /* .vendor_name = "Roland", */
1743 /* .product_name = "UA-22", */
1744 .ifnum = QUIRK_ANY_INTERFACE,
1745 .type = QUIRK_COMPOSITE,
1746 .data = (const struct snd_usb_audio_quirk[]) {
1749 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1753 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1757 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1758 .data = & (const struct snd_usb_midi_endpoint_info) {
1759 .out_cables = 0x0001,
1769 /* this catches most recent vendor-specific Roland devices */
1771 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1772 USB_DEVICE_ID_MATCH_INT_CLASS,
1774 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1775 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1776 .ifnum = QUIRK_ANY_INTERFACE,
1777 .type = QUIRK_AUTODETECT
1781 /* Guillemot devices */
1784 * This is for the "Windows Edition" where the external MIDI ports are
1785 * the only MIDI ports; the control data is reported through HID
1786 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard
1787 * compliant USB MIDI ports for external MIDI and controls.
1789 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1790 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1791 .vendor_name = "Hercules",
1792 .product_name = "DJ Console (WE)",
1794 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1795 .data = & (const struct snd_usb_midi_endpoint_info) {
1796 .out_cables = 0x0001,
1802 /* Midiman/M-Audio devices */
1804 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1805 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1806 .vendor_name = "M-Audio",
1807 .product_name = "MidiSport 2x2",
1808 .ifnum = QUIRK_ANY_INTERFACE,
1809 .type = QUIRK_MIDI_MIDIMAN,
1810 .data = & (const struct snd_usb_midi_endpoint_info) {
1811 .out_cables = 0x0003,
1817 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1818 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1819 .vendor_name = "M-Audio",
1820 .product_name = "MidiSport 1x1",
1821 .ifnum = QUIRK_ANY_INTERFACE,
1822 .type = QUIRK_MIDI_MIDIMAN,
1823 .data = & (const struct snd_usb_midi_endpoint_info) {
1824 .out_cables = 0x0001,
1830 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1831 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1832 .vendor_name = "M-Audio",
1833 .product_name = "Keystation",
1834 .ifnum = QUIRK_ANY_INTERFACE,
1835 .type = QUIRK_MIDI_MIDIMAN,
1836 .data = & (const struct snd_usb_midi_endpoint_info) {
1837 .out_cables = 0x0001,
1843 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1844 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1845 .vendor_name = "M-Audio",
1846 .product_name = "MidiSport 4x4",
1847 .ifnum = QUIRK_ANY_INTERFACE,
1848 .type = QUIRK_MIDI_MIDIMAN,
1849 .data = & (const struct snd_usb_midi_endpoint_info) {
1850 .out_cables = 0x000f,
1857 * For hardware revision 1.05; in the later revisions (1.10 and
1858 * 1.21), 0x1031 is the ID for the device without firmware.
1859 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1861 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1862 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1863 .vendor_name = "M-Audio",
1864 .product_name = "MidiSport 8x8",
1865 .ifnum = QUIRK_ANY_INTERFACE,
1866 .type = QUIRK_MIDI_MIDIMAN,
1867 .data = & (const struct snd_usb_midi_endpoint_info) {
1868 .out_cables = 0x01ff,
1874 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1875 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1876 .vendor_name = "M-Audio",
1877 .product_name = "MidiSport 8x8",
1878 .ifnum = QUIRK_ANY_INTERFACE,
1879 .type = QUIRK_MIDI_MIDIMAN,
1880 .data = & (const struct snd_usb_midi_endpoint_info) {
1881 .out_cables = 0x01ff,
1887 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1888 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1889 .vendor_name = "M-Audio",
1890 .product_name = "MidiSport 2x4",
1891 .ifnum = QUIRK_ANY_INTERFACE,
1892 .type = QUIRK_MIDI_MIDIMAN,
1893 .data = & (const struct snd_usb_midi_endpoint_info) {
1894 .out_cables = 0x000f,
1900 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1901 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1902 .vendor_name = "M-Audio",
1903 .product_name = "Quattro",
1904 .ifnum = QUIRK_ANY_INTERFACE,
1905 .type = QUIRK_COMPOSITE,
1906 .data = & (const struct snd_usb_audio_quirk[]) {
1908 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1909 * and share endpoints with the other interfaces.
1910 * Ignore them. The other interfaces can do 24 bits,
1911 * but captured samples are big-endian (see usbaudio.c).
1915 .type = QUIRK_IGNORE_INTERFACE
1919 .type = QUIRK_IGNORE_INTERFACE
1923 .type = QUIRK_IGNORE_INTERFACE
1927 .type = QUIRK_IGNORE_INTERFACE
1931 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1935 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1939 .type = QUIRK_IGNORE_INTERFACE
1943 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1947 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1951 .type = QUIRK_MIDI_MIDIMAN,
1952 .data = & (const struct snd_usb_midi_endpoint_info) {
1953 .out_cables = 0x0001,
1964 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1965 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1966 .vendor_name = "M-Audio",
1967 .product_name = "AudioPhile",
1969 .type = QUIRK_MIDI_MIDIMAN,
1970 .data = & (const struct snd_usb_midi_endpoint_info) {
1971 .out_cables = 0x0001,
1977 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1978 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1979 .vendor_name = "M-Audio",
1980 .product_name = "Ozone",
1982 .type = QUIRK_MIDI_MIDIMAN,
1983 .data = & (const struct snd_usb_midi_endpoint_info) {
1984 .out_cables = 0x0001,
1990 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1991 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1992 .vendor_name = "M-Audio",
1993 .product_name = "OmniStudio",
1994 .ifnum = QUIRK_ANY_INTERFACE,
1995 .type = QUIRK_COMPOSITE,
1996 .data = & (const struct snd_usb_audio_quirk[]) {
1999 .type = QUIRK_IGNORE_INTERFACE
2003 .type = QUIRK_IGNORE_INTERFACE
2007 .type = QUIRK_IGNORE_INTERFACE
2011 .type = QUIRK_IGNORE_INTERFACE
2015 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2019 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2023 .type = QUIRK_IGNORE_INTERFACE
2027 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2031 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2035 .type = QUIRK_MIDI_MIDIMAN,
2036 .data = & (const struct snd_usb_midi_endpoint_info) {
2037 .out_cables = 0x0001,
2048 USB_DEVICE(0x0763, 0x2019),
2049 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2050 /* .vendor_name = "M-Audio", */
2051 /* .product_name = "Ozone Academic", */
2052 .ifnum = QUIRK_ANY_INTERFACE,
2053 .type = QUIRK_COMPOSITE,
2054 .data = & (const struct snd_usb_audio_quirk[]) {
2057 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2061 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2065 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2069 .type = QUIRK_MIDI_MIDIMAN,
2070 .data = & (const struct snd_usb_midi_endpoint_info) {
2071 .out_cables = 0x0001,
2082 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2083 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2084 /* .vendor_name = "M-Audio", */
2085 /* .product_name = "Fast Track C400", */
2086 .ifnum = QUIRK_ANY_INTERFACE,
2087 .type = QUIRK_COMPOSITE,
2088 .data = &(const struct snd_usb_audio_quirk[]) {
2091 .type = QUIRK_AUDIO_STANDARD_MIXER,
2096 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2097 .data = &(const struct audioformat) {
2098 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2103 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2106 .rates = SNDRV_PCM_RATE_44100 |
2107 SNDRV_PCM_RATE_48000 |
2108 SNDRV_PCM_RATE_88200 |
2109 SNDRV_PCM_RATE_96000,
2113 .rate_table = (unsigned int[]) {
2114 44100, 48000, 88200, 96000
2122 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2123 .data = &(const struct audioformat) {
2124 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2129 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2132 .rates = SNDRV_PCM_RATE_44100 |
2133 SNDRV_PCM_RATE_48000 |
2134 SNDRV_PCM_RATE_88200 |
2135 SNDRV_PCM_RATE_96000,
2139 .rate_table = (unsigned int[]) {
2140 44100, 48000, 88200, 96000
2147 .ifnum = -1 /* Interface = 4 */
2153 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2154 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2155 /* .vendor_name = "M-Audio", */
2156 /* .product_name = "Fast Track C600", */
2157 .ifnum = QUIRK_ANY_INTERFACE,
2158 .type = QUIRK_COMPOSITE,
2159 .data = &(const struct snd_usb_audio_quirk[]) {
2162 .type = QUIRK_AUDIO_STANDARD_MIXER,
2167 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2168 .data = &(const struct audioformat) {
2169 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2174 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2177 .rates = SNDRV_PCM_RATE_44100 |
2178 SNDRV_PCM_RATE_48000 |
2179 SNDRV_PCM_RATE_88200 |
2180 SNDRV_PCM_RATE_96000,
2184 .rate_table = (unsigned int[]) {
2185 44100, 48000, 88200, 96000
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
2218 .ifnum = -1 /* Interface = 4 */
2224 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2225 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2226 /* .vendor_name = "M-Audio", */
2227 /* .product_name = "Fast Track Ultra", */
2228 .ifnum = QUIRK_ANY_INTERFACE,
2229 .type = QUIRK_COMPOSITE,
2230 .data = & (const struct snd_usb_audio_quirk[]) {
2233 .type = QUIRK_AUDIO_STANDARD_MIXER,
2237 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2238 .data = & (const struct audioformat) {
2239 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2244 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2247 .rates = SNDRV_PCM_RATE_44100 |
2248 SNDRV_PCM_RATE_48000 |
2249 SNDRV_PCM_RATE_88200 |
2250 SNDRV_PCM_RATE_96000,
2254 .rate_table = (unsigned int[]) {
2255 44100, 48000, 88200, 96000
2261 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2262 .data = & (const struct audioformat) {
2263 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2268 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2271 .rates = SNDRV_PCM_RATE_44100 |
2272 SNDRV_PCM_RATE_48000 |
2273 SNDRV_PCM_RATE_88200 |
2274 SNDRV_PCM_RATE_96000,
2278 .rate_table = (unsigned int[]) {
2279 44100, 48000, 88200, 96000
2283 /* interface 3 (MIDI) is standard compliant */
2291 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2292 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2293 /* .vendor_name = "M-Audio", */
2294 /* .product_name = "Fast Track Ultra 8R", */
2295 .ifnum = QUIRK_ANY_INTERFACE,
2296 .type = QUIRK_COMPOSITE,
2297 .data = & (const struct snd_usb_audio_quirk[]) {
2300 .type = QUIRK_AUDIO_STANDARD_MIXER,
2304 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2305 .data = & (const struct audioformat) {
2306 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2311 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2314 .rates = SNDRV_PCM_RATE_44100 |
2315 SNDRV_PCM_RATE_48000 |
2316 SNDRV_PCM_RATE_88200 |
2317 SNDRV_PCM_RATE_96000,
2321 .rate_table = (unsigned int[]) {
2322 44100, 48000, 88200, 96000
2328 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2329 .data = & (const struct audioformat) {
2330 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2335 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2338 .rates = SNDRV_PCM_RATE_44100 |
2339 SNDRV_PCM_RATE_48000 |
2340 SNDRV_PCM_RATE_88200 |
2341 SNDRV_PCM_RATE_96000,
2345 .rate_table = (unsigned int[]) {
2346 44100, 48000, 88200, 96000
2350 /* interface 3 (MIDI) is standard compliant */
2360 USB_DEVICE(0x07cf, 0x6801),
2361 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2362 .vendor_name = "Casio",
2363 .product_name = "PL-40R",
2365 .type = QUIRK_MIDI_YAMAHA
2369 /* this ID is used by several devices without a product ID */
2370 USB_DEVICE(0x07cf, 0x6802),
2371 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2372 .vendor_name = "Casio",
2373 .product_name = "Keyboard",
2375 .type = QUIRK_MIDI_YAMAHA
2379 /* Mark of the Unicorn devices */
2381 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2382 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2383 USB_DEVICE_ID_MATCH_PRODUCT |
2384 USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2386 .idProduct = 0x0001,
2387 .bDeviceSubClass = 2,
2388 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2389 .vendor_name = "MOTU",
2390 .product_name = "Fastlane",
2391 .ifnum = QUIRK_ANY_INTERFACE,
2392 .type = QUIRK_COMPOSITE,
2393 .data = & (const struct snd_usb_audio_quirk[]) {
2396 .type = QUIRK_MIDI_RAW_BYTES
2400 .type = QUIRK_IGNORE_INTERFACE
2409 /* Emagic devices */
2411 USB_DEVICE(0x086a, 0x0001),
2412 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2413 .vendor_name = "Emagic",
2414 .product_name = "Unitor8",
2416 .type = QUIRK_MIDI_EMAGIC,
2417 .data = & (const struct snd_usb_midi_endpoint_info) {
2418 .out_cables = 0x80ff,
2424 USB_DEVICE(0x086a, 0x0002),
2425 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2426 .vendor_name = "Emagic",
2427 /* .product_name = "AMT8", */
2429 .type = QUIRK_MIDI_EMAGIC,
2430 .data = & (const struct snd_usb_midi_endpoint_info) {
2431 .out_cables = 0x80ff,
2437 USB_DEVICE(0x086a, 0x0003),
2438 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2439 .vendor_name = "Emagic",
2440 /* .product_name = "MT4", */
2442 .type = QUIRK_MIDI_EMAGIC,
2443 .data = & (const struct snd_usb_midi_endpoint_info) {
2444 .out_cables = 0x800f,
2452 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2453 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2454 .vendor_name = "KORG, Inc.",
2455 /* .product_name = "PANDORA PX5D", */
2457 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2462 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2463 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2464 .vendor_name = "KORG, Inc.",
2465 /* .product_name = "ToneLab ST", */
2467 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2473 USB_DEVICE(0x09e8, 0x0062),
2474 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2475 .vendor_name = "AKAI",
2476 .product_name = "MPD16",
2478 .type = QUIRK_MIDI_AKAI,
2483 /* Akai MPC Element */
2484 USB_DEVICE(0x09e8, 0x0021),
2485 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2486 .ifnum = QUIRK_ANY_INTERFACE,
2487 .type = QUIRK_COMPOSITE,
2488 .data = & (const struct snd_usb_audio_quirk[]) {
2491 .type = QUIRK_IGNORE_INTERFACE
2495 .type = QUIRK_MIDI_STANDARD_INTERFACE
2504 /* Steinberg devices */
2507 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2508 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2509 .ifnum = QUIRK_ANY_INTERFACE,
2510 .type = QUIRK_COMPOSITE,
2511 .data = & (const struct snd_usb_audio_quirk[]) {
2514 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2518 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2522 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2526 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2527 .data = &(const struct snd_usb_midi_endpoint_info) {
2528 .out_cables = 0x0001,
2540 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2541 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2542 .ifnum = QUIRK_ANY_INTERFACE,
2543 .type = QUIRK_COMPOSITE,
2544 .data = & (const struct snd_usb_audio_quirk[]) {
2547 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2551 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2555 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2559 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2560 .data = &(const struct snd_usb_midi_endpoint_info) {
2561 .out_cables = 0x0001,
2572 /* TerraTec devices */
2574 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2575 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2576 .vendor_name = "TerraTec",
2577 .product_name = "PHASE 26",
2579 .type = QUIRK_MIDI_STANDARD_INTERFACE
2583 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2584 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2585 .vendor_name = "TerraTec",
2586 .product_name = "PHASE 26",
2588 .type = QUIRK_MIDI_STANDARD_INTERFACE
2592 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2593 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2594 .vendor_name = "TerraTec",
2595 .product_name = "PHASE 26",
2597 .type = QUIRK_MIDI_STANDARD_INTERFACE
2601 USB_DEVICE(0x0ccd, 0x0028),
2602 QUIRK_RENAME_DEVICE("TerraTec", "Aureon5.1MkII")
2605 USB_DEVICE(0x0ccd, 0x0035),
2606 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2607 .vendor_name = "Miditech",
2608 .product_name = "Play'n Roll",
2610 .type = QUIRK_MIDI_CME
2614 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2616 USB_DEVICE(0x103d, 0x0100),
2617 QUIRK_RENAME_DEVICE("Stanton", "ScratchAmp")
2620 USB_DEVICE(0x103d, 0x0101),
2621 QUIRK_RENAME_DEVICE("Stanton", "ScratchAmp")
2624 /* Novation EMS devices */
2626 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2627 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2628 .vendor_name = "Novation",
2629 .product_name = "ReMOTE Audio/XStation",
2631 .type = QUIRK_MIDI_NOVATION
2635 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2636 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2637 .vendor_name = "Novation",
2638 .product_name = "Speedio",
2640 .type = QUIRK_MIDI_NOVATION
2644 USB_DEVICE(0x1235, 0x000a),
2645 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2646 /* .vendor_name = "Novation", */
2647 /* .product_name = "Nocturn", */
2649 .type = QUIRK_MIDI_RAW_BYTES
2653 USB_DEVICE(0x1235, 0x000e),
2654 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2655 /* .vendor_name = "Novation", */
2656 /* .product_name = "Launchpad", */
2658 .type = QUIRK_MIDI_RAW_BYTES
2662 USB_DEVICE(0x1235, 0x0010),
2663 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2664 .vendor_name = "Focusrite",
2665 .product_name = "Saffire 6 USB",
2666 .ifnum = QUIRK_ANY_INTERFACE,
2667 .type = QUIRK_COMPOSITE,
2668 .data = (const struct snd_usb_audio_quirk[]) {
2671 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2672 .data = &(const struct audioformat) {
2673 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2678 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2680 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2681 .rates = SNDRV_PCM_RATE_44100 |
2682 SNDRV_PCM_RATE_48000,
2686 .rate_table = (unsigned int[]) {
2693 .type = QUIRK_MIDI_RAW_BYTES
2702 USB_DEVICE(0x1235, 0x0018),
2703 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2704 .vendor_name = "Novation",
2705 .product_name = "Twitch",
2706 .ifnum = QUIRK_ANY_INTERFACE,
2707 .type = QUIRK_COMPOSITE,
2708 .data = (const struct snd_usb_audio_quirk[]) {
2711 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2712 .data = & (const struct audioformat) {
2713 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2718 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2720 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2721 .rates = SNDRV_PCM_RATE_44100 |
2722 SNDRV_PCM_RATE_48000,
2726 .rate_table = (unsigned int[]) {
2733 .type = QUIRK_MIDI_RAW_BYTES
2742 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2743 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2744 .vendor_name = "Novation",
2745 .product_name = "ReMOTE25",
2747 .type = QUIRK_MIDI_NOVATION
2751 /* Access Music devices */
2753 /* VirusTI Desktop */
2754 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2755 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2756 .ifnum = QUIRK_ANY_INTERFACE,
2757 .type = QUIRK_COMPOSITE,
2758 .data = &(const struct snd_usb_audio_quirk[]) {
2761 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2762 .data = &(const struct snd_usb_midi_endpoint_info) {
2763 .out_cables = 0x0003,
2769 .type = QUIRK_IGNORE_INTERFACE
2780 /* aka. Serato Scratch Live DJ Box */
2781 USB_DEVICE(0x13e5, 0x0001),
2782 QUIRK_RENAME_DEVICE("Rane", "SL-1")
2785 /* Native Instruments MK2 series */
2787 /* Komplete Audio 6 */
2788 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2790 .idProduct = 0x1000,
2793 /* Traktor Audio 6 */
2794 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2796 .idProduct = 0x1010,
2799 /* Traktor Audio 10 */
2800 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2802 .idProduct = 0x1020,
2805 /* QinHeng devices */
2807 USB_DEVICE(0x1a86, 0x752d),
2808 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2809 .vendor_name = "QinHeng",
2810 .product_name = "CH345",
2812 .type = QUIRK_MIDI_CH345
2816 /* KeithMcMillen Stringport */
2818 USB_DEVICE(0x1f38, 0x0001),
2819 .bInterfaceClass = USB_CLASS_AUDIO,
2822 /* Miditech devices */
2824 USB_DEVICE(0x4752, 0x0011),
2825 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2826 .vendor_name = "Miditech",
2827 .product_name = "Midistart-2",
2829 .type = QUIRK_MIDI_CME
2833 /* Central Music devices */
2835 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2836 USB_DEVICE(0x7104, 0x2202),
2837 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2839 .type = QUIRK_MIDI_CME
2844 * Auvitek au0828 devices with audio interface.
2845 * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
2846 * Please notice that some drivers are DVB only, and don't need to be
2847 * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2850 #define AU0828_DEVICE(vid, pid, vname, pname) { \
2853 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
2854 USB_DEVICE_ID_MATCH_INT_CLASS | \
2855 USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
2856 .bInterfaceClass = USB_CLASS_AUDIO, \
2857 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, \
2858 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2859 .vendor_name = vname, \
2860 .product_name = pname, \
2861 .ifnum = QUIRK_ANY_INTERFACE, \
2862 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
2863 .shares_media_device = 1, \
2867 AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2868 AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2869 AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
2870 AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
2871 AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
2872 AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
2873 AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
2874 AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
2875 AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
2876 AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
2877 AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
2878 AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
2879 AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
2880 AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
2881 AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
2882 AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
2883 AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
2885 /* Syntek STK1160 */
2887 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2888 USB_DEVICE_ID_MATCH_INT_CLASS |
2889 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2891 .idProduct = 0x0408,
2892 .bInterfaceClass = USB_CLASS_AUDIO,
2893 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2894 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2895 .vendor_name = "Syntek",
2896 .product_name = "STK1160",
2897 .ifnum = QUIRK_ANY_INTERFACE,
2898 .type = QUIRK_AUDIO_ALIGN_TRANSFER
2902 /* Digidesign Mbox */
2904 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2905 USB_DEVICE(0x0dba, 0x1000),
2906 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2907 .vendor_name = "Digidesign",
2908 .product_name = "MBox",
2909 .ifnum = QUIRK_ANY_INTERFACE,
2910 .type = QUIRK_COMPOSITE,
2911 .data = (const struct snd_usb_audio_quirk[]){
2914 .type = QUIRK_AUDIO_STANDARD_MIXER,
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_SYNC,
2929 .maxpacksize = 0x130,
2930 .rates = SNDRV_PCM_RATE_48000,
2934 .rate_table = (unsigned int[]) {
2941 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2942 .data = &(const struct audioformat) {
2943 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2950 .ep_attr = USB_ENDPOINT_XFER_ISOC |
2951 USB_ENDPOINT_SYNC_ASYNC,
2952 .maxpacksize = 0x130,
2953 .rates = SNDRV_PCM_RATE_48000,
2957 .rate_table = (unsigned int[]) {
2969 /* DIGIDESIGN MBOX 2 */
2971 USB_DEVICE(0x0dba, 0x3000),
2972 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2973 .vendor_name = "Digidesign",
2974 .product_name = "Mbox 2",
2975 .ifnum = QUIRK_ANY_INTERFACE,
2976 .type = QUIRK_COMPOSITE,
2977 .data = (const struct snd_usb_audio_quirk[]) {
2980 .type = QUIRK_IGNORE_INTERFACE
2984 .type = QUIRK_IGNORE_INTERFACE
2988 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2989 .data = &(const struct audioformat) {
2990 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2997 .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
2998 .rates = SNDRV_PCM_RATE_48000,
3002 .rate_table = (unsigned int[]) {
3009 .type = QUIRK_IGNORE_INTERFACE
3013 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3014 .data = &(const struct audioformat) {
3015 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3020 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3022 .ep_attr = USB_ENDPOINT_SYNC_SYNC,
3023 .rates = SNDRV_PCM_RATE_48000,
3027 .rate_table = (unsigned int[]) {
3034 .type = QUIRK_IGNORE_INTERFACE
3038 .type = QUIRK_MIDI_MIDIMAN,
3039 .data = &(const struct snd_usb_midi_endpoint_info) {
3041 .out_cables = 0x0001,
3043 .in_interval = 0x01,
3054 /* Tascam US122 MKII - playback-only support */
3055 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
3057 .idProduct = 0x8021,
3058 .bInterfaceClass = USB_CLASS_AUDIO,
3059 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3060 .vendor_name = "TASCAM",
3061 .product_name = "US122 MKII",
3062 .ifnum = QUIRK_ANY_INTERFACE,
3063 .type = QUIRK_COMPOSITE,
3064 .data = (const struct snd_usb_audio_quirk[]) {
3067 .type = QUIRK_IGNORE_INTERFACE
3071 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3072 .data = &(const struct audioformat) {
3073 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3078 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3080 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3081 .rates = SNDRV_PCM_RATE_44100 |
3082 SNDRV_PCM_RATE_48000 |
3083 SNDRV_PCM_RATE_88200 |
3084 SNDRV_PCM_RATE_96000,
3088 .rate_table = (unsigned int[]) {
3089 44100, 48000, 88200, 96000
3100 /* Microsoft XboxLive Headset/Xbox Communicator */
3102 USB_DEVICE(0x045e, 0x0283),
3103 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3104 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3105 .vendor_name = "Microsoft",
3106 .product_name = "XboxLive Headset/Xbox Communicator",
3107 .ifnum = QUIRK_ANY_INTERFACE,
3108 .type = QUIRK_COMPOSITE,
3109 .data = &(const struct snd_usb_audio_quirk[]) {
3113 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3114 .data = &(const struct audioformat) {
3115 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3123 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3131 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3132 .data = &(const struct audioformat) {
3133 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3141 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3155 USB_DEVICE(0x200c, 0x100b),
3156 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3157 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3158 .ifnum = QUIRK_ANY_INTERFACE,
3159 .type = QUIRK_COMPOSITE,
3160 .data = &(const struct snd_usb_audio_quirk[]) {
3163 .type = QUIRK_AUDIO_STANDARD_MIXER,
3167 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3168 .data = &(const struct audioformat) {
3169 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3174 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3176 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3177 .rates = SNDRV_PCM_RATE_44100 |
3178 SNDRV_PCM_RATE_48000,
3182 .rate_table = (unsigned int[]) {
3196 * ZOOM R16/24 in audio interface mode.
3197 * Playback requires an extra four byte LE length indicator
3198 * at the start of each isochronous packet. This quirk is
3199 * enabled in create_standard_audio_quirk().
3201 USB_DEVICE(0x1686, 0x00dd),
3202 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3203 .ifnum = QUIRK_ANY_INTERFACE,
3204 .type = QUIRK_COMPOSITE,
3205 .data = (const struct snd_usb_audio_quirk[]) {
3209 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3214 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3219 .type = QUIRK_MIDI_STANDARD_INTERFACE
3230 * Some USB MIDI devices don't have an audio control interface,
3231 * so we have to grab MIDI streaming interfaces here.
3233 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3234 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3235 .bInterfaceClass = USB_CLASS_AUDIO,
3236 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3237 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3238 .ifnum = QUIRK_ANY_INTERFACE,
3239 .type = QUIRK_MIDI_STANDARD_INTERFACE
3245 * The original product_name is "USB Sound Device", however this name
3246 * is also used by the CM106 based cards, so make it unique.
3248 USB_DEVICE(0x0d8c, 0x0103),
3249 QUIRK_RENAME_DEVICE(NULL, "Audio Advantage MicroII")
3252 /* disabled due to regression for other devices;
3253 * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3258 * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3259 * ID, but it looks like the product ID actually is only for Nura.
3260 * The capture interface does not work at all (even on Windows),
3261 * and only the 48 kHz sample rate works for the playback interface.
3263 USB_DEVICE(0x0a12, 0x1243),
3264 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3265 .ifnum = QUIRK_ANY_INTERFACE,
3266 .type = QUIRK_COMPOSITE,
3267 .data = (const struct snd_usb_audio_quirk[]) {
3270 .type = QUIRK_AUDIO_STANDARD_MIXER,
3275 .type = QUIRK_IGNORE_INTERFACE,
3280 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3281 .data = &(const struct audioformat) {
3282 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3287 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3288 UAC_EP_CS_ATTR_SAMPLE_RATE,
3290 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3291 .rates = SNDRV_PCM_RATE_48000,
3295 .rate_table = (unsigned int[]) {
3306 #endif /* disabled */
3310 * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3311 * even though it advertises more. The capture interface doesn't work
3314 USB_DEVICE(0x19b5, 0x0021),
3315 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3316 .ifnum = QUIRK_ANY_INTERFACE,
3317 .type = QUIRK_COMPOSITE,
3318 .data = (const struct snd_usb_audio_quirk[]) {
3321 .type = QUIRK_AUDIO_STANDARD_MIXER,
3326 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3327 .data = &(const struct audioformat) {
3328 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3333 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3334 UAC_EP_CS_ATTR_SAMPLE_RATE,
3336 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3337 .rates = SNDRV_PCM_RATE_48000,
3341 .rate_table = (unsigned int[]) {
3352 /* Dell WD15 Dock */
3354 USB_DEVICE(0x0bda, 0x4014),
3355 QUIRK_DEVICE_PROFILE("Dell", "WD15 Dock", "Dell-WD15-Dock")
3357 /* Dell WD19 Dock */
3359 USB_DEVICE(0x0bda, 0x402e),
3360 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3361 .vendor_name = "Dell",
3362 .product_name = "WD19 Dock",
3363 .profile_name = "Dell-WD15-Dock",
3364 .ifnum = QUIRK_ANY_INTERFACE,
3365 .type = QUIRK_SETUP_FMT_AFTER_RESUME
3368 /* MOTU Microbook II */
3370 USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004),
3371 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3372 .vendor_name = "MOTU",
3373 .product_name = "MicroBookII",
3374 .ifnum = QUIRK_ANY_INTERFACE,
3375 .type = QUIRK_COMPOSITE,
3376 .data = (const struct snd_usb_audio_quirk[]) {
3379 .type = QUIRK_AUDIO_STANDARD_MIXER,
3383 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3384 .data = &(const struct audioformat) {
3385 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3392 .rates = SNDRV_PCM_RATE_96000,
3393 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3394 USB_ENDPOINT_SYNC_ASYNC,
3398 .maxpacksize = 0x00d8,
3399 .rate_table = (unsigned int[]) {
3406 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3407 .data = &(const struct audioformat) {
3408 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3415 .rates = SNDRV_PCM_RATE_96000,
3416 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3417 USB_ENDPOINT_SYNC_ASYNC,
3421 .maxpacksize = 0x0120,
3422 .rate_table = (unsigned int[]) {
3435 * PIONEER DJ DDJ-SX3
3436 * PCM is 12 channels out, 10 channels in @ 44.1 fixed
3437 * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
3438 * The feedback for the output is the input.
3440 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
3441 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3442 .ifnum = QUIRK_ANY_INTERFACE,
3443 .type = QUIRK_COMPOSITE,
3444 .data = (const struct snd_usb_audio_quirk[]) {
3447 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3448 .data = &(const struct audioformat) {
3449 .formats = SNDRV_PCM_FMTBIT_S32_LE,
3455 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3456 USB_ENDPOINT_SYNC_ASYNC,
3457 .rates = SNDRV_PCM_RATE_44100,
3461 .rate_table = (unsigned int[]) { 44100 }
3466 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3467 .data = &(const struct audioformat) {
3468 .formats = SNDRV_PCM_FMTBIT_S32_LE,
3474 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3475 USB_ENDPOINT_SYNC_ASYNC|
3476 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3477 .rates = SNDRV_PCM_RATE_44100,
3481 .rate_table = (unsigned int[]) { 44100 }
3492 * Pioneer DJ DJM-250MK2
3493 * PCM is 8 channels out @ 48 fixed (endpoints 0x01).
3494 * The output from computer to the mixer is usable.
3496 * The input (phono or line to computer) is not working.
3497 * It should be at endpoint 0x82 and probably also 8 channels,
3498 * but it seems that it works only with Pioneer proprietary software.
3499 * Even on officially supported OS, the Audacity was unable to record
3500 * and Mixxx to recognize the control vinyls.
3502 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3503 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3504 .ifnum = QUIRK_ANY_INTERFACE,
3505 .type = QUIRK_COMPOSITE,
3506 .data = (const struct snd_usb_audio_quirk[]) {
3509 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3510 .data = &(const struct audioformat) {
3511 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3512 .channels = 8, // outputs
3517 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3518 USB_ENDPOINT_SYNC_ASYNC,
3519 .rates = SNDRV_PCM_RATE_48000,
3523 .rate_table = (unsigned int[]) { 48000 }
3533 #define ALC1220_VB_DESKTOP(vend, prod) { \
3534 USB_DEVICE(vend, prod), \
3535 QUIRK_DEVICE_PROFILE("Realtek", "ALC1220-VB-DT", \
3536 "Realtek-ALC1220-VB-Desktop") \
3538 ALC1220_VB_DESKTOP(0x0414, 0xa002), /* Gigabyte TRX40 Aorus Pro WiFi */
3539 ALC1220_VB_DESKTOP(0x0db0, 0x0d64), /* MSI TRX40 Creator */
3540 ALC1220_VB_DESKTOP(0x0db0, 0x543d), /* MSI TRX40 */
3541 ALC1220_VB_DESKTOP(0x26ce, 0x0a01), /* Asrock TRX40 Creator */
3542 #undef ALC1220_VB_DESKTOP
3544 /* Two entries for Gigabyte TRX40 Aorus Master:
3545 * TRX40 Aorus Master has two USB-audio devices, one for the front headphone
3546 * with ESS SABRE9218 DAC chip, while another for the rest I/O (the rear
3547 * panel and the front mic) with Realtek ALC1220-VB.
3548 * Here we provide two distinct names for making UCM profiles easier.
3551 USB_DEVICE(0x0414, 0xa000),
3552 QUIRK_DEVICE_PROFILE("Gigabyte", "Aorus Master Front Headphone",
3553 "Gigabyte-Aorus-Master-Front-Headphone")
3556 USB_DEVICE(0x0414, 0xa001),
3557 QUIRK_DEVICE_PROFILE("Gigabyte", "Aorus Master Main Audio",
3558 "Gigabyte-Aorus-Master-Main-Audio")
3562 * Pioneer DJ DJM-900NXS2
3563 * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE
3565 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a),
3566 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3567 .ifnum = QUIRK_ANY_INTERFACE,
3568 .type = QUIRK_COMPOSITE,
3569 .data = (const struct snd_usb_audio_quirk[]) {
3572 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3573 .data = &(const struct audioformat) {
3574 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3580 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3581 USB_ENDPOINT_SYNC_ASYNC,
3582 .rates = SNDRV_PCM_RATE_44100|
3583 SNDRV_PCM_RATE_48000|
3584 SNDRV_PCM_RATE_96000,
3588 .rate_table = (unsigned int[]) {
3595 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3596 .data = &(const struct audioformat) {
3597 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3603 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3604 USB_ENDPOINT_SYNC_ASYNC|
3605 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3606 .rates = SNDRV_PCM_RATE_44100|
3607 SNDRV_PCM_RATE_48000|
3608 SNDRV_PCM_RATE_96000,
3612 .rate_table = (unsigned int[]) {
3624 #undef USB_DEVICE_VENDOR_SPEC