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) },
81 * Creative Technology, Ltd Live! Cam Sync HD [VF0770]
82 * The device advertises 8 formats, but only a rate of 48kHz is honored by the
83 * hardware and 24 bits give chopped audio, so only report the one working
87 USB_DEVICE(0x041e, 0x4095),
88 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
89 .ifnum = QUIRK_ANY_INTERFACE,
90 .type = QUIRK_COMPOSITE,
91 .data = &(const struct snd_usb_audio_quirk[]) {
94 .type = QUIRK_AUDIO_STANDARD_MIXER,
98 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
99 .data = &(const struct audioformat) {
100 .formats = SNDRV_PCM_FMTBIT_S16_LE,
108 .rates = SNDRV_PCM_RATE_48000,
112 .rate_table = (unsigned int[]) { 48000 },
124 * When not ignored, causes instability issues for some users, forcing them to
125 * skip the entire module.
128 USB_DEVICE(0x0424, 0xb832),
129 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
130 .vendor_name = "Standard Microsystems Corp.",
131 .product_name = "HP Wireless Audio",
132 .ifnum = QUIRK_ANY_INTERFACE,
133 .type = QUIRK_COMPOSITE,
134 .data = (const struct snd_usb_audio_quirk[]) {
138 .type = QUIRK_IGNORE_INTERFACE,
143 .type = QUIRK_IGNORE_INTERFACE,
148 .type = QUIRK_IGNORE_INTERFACE,
150 /* HID Device, .ifnum = 3 */
159 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
160 * class matches do not take effect without an explicit ID match.
162 { USB_AUDIO_DEVICE(0x046d, 0x0850) },
163 { USB_AUDIO_DEVICE(0x046d, 0x08ae) },
164 { USB_AUDIO_DEVICE(0x046d, 0x08c6) },
165 { USB_AUDIO_DEVICE(0x046d, 0x08f0) },
166 { USB_AUDIO_DEVICE(0x046d, 0x08f5) },
167 { USB_AUDIO_DEVICE(0x046d, 0x08f6) },
168 { USB_AUDIO_DEVICE(0x046d, 0x0990) },
174 #define YAMAHA_DEVICE(id, name) { \
175 USB_DEVICE(0x0499, id), \
176 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
177 .vendor_name = "Yamaha", \
178 .product_name = name, \
179 .ifnum = QUIRK_ANY_INTERFACE, \
180 .type = QUIRK_MIDI_YAMAHA \
183 #define YAMAHA_INTERFACE(id, intf, name) { \
184 USB_DEVICE_VENDOR_SPEC(0x0499, id), \
185 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
186 .vendor_name = "Yamaha", \
187 .product_name = name, \
189 .type = QUIRK_MIDI_YAMAHA \
192 YAMAHA_DEVICE(0x1000, "UX256"),
193 YAMAHA_DEVICE(0x1001, "MU1000"),
194 YAMAHA_DEVICE(0x1002, "MU2000"),
195 YAMAHA_DEVICE(0x1003, "MU500"),
196 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
197 YAMAHA_DEVICE(0x1005, "MOTIF6"),
198 YAMAHA_DEVICE(0x1006, "MOTIF7"),
199 YAMAHA_DEVICE(0x1007, "MOTIF8"),
200 YAMAHA_DEVICE(0x1008, "UX96"),
201 YAMAHA_DEVICE(0x1009, "UX16"),
202 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
203 YAMAHA_DEVICE(0x100c, "UC-MX"),
204 YAMAHA_DEVICE(0x100d, "UC-KX"),
205 YAMAHA_DEVICE(0x100e, "S08"),
206 YAMAHA_DEVICE(0x100f, "CLP-150"),
207 YAMAHA_DEVICE(0x1010, "CLP-170"),
208 YAMAHA_DEVICE(0x1011, "P-250"),
209 YAMAHA_DEVICE(0x1012, "TYROS"),
210 YAMAHA_DEVICE(0x1013, "PF-500"),
211 YAMAHA_DEVICE(0x1014, "S90"),
212 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
213 YAMAHA_DEVICE(0x1016, "MDP-5"),
214 YAMAHA_DEVICE(0x1017, "CVP-204"),
215 YAMAHA_DEVICE(0x1018, "CVP-206"),
216 YAMAHA_DEVICE(0x1019, "CVP-208"),
217 YAMAHA_DEVICE(0x101a, "CVP-210"),
218 YAMAHA_DEVICE(0x101b, "PSR-1100"),
219 YAMAHA_DEVICE(0x101c, "PSR-2100"),
220 YAMAHA_DEVICE(0x101d, "CLP-175"),
221 YAMAHA_DEVICE(0x101e, "PSR-K1"),
222 YAMAHA_DEVICE(0x101f, "EZ-J24"),
223 YAMAHA_DEVICE(0x1020, "EZ-250i"),
224 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
225 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
226 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
227 YAMAHA_DEVICE(0x1024, "CVP-301"),
228 YAMAHA_DEVICE(0x1025, "CVP-303"),
229 YAMAHA_DEVICE(0x1026, "CVP-305"),
230 YAMAHA_DEVICE(0x1027, "CVP-307"),
231 YAMAHA_DEVICE(0x1028, "CVP-309"),
232 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
233 YAMAHA_DEVICE(0x102a, "PSR-1500"),
234 YAMAHA_DEVICE(0x102b, "PSR-3000"),
235 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
236 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
237 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
238 YAMAHA_DEVICE(0x1032, "DGX-305"),
239 YAMAHA_DEVICE(0x1033, "DGX-505"),
240 YAMAHA_DEVICE(0x1034, NULL),
241 YAMAHA_DEVICE(0x1035, NULL),
242 YAMAHA_DEVICE(0x1036, NULL),
243 YAMAHA_DEVICE(0x1037, NULL),
244 YAMAHA_DEVICE(0x1038, NULL),
245 YAMAHA_DEVICE(0x1039, NULL),
246 YAMAHA_DEVICE(0x103a, NULL),
247 YAMAHA_DEVICE(0x103b, NULL),
248 YAMAHA_DEVICE(0x103c, NULL),
249 YAMAHA_DEVICE(0x103d, NULL),
250 YAMAHA_DEVICE(0x103e, NULL),
251 YAMAHA_DEVICE(0x103f, NULL),
252 YAMAHA_DEVICE(0x1040, NULL),
253 YAMAHA_DEVICE(0x1041, NULL),
254 YAMAHA_DEVICE(0x1042, NULL),
255 YAMAHA_DEVICE(0x1043, NULL),
256 YAMAHA_DEVICE(0x1044, NULL),
257 YAMAHA_DEVICE(0x1045, NULL),
258 YAMAHA_INTERFACE(0x104e, 0, NULL),
259 YAMAHA_DEVICE(0x104f, NULL),
260 YAMAHA_DEVICE(0x1050, NULL),
261 YAMAHA_DEVICE(0x1051, NULL),
262 YAMAHA_DEVICE(0x1052, NULL),
263 YAMAHA_INTERFACE(0x1053, 0, NULL),
264 YAMAHA_INTERFACE(0x1054, 0, NULL),
265 YAMAHA_DEVICE(0x1055, NULL),
266 YAMAHA_DEVICE(0x1056, NULL),
267 YAMAHA_DEVICE(0x1057, NULL),
268 YAMAHA_DEVICE(0x1058, NULL),
269 YAMAHA_DEVICE(0x1059, NULL),
270 YAMAHA_DEVICE(0x105a, NULL),
271 YAMAHA_DEVICE(0x105b, NULL),
272 YAMAHA_DEVICE(0x105c, NULL),
273 YAMAHA_DEVICE(0x105d, NULL),
275 USB_DEVICE(0x0499, 0x1503),
276 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
277 /* .vendor_name = "Yamaha", */
278 /* .product_name = "MOX6/MOX8", */
279 .ifnum = QUIRK_ANY_INTERFACE,
280 .type = QUIRK_COMPOSITE,
281 .data = (const struct snd_usb_audio_quirk[]) {
284 .type = QUIRK_AUDIO_STANDARD_INTERFACE
288 .type = QUIRK_AUDIO_STANDARD_INTERFACE
292 .type = QUIRK_MIDI_YAMAHA
301 USB_DEVICE(0x0499, 0x1507),
302 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
303 /* .vendor_name = "Yamaha", */
304 /* .product_name = "THR10", */
305 .ifnum = QUIRK_ANY_INTERFACE,
306 .type = QUIRK_COMPOSITE,
307 .data = (const struct snd_usb_audio_quirk[]) {
310 .type = QUIRK_AUDIO_STANDARD_INTERFACE
314 .type = QUIRK_AUDIO_STANDARD_INTERFACE
318 .type = QUIRK_MIDI_YAMAHA
327 USB_DEVICE(0x0499, 0x1509),
328 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
329 /* .vendor_name = "Yamaha", */
330 /* .product_name = "Steinberg UR22", */
331 .ifnum = QUIRK_ANY_INTERFACE,
332 .type = QUIRK_COMPOSITE,
333 .data = (const struct snd_usb_audio_quirk[]) {
336 .type = QUIRK_AUDIO_STANDARD_INTERFACE
340 .type = QUIRK_AUDIO_STANDARD_INTERFACE
344 .type = QUIRK_MIDI_YAMAHA
348 .type = QUIRK_IGNORE_INTERFACE
357 USB_DEVICE(0x0499, 0x150a),
358 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
359 /* .vendor_name = "Yamaha", */
360 /* .product_name = "THR5A", */
361 .ifnum = QUIRK_ANY_INTERFACE,
362 .type = QUIRK_COMPOSITE,
363 .data = (const struct snd_usb_audio_quirk[]) {
366 .type = QUIRK_AUDIO_STANDARD_INTERFACE
370 .type = QUIRK_AUDIO_STANDARD_INTERFACE
374 .type = QUIRK_MIDI_YAMAHA
383 USB_DEVICE(0x0499, 0x150c),
384 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
385 /* .vendor_name = "Yamaha", */
386 /* .product_name = "THR10C", */
387 .ifnum = QUIRK_ANY_INTERFACE,
388 .type = QUIRK_COMPOSITE,
389 .data = (const struct snd_usb_audio_quirk[]) {
392 .type = QUIRK_AUDIO_STANDARD_INTERFACE
396 .type = QUIRK_AUDIO_STANDARD_INTERFACE
400 .type = QUIRK_MIDI_YAMAHA
408 YAMAHA_DEVICE(0x2000, "DGP-7"),
409 YAMAHA_DEVICE(0x2001, "DGP-5"),
410 YAMAHA_DEVICE(0x2002, NULL),
411 YAMAHA_DEVICE(0x2003, NULL),
412 YAMAHA_DEVICE(0x5000, "CS1D"),
413 YAMAHA_DEVICE(0x5001, "DSP1D"),
414 YAMAHA_DEVICE(0x5002, "DME32"),
415 YAMAHA_DEVICE(0x5003, "DM2000"),
416 YAMAHA_DEVICE(0x5004, "02R96"),
417 YAMAHA_DEVICE(0x5005, "ACU16-C"),
418 YAMAHA_DEVICE(0x5006, "NHB32-C"),
419 YAMAHA_DEVICE(0x5007, "DM1000"),
420 YAMAHA_DEVICE(0x5008, "01V96"),
421 YAMAHA_DEVICE(0x5009, "SPX2000"),
422 YAMAHA_DEVICE(0x500a, "PM5D"),
423 YAMAHA_DEVICE(0x500b, "DME64N"),
424 YAMAHA_DEVICE(0x500c, "DME24N"),
425 YAMAHA_DEVICE(0x500d, NULL),
426 YAMAHA_DEVICE(0x500e, NULL),
427 YAMAHA_DEVICE(0x500f, NULL),
428 YAMAHA_DEVICE(0x7000, "DTX"),
429 YAMAHA_DEVICE(0x7010, "UB99"),
431 #undef YAMAHA_INTERFACE
432 /* this catches most recent vendor-specific Yamaha devices */
434 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
435 USB_DEVICE_ID_MATCH_INT_CLASS,
437 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
438 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
439 .ifnum = QUIRK_ANY_INTERFACE,
440 .type = QUIRK_AUTODETECT
445 * Roland/RolandED/Edirol/BOSS devices
448 USB_DEVICE(0x0582, 0x0000),
449 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
450 .vendor_name = "Roland",
451 .product_name = "UA-100",
452 .ifnum = QUIRK_ANY_INTERFACE,
453 .type = QUIRK_COMPOSITE,
454 .data = (const struct snd_usb_audio_quirk[]) {
457 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
458 .data = & (const struct audioformat) {
459 .formats = SNDRV_PCM_FMTBIT_S16_LE,
467 .rates = SNDRV_PCM_RATE_CONTINUOUS,
474 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
475 .data = & (const struct audioformat) {
476 .formats = SNDRV_PCM_FMTBIT_S16_LE,
481 .attributes = UAC_EP_CS_ATTR_FILL_MAX,
484 .rates = SNDRV_PCM_RATE_CONTINUOUS,
491 .type = QUIRK_MIDI_FIXED_ENDPOINT,
492 .data = & (const struct snd_usb_midi_endpoint_info) {
493 .out_cables = 0x0007,
504 USB_DEVICE(0x0582, 0x0002),
505 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
506 .vendor_name = "EDIROL",
507 .product_name = "UM-4",
508 .ifnum = QUIRK_ANY_INTERFACE,
509 .type = QUIRK_COMPOSITE,
510 .data = (const struct snd_usb_audio_quirk[]) {
513 .type = QUIRK_IGNORE_INTERFACE
517 .type = QUIRK_IGNORE_INTERFACE
521 .type = QUIRK_MIDI_FIXED_ENDPOINT,
522 .data = & (const struct snd_usb_midi_endpoint_info) {
523 .out_cables = 0x000f,
534 USB_DEVICE(0x0582, 0x0003),
535 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
536 .vendor_name = "Roland",
537 .product_name = "SC-8850",
538 .ifnum = QUIRK_ANY_INTERFACE,
539 .type = QUIRK_COMPOSITE,
540 .data = (const struct snd_usb_audio_quirk[]) {
543 .type = QUIRK_IGNORE_INTERFACE
547 .type = QUIRK_IGNORE_INTERFACE
551 .type = QUIRK_MIDI_FIXED_ENDPOINT,
552 .data = & (const struct snd_usb_midi_endpoint_info) {
553 .out_cables = 0x003f,
564 USB_DEVICE(0x0582, 0x0004),
565 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
566 .vendor_name = "Roland",
567 .product_name = "U-8",
568 .ifnum = QUIRK_ANY_INTERFACE,
569 .type = QUIRK_COMPOSITE,
570 .data = (const struct snd_usb_audio_quirk[]) {
573 .type = QUIRK_IGNORE_INTERFACE
577 .type = QUIRK_IGNORE_INTERFACE
581 .type = QUIRK_MIDI_FIXED_ENDPOINT,
582 .data = & (const struct snd_usb_midi_endpoint_info) {
583 .out_cables = 0x0005,
594 /* Has ID 0x0099 when not in "Advanced Driver" mode.
595 * The UM-2EX has only one input, but we cannot detect this. */
596 USB_DEVICE(0x0582, 0x0005),
597 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
598 .vendor_name = "EDIROL",
599 .product_name = "UM-2",
600 .ifnum = QUIRK_ANY_INTERFACE,
601 .type = QUIRK_COMPOSITE,
602 .data = (const struct snd_usb_audio_quirk[]) {
605 .type = QUIRK_IGNORE_INTERFACE
609 .type = QUIRK_IGNORE_INTERFACE
613 .type = QUIRK_MIDI_FIXED_ENDPOINT,
614 .data = & (const struct snd_usb_midi_endpoint_info) {
615 .out_cables = 0x0003,
626 USB_DEVICE(0x0582, 0x0007),
627 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
628 .vendor_name = "Roland",
629 .product_name = "SC-8820",
630 .ifnum = QUIRK_ANY_INTERFACE,
631 .type = QUIRK_COMPOSITE,
632 .data = (const struct snd_usb_audio_quirk[]) {
635 .type = QUIRK_IGNORE_INTERFACE
639 .type = QUIRK_IGNORE_INTERFACE
643 .type = QUIRK_MIDI_FIXED_ENDPOINT,
644 .data = & (const struct snd_usb_midi_endpoint_info) {
645 .out_cables = 0x0013,
656 USB_DEVICE(0x0582, 0x0008),
657 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
658 .vendor_name = "Roland",
659 .product_name = "PC-300",
660 .ifnum = QUIRK_ANY_INTERFACE,
661 .type = QUIRK_COMPOSITE,
662 .data = (const struct snd_usb_audio_quirk[]) {
665 .type = QUIRK_IGNORE_INTERFACE
669 .type = QUIRK_IGNORE_INTERFACE
673 .type = QUIRK_MIDI_FIXED_ENDPOINT,
674 .data = & (const struct snd_usb_midi_endpoint_info) {
675 .out_cables = 0x0001,
686 /* has ID 0x009d when not in "Advanced Driver" mode */
687 USB_DEVICE(0x0582, 0x0009),
688 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
689 .vendor_name = "EDIROL",
690 .product_name = "UM-1",
691 .ifnum = QUIRK_ANY_INTERFACE,
692 .type = QUIRK_COMPOSITE,
693 .data = (const struct snd_usb_audio_quirk[]) {
696 .type = QUIRK_IGNORE_INTERFACE
700 .type = QUIRK_IGNORE_INTERFACE
704 .type = QUIRK_MIDI_FIXED_ENDPOINT,
705 .data = & (const struct snd_usb_midi_endpoint_info) {
706 .out_cables = 0x0001,
717 USB_DEVICE(0x0582, 0x000b),
718 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
719 .vendor_name = "Roland",
720 .product_name = "SK-500",
721 .ifnum = QUIRK_ANY_INTERFACE,
722 .type = QUIRK_COMPOSITE,
723 .data = (const struct snd_usb_audio_quirk[]) {
726 .type = QUIRK_IGNORE_INTERFACE
730 .type = QUIRK_IGNORE_INTERFACE
734 .type = QUIRK_MIDI_FIXED_ENDPOINT,
735 .data = & (const struct snd_usb_midi_endpoint_info) {
736 .out_cables = 0x0013,
747 /* thanks to Emiliano Grilli <emillo@libero.it>
748 * for helping researching this data */
749 USB_DEVICE(0x0582, 0x000c),
750 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
751 .vendor_name = "Roland",
752 .product_name = "SC-D70",
753 .ifnum = QUIRK_ANY_INTERFACE,
754 .type = QUIRK_COMPOSITE,
755 .data = (const struct snd_usb_audio_quirk[]) {
758 .type = QUIRK_AUDIO_STANDARD_INTERFACE
762 .type = QUIRK_AUDIO_STANDARD_INTERFACE
766 .type = QUIRK_MIDI_FIXED_ENDPOINT,
767 .data = & (const struct snd_usb_midi_endpoint_info) {
768 .out_cables = 0x0007,
779 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
780 * If the advanced mode switch at the back of the unit is off, the
781 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
782 * but offers only 16-bit PCM.
783 * In advanced mode, the UA-5 will output S24_3LE samples (two
784 * channels) at the rate indicated on the front switch, including
785 * the 96kHz sample rate.
787 USB_DEVICE(0x0582, 0x0010),
788 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
789 .vendor_name = "EDIROL",
790 .product_name = "UA-5",
791 .ifnum = QUIRK_ANY_INTERFACE,
792 .type = QUIRK_COMPOSITE,
793 .data = (const struct snd_usb_audio_quirk[]) {
796 .type = QUIRK_AUDIO_STANDARD_INTERFACE
800 .type = QUIRK_AUDIO_STANDARD_INTERFACE
809 /* has ID 0x0013 when not in "Advanced Driver" mode */
810 USB_DEVICE(0x0582, 0x0012),
811 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
812 .vendor_name = "Roland",
813 .product_name = "XV-5050",
815 .type = QUIRK_MIDI_FIXED_ENDPOINT,
816 .data = & (const struct snd_usb_midi_endpoint_info) {
817 .out_cables = 0x0001,
823 /* has ID 0x0015 when not in "Advanced Driver" mode */
824 USB_DEVICE(0x0582, 0x0014),
825 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
826 .vendor_name = "EDIROL",
827 .product_name = "UM-880",
829 .type = QUIRK_MIDI_FIXED_ENDPOINT,
830 .data = & (const struct snd_usb_midi_endpoint_info) {
831 .out_cables = 0x01ff,
837 /* has ID 0x0017 when not in "Advanced Driver" mode */
838 USB_DEVICE(0x0582, 0x0016),
839 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
840 .vendor_name = "EDIROL",
841 .product_name = "SD-90",
842 .ifnum = QUIRK_ANY_INTERFACE,
843 .type = QUIRK_COMPOSITE,
844 .data = (const struct snd_usb_audio_quirk[]) {
847 .type = QUIRK_AUDIO_STANDARD_INTERFACE
851 .type = QUIRK_AUDIO_STANDARD_INTERFACE
855 .type = QUIRK_MIDI_FIXED_ENDPOINT,
856 .data = & (const struct snd_usb_midi_endpoint_info) {
857 .out_cables = 0x000f,
868 /* has ID 0x001c when not in "Advanced Driver" mode */
869 USB_DEVICE(0x0582, 0x001b),
870 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
871 .vendor_name = "Roland",
872 .product_name = "MMP-2",
873 .ifnum = QUIRK_ANY_INTERFACE,
874 .type = QUIRK_COMPOSITE,
875 .data = (const struct snd_usb_audio_quirk[]) {
878 .type = QUIRK_IGNORE_INTERFACE
882 .type = QUIRK_IGNORE_INTERFACE
886 .type = QUIRK_MIDI_FIXED_ENDPOINT,
887 .data = & (const struct snd_usb_midi_endpoint_info) {
888 .out_cables = 0x0001,
899 /* has ID 0x001e when not in "Advanced Driver" mode */
900 USB_DEVICE(0x0582, 0x001d),
901 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
902 .vendor_name = "Roland",
903 .product_name = "V-SYNTH",
905 .type = QUIRK_MIDI_FIXED_ENDPOINT,
906 .data = & (const struct snd_usb_midi_endpoint_info) {
907 .out_cables = 0x0001,
913 /* has ID 0x0024 when not in "Advanced Driver" mode */
914 USB_DEVICE(0x0582, 0x0023),
915 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
916 .vendor_name = "EDIROL",
917 .product_name = "UM-550",
919 .type = QUIRK_MIDI_FIXED_ENDPOINT,
920 .data = & (const struct snd_usb_midi_endpoint_info) {
921 .out_cables = 0x003f,
928 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
929 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
932 USB_DEVICE(0x0582, 0x0025),
933 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
934 .vendor_name = "EDIROL",
935 .product_name = "UA-20",
936 .ifnum = QUIRK_ANY_INTERFACE,
937 .type = QUIRK_COMPOSITE,
938 .data = (const struct snd_usb_audio_quirk[]) {
941 .type = QUIRK_IGNORE_INTERFACE
945 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
946 .data = & (const struct audioformat) {
947 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
955 .rates = SNDRV_PCM_RATE_CONTINUOUS,
962 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
963 .data = & (const struct audioformat) {
964 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
972 .rates = SNDRV_PCM_RATE_CONTINUOUS,
979 .type = QUIRK_MIDI_FIXED_ENDPOINT,
980 .data = & (const struct snd_usb_midi_endpoint_info) {
981 .out_cables = 0x0001,
992 /* has ID 0x0028 when not in "Advanced Driver" mode */
993 USB_DEVICE(0x0582, 0x0027),
994 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
995 .vendor_name = "EDIROL",
996 .product_name = "SD-20",
998 .type = QUIRK_MIDI_FIXED_ENDPOINT,
999 .data = & (const struct snd_usb_midi_endpoint_info) {
1000 .out_cables = 0x0003,
1006 /* has ID 0x002a when not in "Advanced Driver" mode */
1007 USB_DEVICE(0x0582, 0x0029),
1008 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1009 .vendor_name = "EDIROL",
1010 .product_name = "SD-80",
1012 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1013 .data = & (const struct snd_usb_midi_endpoint_info) {
1014 .out_cables = 0x000f,
1020 * This quirk is for the "Advanced" modes of the Edirol UA-700.
1021 * If the sample format switch is not in an advanced setting, the
1022 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
1023 * but offers only 16-bit PCM and no MIDI.
1025 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
1026 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1027 .vendor_name = "EDIROL",
1028 .product_name = "UA-700",
1029 .ifnum = QUIRK_ANY_INTERFACE,
1030 .type = QUIRK_COMPOSITE,
1031 .data = (const struct snd_usb_audio_quirk[]) {
1034 .type = QUIRK_AUDIO_EDIROL_UAXX
1038 .type = QUIRK_AUDIO_EDIROL_UAXX
1042 .type = QUIRK_AUDIO_EDIROL_UAXX
1051 /* has ID 0x002e when not in "Advanced Driver" mode */
1052 USB_DEVICE(0x0582, 0x002d),
1053 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1054 .vendor_name = "Roland",
1055 .product_name = "XV-2020",
1057 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1058 .data = & (const struct snd_usb_midi_endpoint_info) {
1059 .out_cables = 0x0001,
1065 /* has ID 0x0030 when not in "Advanced Driver" mode */
1066 USB_DEVICE(0x0582, 0x002f),
1067 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1068 .vendor_name = "Roland",
1069 .product_name = "VariOS",
1071 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1072 .data = & (const struct snd_usb_midi_endpoint_info) {
1073 .out_cables = 0x0007,
1079 /* has ID 0x0034 when not in "Advanced Driver" mode */
1080 USB_DEVICE(0x0582, 0x0033),
1081 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1082 .vendor_name = "EDIROL",
1083 .product_name = "PCR",
1085 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1086 .data = & (const struct snd_usb_midi_endpoint_info) {
1087 .out_cables = 0x0003,
1094 * Has ID 0x0038 when not in "Advanced Driver" mode;
1095 * later revisions use IDs 0x0054 and 0x00a2.
1097 USB_DEVICE(0x0582, 0x0037),
1098 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1099 .vendor_name = "Roland",
1100 .product_name = "Digital Piano",
1102 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1103 .data = & (const struct snd_usb_midi_endpoint_info) {
1104 .out_cables = 0x0001,
1111 * This quirk is for the "Advanced Driver" mode. If off, the GS-10
1112 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1115 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1116 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1117 .vendor_name = "BOSS",
1118 .product_name = "GS-10",
1119 .ifnum = QUIRK_ANY_INTERFACE,
1120 .type = QUIRK_COMPOSITE,
1121 .data = & (const struct snd_usb_audio_quirk[]) {
1124 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1128 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1132 .type = QUIRK_MIDI_STANDARD_INTERFACE
1141 /* has ID 0x0041 when not in "Advanced Driver" mode */
1142 USB_DEVICE(0x0582, 0x0040),
1143 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1144 .vendor_name = "Roland",
1145 .product_name = "GI-20",
1147 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1148 .data = & (const struct snd_usb_midi_endpoint_info) {
1149 .out_cables = 0x0001,
1155 /* has ID 0x0043 when not in "Advanced Driver" mode */
1156 USB_DEVICE(0x0582, 0x0042),
1157 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1158 .vendor_name = "Roland",
1159 .product_name = "RS-70",
1161 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1162 .data = & (const struct snd_usb_midi_endpoint_info) {
1163 .out_cables = 0x0001,
1169 /* has ID 0x0049 when not in "Advanced Driver" mode */
1170 USB_DEVICE(0x0582, 0x0047),
1171 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1172 /* .vendor_name = "EDIROL", */
1173 /* .product_name = "UR-80", */
1174 .ifnum = QUIRK_ANY_INTERFACE,
1175 .type = QUIRK_COMPOSITE,
1176 .data = (const struct snd_usb_audio_quirk[]) {
1177 /* in the 96 kHz modes, only interface 1 is there */
1180 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1184 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1193 /* has ID 0x004a when not in "Advanced Driver" mode */
1194 USB_DEVICE(0x0582, 0x0048),
1195 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1196 /* .vendor_name = "EDIROL", */
1197 /* .product_name = "UR-80", */
1199 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1200 .data = & (const struct snd_usb_midi_endpoint_info) {
1201 .out_cables = 0x0003,
1207 /* has ID 0x004e when not in "Advanced Driver" mode */
1208 USB_DEVICE(0x0582, 0x004c),
1209 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1210 .vendor_name = "EDIROL",
1211 .product_name = "PCR-A",
1212 .ifnum = QUIRK_ANY_INTERFACE,
1213 .type = QUIRK_COMPOSITE,
1214 .data = (const struct snd_usb_audio_quirk[]) {
1217 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1221 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1230 /* has ID 0x004f when not in "Advanced Driver" mode */
1231 USB_DEVICE(0x0582, 0x004d),
1232 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1233 .vendor_name = "EDIROL",
1234 .product_name = "PCR-A",
1236 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1237 .data = & (const struct snd_usb_midi_endpoint_info) {
1238 .out_cables = 0x0003,
1245 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1246 * is standard compliant, but has only 16-bit PCM.
1248 USB_DEVICE(0x0582, 0x0050),
1249 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1250 .vendor_name = "EDIROL",
1251 .product_name = "UA-3FX",
1252 .ifnum = QUIRK_ANY_INTERFACE,
1253 .type = QUIRK_COMPOSITE,
1254 .data = (const struct snd_usb_audio_quirk[]) {
1257 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1261 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1270 USB_DEVICE(0x0582, 0x0052),
1271 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1272 .vendor_name = "EDIROL",
1273 .product_name = "UM-1SX",
1275 .type = QUIRK_MIDI_STANDARD_INTERFACE
1279 USB_DEVICE(0x0582, 0x0060),
1280 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1281 .vendor_name = "Roland",
1282 .product_name = "EXR Series",
1284 .type = QUIRK_MIDI_STANDARD_INTERFACE
1288 /* has ID 0x0066 when not in "Advanced Driver" mode */
1289 USB_DEVICE(0x0582, 0x0064),
1290 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1291 /* .vendor_name = "EDIROL", */
1292 /* .product_name = "PCR-1", */
1293 .ifnum = QUIRK_ANY_INTERFACE,
1294 .type = QUIRK_COMPOSITE,
1295 .data = (const struct snd_usb_audio_quirk[]) {
1298 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1302 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1311 /* has ID 0x0067 when not in "Advanced Driver" mode */
1312 USB_DEVICE(0x0582, 0x0065),
1313 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1314 /* .vendor_name = "EDIROL", */
1315 /* .product_name = "PCR-1", */
1317 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1318 .data = & (const struct snd_usb_midi_endpoint_info) {
1319 .out_cables = 0x0001,
1325 /* has ID 0x006e when not in "Advanced Driver" mode */
1326 USB_DEVICE(0x0582, 0x006d),
1327 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1328 .vendor_name = "Roland",
1329 .product_name = "FANTOM-X",
1331 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1332 .data = & (const struct snd_usb_midi_endpoint_info) {
1333 .out_cables = 0x0001,
1339 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1340 * If the switch is not in an advanced setting, the UA-25 has
1341 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1342 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1344 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1345 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1346 .vendor_name = "EDIROL",
1347 .product_name = "UA-25",
1348 .ifnum = QUIRK_ANY_INTERFACE,
1349 .type = QUIRK_COMPOSITE,
1350 .data = (const struct snd_usb_audio_quirk[]) {
1353 .type = QUIRK_AUDIO_EDIROL_UAXX
1357 .type = QUIRK_AUDIO_EDIROL_UAXX
1361 .type = QUIRK_AUDIO_EDIROL_UAXX
1370 /* has ID 0x0076 when not in "Advanced Driver" mode */
1371 USB_DEVICE(0x0582, 0x0075),
1372 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1373 .vendor_name = "BOSS",
1374 .product_name = "DR-880",
1376 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1377 .data = & (const struct snd_usb_midi_endpoint_info) {
1378 .out_cables = 0x0001,
1384 /* has ID 0x007b when not in "Advanced Driver" mode */
1385 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1386 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1387 .vendor_name = "Roland",
1388 /* "RD" or "RD-700SX"? */
1390 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1391 .data = & (const struct snd_usb_midi_endpoint_info) {
1392 .out_cables = 0x0003,
1398 /* has ID 0x0081 when not in "Advanced Driver" mode */
1399 USB_DEVICE(0x0582, 0x0080),
1400 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1401 .vendor_name = "Roland",
1402 .product_name = "G-70",
1404 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1405 .data = & (const struct snd_usb_midi_endpoint_info) {
1406 .out_cables = 0x0001,
1412 /* has ID 0x008c when not in "Advanced Driver" mode */
1413 USB_DEVICE(0x0582, 0x008b),
1414 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1415 .vendor_name = "EDIROL",
1416 .product_name = "PC-50",
1418 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1419 .data = & (const struct snd_usb_midi_endpoint_info) {
1420 .out_cables = 0x0001,
1427 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1428 * is standard compliant, but has only 16-bit PCM and no MIDI.
1430 USB_DEVICE(0x0582, 0x00a3),
1431 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1432 .vendor_name = "EDIROL",
1433 .product_name = "UA-4FX",
1434 .ifnum = QUIRK_ANY_INTERFACE,
1435 .type = QUIRK_COMPOSITE,
1436 .data = (const struct snd_usb_audio_quirk[]) {
1439 .type = QUIRK_AUDIO_EDIROL_UAXX
1443 .type = QUIRK_AUDIO_EDIROL_UAXX
1447 .type = QUIRK_AUDIO_EDIROL_UAXX
1457 USB_DEVICE(0x0582, 0x00c4),
1458 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1459 .ifnum = QUIRK_ANY_INTERFACE,
1460 .type = QUIRK_COMPOSITE,
1461 .data = (const struct snd_usb_audio_quirk[]) {
1464 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1468 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1472 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1473 .data = & (const struct snd_usb_midi_endpoint_info) {
1474 .out_cables = 0x0001,
1485 /* Advanced modes of the Edirol UA-25EX.
1486 * For the standard mode, UA-25EX has ID 0582:00e7, which
1487 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1489 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1490 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1491 .vendor_name = "EDIROL",
1492 .product_name = "UA-25EX",
1493 .ifnum = QUIRK_ANY_INTERFACE,
1494 .type = QUIRK_COMPOSITE,
1495 .data = (const struct snd_usb_audio_quirk[]) {
1498 .type = QUIRK_AUDIO_EDIROL_UAXX
1502 .type = QUIRK_AUDIO_EDIROL_UAXX
1506 .type = QUIRK_AUDIO_EDIROL_UAXX
1516 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1517 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1519 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1520 .data = & (const struct snd_usb_midi_endpoint_info) {
1521 .out_cables = 0x0007,
1528 USB_DEVICE(0x0582, 0x0113),
1529 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1530 .ifnum = QUIRK_ANY_INTERFACE,
1531 .type = QUIRK_COMPOSITE,
1532 .data = (const struct snd_usb_audio_quirk[]) {
1535 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1539 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1543 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1544 .data = & (const struct snd_usb_midi_endpoint_info) {
1545 .out_cables = 0x0001,
1556 /* only 44.1 kHz works at the moment */
1557 USB_DEVICE(0x0582, 0x0120),
1558 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1559 /* .vendor_name = "Roland", */
1560 /* .product_name = "OCTO-CAPTURE", */
1561 .ifnum = QUIRK_ANY_INTERFACE,
1562 .type = QUIRK_COMPOSITE,
1563 .data = (const struct snd_usb_audio_quirk[]) {
1566 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1567 .data = & (const struct audioformat) {
1568 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1575 .rates = SNDRV_PCM_RATE_44100,
1579 .rate_table = (unsigned int[]) { 44100 }
1584 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1585 .data = & (const struct audioformat) {
1586 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1593 .rates = SNDRV_PCM_RATE_44100,
1597 .rate_table = (unsigned int[]) { 44100 }
1602 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1603 .data = & (const struct snd_usb_midi_endpoint_info) {
1604 .out_cables = 0x0001,
1610 .type = QUIRK_IGNORE_INTERFACE
1614 .type = QUIRK_IGNORE_INTERFACE
1623 /* only 44.1 kHz works at the moment */
1624 USB_DEVICE(0x0582, 0x012f),
1625 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1626 /* .vendor_name = "Roland", */
1627 /* .product_name = "QUAD-CAPTURE", */
1628 .ifnum = QUIRK_ANY_INTERFACE,
1629 .type = QUIRK_COMPOSITE,
1630 .data = (const struct snd_usb_audio_quirk[]) {
1633 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1634 .data = & (const struct audioformat) {
1635 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1642 .rates = SNDRV_PCM_RATE_44100,
1646 .rate_table = (unsigned int[]) { 44100 }
1651 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1652 .data = & (const struct audioformat) {
1653 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1660 .rates = SNDRV_PCM_RATE_44100,
1664 .rate_table = (unsigned int[]) { 44100 }
1669 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1670 .data = & (const struct snd_usb_midi_endpoint_info) {
1671 .out_cables = 0x0001,
1677 .type = QUIRK_IGNORE_INTERFACE
1681 .type = QUIRK_IGNORE_INTERFACE
1690 USB_DEVICE(0x0582, 0x0159),
1691 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1692 /* .vendor_name = "Roland", */
1693 /* .product_name = "UA-22", */
1694 .ifnum = QUIRK_ANY_INTERFACE,
1695 .type = QUIRK_COMPOSITE,
1696 .data = (const struct snd_usb_audio_quirk[]) {
1699 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1703 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1707 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1708 .data = & (const struct snd_usb_midi_endpoint_info) {
1709 .out_cables = 0x0001,
1719 /* this catches most recent vendor-specific Roland devices */
1721 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1722 USB_DEVICE_ID_MATCH_INT_CLASS,
1724 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1725 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1726 .ifnum = QUIRK_ANY_INTERFACE,
1727 .type = QUIRK_AUTODETECT
1731 /* Guillemot devices */
1734 * This is for the "Windows Edition" where the external MIDI ports are
1735 * the only MIDI ports; the control data is reported through HID
1736 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard
1737 * compliant USB MIDI ports for external MIDI and controls.
1739 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1740 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1741 .vendor_name = "Hercules",
1742 .product_name = "DJ Console (WE)",
1744 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1745 .data = & (const struct snd_usb_midi_endpoint_info) {
1746 .out_cables = 0x0001,
1752 /* Midiman/M-Audio devices */
1754 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1755 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1756 .vendor_name = "M-Audio",
1757 .product_name = "MidiSport 2x2",
1758 .ifnum = QUIRK_ANY_INTERFACE,
1759 .type = QUIRK_MIDI_MIDIMAN,
1760 .data = & (const struct snd_usb_midi_endpoint_info) {
1761 .out_cables = 0x0003,
1767 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1768 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1769 .vendor_name = "M-Audio",
1770 .product_name = "MidiSport 1x1",
1771 .ifnum = QUIRK_ANY_INTERFACE,
1772 .type = QUIRK_MIDI_MIDIMAN,
1773 .data = & (const struct snd_usb_midi_endpoint_info) {
1774 .out_cables = 0x0001,
1780 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1781 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1782 .vendor_name = "M-Audio",
1783 .product_name = "Keystation",
1784 .ifnum = QUIRK_ANY_INTERFACE,
1785 .type = QUIRK_MIDI_MIDIMAN,
1786 .data = & (const struct snd_usb_midi_endpoint_info) {
1787 .out_cables = 0x0001,
1793 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1794 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1795 .vendor_name = "M-Audio",
1796 .product_name = "MidiSport 4x4",
1797 .ifnum = QUIRK_ANY_INTERFACE,
1798 .type = QUIRK_MIDI_MIDIMAN,
1799 .data = & (const struct snd_usb_midi_endpoint_info) {
1800 .out_cables = 0x000f,
1807 * For hardware revision 1.05; in the later revisions (1.10 and
1808 * 1.21), 0x1031 is the ID for the device without firmware.
1809 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1811 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1812 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1813 .vendor_name = "M-Audio",
1814 .product_name = "MidiSport 8x8",
1815 .ifnum = QUIRK_ANY_INTERFACE,
1816 .type = QUIRK_MIDI_MIDIMAN,
1817 .data = & (const struct snd_usb_midi_endpoint_info) {
1818 .out_cables = 0x01ff,
1824 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1825 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1826 .vendor_name = "M-Audio",
1827 .product_name = "MidiSport 8x8",
1828 .ifnum = QUIRK_ANY_INTERFACE,
1829 .type = QUIRK_MIDI_MIDIMAN,
1830 .data = & (const struct snd_usb_midi_endpoint_info) {
1831 .out_cables = 0x01ff,
1837 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1838 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1839 .vendor_name = "M-Audio",
1840 .product_name = "MidiSport 2x4",
1841 .ifnum = QUIRK_ANY_INTERFACE,
1842 .type = QUIRK_MIDI_MIDIMAN,
1843 .data = & (const struct snd_usb_midi_endpoint_info) {
1844 .out_cables = 0x000f,
1850 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1851 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1852 .vendor_name = "M-Audio",
1853 .product_name = "Quattro",
1854 .ifnum = QUIRK_ANY_INTERFACE,
1855 .type = QUIRK_COMPOSITE,
1856 .data = & (const struct snd_usb_audio_quirk[]) {
1858 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1859 * and share endpoints with the other interfaces.
1860 * Ignore them. The other interfaces can do 24 bits,
1861 * but captured samples are big-endian (see usbaudio.c).
1865 .type = QUIRK_IGNORE_INTERFACE
1869 .type = QUIRK_IGNORE_INTERFACE
1873 .type = QUIRK_IGNORE_INTERFACE
1877 .type = QUIRK_IGNORE_INTERFACE
1881 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1885 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1889 .type = QUIRK_IGNORE_INTERFACE
1893 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1897 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1901 .type = QUIRK_MIDI_MIDIMAN,
1902 .data = & (const struct snd_usb_midi_endpoint_info) {
1903 .out_cables = 0x0001,
1914 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1915 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1916 .vendor_name = "M-Audio",
1917 .product_name = "AudioPhile",
1919 .type = QUIRK_MIDI_MIDIMAN,
1920 .data = & (const struct snd_usb_midi_endpoint_info) {
1921 .out_cables = 0x0001,
1927 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1928 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1929 .vendor_name = "M-Audio",
1930 .product_name = "Ozone",
1932 .type = QUIRK_MIDI_MIDIMAN,
1933 .data = & (const struct snd_usb_midi_endpoint_info) {
1934 .out_cables = 0x0001,
1940 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1941 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1942 .vendor_name = "M-Audio",
1943 .product_name = "OmniStudio",
1944 .ifnum = QUIRK_ANY_INTERFACE,
1945 .type = QUIRK_COMPOSITE,
1946 .data = & (const struct snd_usb_audio_quirk[]) {
1949 .type = QUIRK_IGNORE_INTERFACE
1953 .type = QUIRK_IGNORE_INTERFACE
1957 .type = QUIRK_IGNORE_INTERFACE
1961 .type = QUIRK_IGNORE_INTERFACE
1965 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1969 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1973 .type = QUIRK_IGNORE_INTERFACE
1977 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1981 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1985 .type = QUIRK_MIDI_MIDIMAN,
1986 .data = & (const struct snd_usb_midi_endpoint_info) {
1987 .out_cables = 0x0001,
1998 USB_DEVICE(0x0763, 0x2019),
1999 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2000 /* .vendor_name = "M-Audio", */
2001 /* .product_name = "Ozone Academic", */
2002 .ifnum = QUIRK_ANY_INTERFACE,
2003 .type = QUIRK_COMPOSITE,
2004 .data = & (const struct snd_usb_audio_quirk[]) {
2007 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2011 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2015 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2019 .type = QUIRK_MIDI_MIDIMAN,
2020 .data = & (const struct snd_usb_midi_endpoint_info) {
2021 .out_cables = 0x0001,
2032 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2033 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2034 /* .vendor_name = "M-Audio", */
2035 /* .product_name = "Fast Track C400", */
2036 .ifnum = QUIRK_ANY_INTERFACE,
2037 .type = QUIRK_COMPOSITE,
2038 .data = &(const struct snd_usb_audio_quirk[]) {
2041 .type = QUIRK_AUDIO_STANDARD_MIXER,
2046 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2047 .data = &(const struct audioformat) {
2048 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2053 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2056 .rates = SNDRV_PCM_RATE_44100 |
2057 SNDRV_PCM_RATE_48000 |
2058 SNDRV_PCM_RATE_88200 |
2059 SNDRV_PCM_RATE_96000,
2063 .rate_table = (unsigned int[]) {
2064 44100, 48000, 88200, 96000
2072 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2073 .data = &(const struct audioformat) {
2074 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2079 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2082 .rates = SNDRV_PCM_RATE_44100 |
2083 SNDRV_PCM_RATE_48000 |
2084 SNDRV_PCM_RATE_88200 |
2085 SNDRV_PCM_RATE_96000,
2089 .rate_table = (unsigned int[]) {
2090 44100, 48000, 88200, 96000
2097 .ifnum = -1 /* Interface = 4 */
2103 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2104 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2105 /* .vendor_name = "M-Audio", */
2106 /* .product_name = "Fast Track C600", */
2107 .ifnum = QUIRK_ANY_INTERFACE,
2108 .type = QUIRK_COMPOSITE,
2109 .data = &(const struct snd_usb_audio_quirk[]) {
2112 .type = QUIRK_AUDIO_STANDARD_MIXER,
2117 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2118 .data = &(const struct audioformat) {
2119 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2124 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2127 .rates = SNDRV_PCM_RATE_44100 |
2128 SNDRV_PCM_RATE_48000 |
2129 SNDRV_PCM_RATE_88200 |
2130 SNDRV_PCM_RATE_96000,
2134 .rate_table = (unsigned int[]) {
2135 44100, 48000, 88200, 96000
2143 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2144 .data = &(const struct audioformat) {
2145 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2150 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2153 .rates = SNDRV_PCM_RATE_44100 |
2154 SNDRV_PCM_RATE_48000 |
2155 SNDRV_PCM_RATE_88200 |
2156 SNDRV_PCM_RATE_96000,
2160 .rate_table = (unsigned int[]) {
2161 44100, 48000, 88200, 96000
2168 .ifnum = -1 /* Interface = 4 */
2174 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2175 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2176 /* .vendor_name = "M-Audio", */
2177 /* .product_name = "Fast Track Ultra", */
2178 .ifnum = QUIRK_ANY_INTERFACE,
2179 .type = QUIRK_COMPOSITE,
2180 .data = & (const struct snd_usb_audio_quirk[]) {
2183 .type = QUIRK_AUDIO_STANDARD_MIXER,
2187 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2188 .data = & (const struct audioformat) {
2189 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2194 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2197 .rates = SNDRV_PCM_RATE_44100 |
2198 SNDRV_PCM_RATE_48000 |
2199 SNDRV_PCM_RATE_88200 |
2200 SNDRV_PCM_RATE_96000,
2204 .rate_table = (unsigned int[]) {
2205 44100, 48000, 88200, 96000
2211 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2212 .data = & (const struct audioformat) {
2213 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2218 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2221 .rates = SNDRV_PCM_RATE_44100 |
2222 SNDRV_PCM_RATE_48000 |
2223 SNDRV_PCM_RATE_88200 |
2224 SNDRV_PCM_RATE_96000,
2228 .rate_table = (unsigned int[]) {
2229 44100, 48000, 88200, 96000
2233 /* interface 3 (MIDI) is standard compliant */
2241 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2242 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2243 /* .vendor_name = "M-Audio", */
2244 /* .product_name = "Fast Track Ultra 8R", */
2245 .ifnum = QUIRK_ANY_INTERFACE,
2246 .type = QUIRK_COMPOSITE,
2247 .data = & (const struct snd_usb_audio_quirk[]) {
2250 .type = QUIRK_AUDIO_STANDARD_MIXER,
2254 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2255 .data = & (const struct audioformat) {
2256 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2261 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2264 .rates = SNDRV_PCM_RATE_44100 |
2265 SNDRV_PCM_RATE_48000 |
2266 SNDRV_PCM_RATE_88200 |
2267 SNDRV_PCM_RATE_96000,
2271 .rate_table = (unsigned int[]) {
2272 44100, 48000, 88200, 96000
2278 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2279 .data = & (const struct audioformat) {
2280 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2285 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2288 .rates = SNDRV_PCM_RATE_44100 |
2289 SNDRV_PCM_RATE_48000 |
2290 SNDRV_PCM_RATE_88200 |
2291 SNDRV_PCM_RATE_96000,
2295 .rate_table = (unsigned int[]) {
2296 44100, 48000, 88200, 96000
2300 /* interface 3 (MIDI) is standard compliant */
2310 USB_DEVICE(0x07cf, 0x6801),
2311 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2312 .vendor_name = "Casio",
2313 .product_name = "PL-40R",
2315 .type = QUIRK_MIDI_YAMAHA
2319 /* this ID is used by several devices without a product ID */
2320 USB_DEVICE(0x07cf, 0x6802),
2321 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2322 .vendor_name = "Casio",
2323 .product_name = "Keyboard",
2325 .type = QUIRK_MIDI_YAMAHA
2329 /* Mark of the Unicorn devices */
2331 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2332 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2333 USB_DEVICE_ID_MATCH_PRODUCT |
2334 USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2336 .idProduct = 0x0001,
2337 .bDeviceSubClass = 2,
2338 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2339 .vendor_name = "MOTU",
2340 .product_name = "Fastlane",
2341 .ifnum = QUIRK_ANY_INTERFACE,
2342 .type = QUIRK_COMPOSITE,
2343 .data = & (const struct snd_usb_audio_quirk[]) {
2346 .type = QUIRK_MIDI_RAW_BYTES
2350 .type = QUIRK_IGNORE_INTERFACE
2359 /* Emagic devices */
2361 USB_DEVICE(0x086a, 0x0001),
2362 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2363 .vendor_name = "Emagic",
2364 .product_name = "Unitor8",
2366 .type = QUIRK_MIDI_EMAGIC,
2367 .data = & (const struct snd_usb_midi_endpoint_info) {
2368 .out_cables = 0x80ff,
2374 USB_DEVICE(0x086a, 0x0002),
2375 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2376 .vendor_name = "Emagic",
2377 /* .product_name = "AMT8", */
2379 .type = QUIRK_MIDI_EMAGIC,
2380 .data = & (const struct snd_usb_midi_endpoint_info) {
2381 .out_cables = 0x80ff,
2387 USB_DEVICE(0x086a, 0x0003),
2388 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2389 .vendor_name = "Emagic",
2390 /* .product_name = "MT4", */
2392 .type = QUIRK_MIDI_EMAGIC,
2393 .data = & (const struct snd_usb_midi_endpoint_info) {
2394 .out_cables = 0x800f,
2402 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2403 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2404 .vendor_name = "KORG, Inc.",
2405 /* .product_name = "PANDORA PX5D", */
2407 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2412 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2413 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2414 .vendor_name = "KORG, Inc.",
2415 /* .product_name = "ToneLab ST", */
2417 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2422 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0204),
2423 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2424 .vendor_name = "KORG, Inc.",
2425 /* .product_name = "ToneLab EX", */
2427 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2433 USB_DEVICE(0x09e8, 0x0062),
2434 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2435 .vendor_name = "AKAI",
2436 .product_name = "MPD16",
2438 .type = QUIRK_MIDI_AKAI,
2443 /* Akai MPC Element */
2444 USB_DEVICE(0x09e8, 0x0021),
2445 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2446 .ifnum = QUIRK_ANY_INTERFACE,
2447 .type = QUIRK_COMPOSITE,
2448 .data = & (const struct snd_usb_audio_quirk[]) {
2451 .type = QUIRK_IGNORE_INTERFACE
2455 .type = QUIRK_MIDI_STANDARD_INTERFACE
2464 /* Steinberg devices */
2467 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2468 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2469 .ifnum = QUIRK_ANY_INTERFACE,
2470 .type = QUIRK_COMPOSITE,
2471 .data = & (const struct snd_usb_audio_quirk[]) {
2474 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2478 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2482 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2486 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2487 .data = &(const struct snd_usb_midi_endpoint_info) {
2488 .out_cables = 0x0001,
2500 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2501 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2502 .ifnum = QUIRK_ANY_INTERFACE,
2503 .type = QUIRK_COMPOSITE,
2504 .data = & (const struct snd_usb_audio_quirk[]) {
2507 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2511 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2515 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2519 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2520 .data = &(const struct snd_usb_midi_endpoint_info) {
2521 .out_cables = 0x0001,
2532 /* TerraTec devices */
2534 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2535 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2536 .vendor_name = "TerraTec",
2537 .product_name = "PHASE 26",
2539 .type = QUIRK_MIDI_STANDARD_INTERFACE
2543 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2544 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2545 .vendor_name = "TerraTec",
2546 .product_name = "PHASE 26",
2548 .type = QUIRK_MIDI_STANDARD_INTERFACE
2552 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2553 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2554 .vendor_name = "TerraTec",
2555 .product_name = "PHASE 26",
2557 .type = QUIRK_MIDI_STANDARD_INTERFACE
2561 USB_DEVICE(0x0ccd, 0x0035),
2562 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2563 .vendor_name = "Miditech",
2564 .product_name = "Play'n Roll",
2566 .type = QUIRK_MIDI_CME
2570 /* Novation EMS devices */
2572 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2573 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2574 .vendor_name = "Novation",
2575 .product_name = "ReMOTE Audio/XStation",
2577 .type = QUIRK_MIDI_NOVATION
2581 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2582 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2583 .vendor_name = "Novation",
2584 .product_name = "Speedio",
2586 .type = QUIRK_MIDI_NOVATION
2590 USB_DEVICE(0x1235, 0x000a),
2591 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2592 /* .vendor_name = "Novation", */
2593 /* .product_name = "Nocturn", */
2595 .type = QUIRK_MIDI_RAW_BYTES
2599 USB_DEVICE(0x1235, 0x000e),
2600 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2601 /* .vendor_name = "Novation", */
2602 /* .product_name = "Launchpad", */
2604 .type = QUIRK_MIDI_RAW_BYTES
2608 USB_DEVICE(0x1235, 0x0010),
2609 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2610 .vendor_name = "Focusrite",
2611 .product_name = "Saffire 6 USB",
2612 .ifnum = QUIRK_ANY_INTERFACE,
2613 .type = QUIRK_COMPOSITE,
2614 .data = (const struct snd_usb_audio_quirk[]) {
2617 .type = QUIRK_AUDIO_STANDARD_MIXER,
2621 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2622 .data = &(const struct audioformat) {
2623 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2628 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2630 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2632 .maxpacksize = 0x024c,
2633 .rates = SNDRV_PCM_RATE_44100 |
2634 SNDRV_PCM_RATE_48000,
2638 .rate_table = (unsigned int[]) {
2645 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2646 .data = &(const struct audioformat) {
2647 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2654 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2656 .maxpacksize = 0x0126,
2657 .rates = SNDRV_PCM_RATE_44100 |
2658 SNDRV_PCM_RATE_48000,
2662 .rate_table = (unsigned int[]) {
2669 .type = QUIRK_MIDI_RAW_BYTES
2678 USB_DEVICE(0x1235, 0x0018),
2679 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2680 .vendor_name = "Novation",
2681 .product_name = "Twitch",
2682 .ifnum = QUIRK_ANY_INTERFACE,
2683 .type = QUIRK_COMPOSITE,
2684 .data = (const struct snd_usb_audio_quirk[]) {
2687 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2688 .data = & (const struct audioformat) {
2689 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2694 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2696 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2697 .rates = SNDRV_PCM_RATE_44100 |
2698 SNDRV_PCM_RATE_48000,
2702 .rate_table = (unsigned int[]) {
2709 .type = QUIRK_MIDI_RAW_BYTES
2718 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2719 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2720 .vendor_name = "Novation",
2721 .product_name = "ReMOTE25",
2723 .type = QUIRK_MIDI_NOVATION
2727 /* Access Music devices */
2729 /* VirusTI Desktop */
2730 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2731 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2732 .ifnum = QUIRK_ANY_INTERFACE,
2733 .type = QUIRK_COMPOSITE,
2734 .data = &(const struct snd_usb_audio_quirk[]) {
2737 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2738 .data = &(const struct snd_usb_midi_endpoint_info) {
2739 .out_cables = 0x0003,
2745 .type = QUIRK_IGNORE_INTERFACE
2754 /* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */
2756 USB_DEVICE(0x17aa, 0x1046),
2757 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2758 .ifnum = QUIRK_ANY_INTERFACE,
2759 .type = QUIRK_SETUP_DISABLE_AUTOSUSPEND
2762 /* Lenovo ThinkStation P620 Internal Speaker + Front Headset */
2764 USB_DEVICE(0x17aa, 0x104d),
2765 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2766 .ifnum = QUIRK_ANY_INTERFACE,
2767 .type = QUIRK_SETUP_DISABLE_AUTOSUSPEND
2771 /* Native Instruments MK2 series */
2773 /* Komplete Audio 6 */
2774 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2776 .idProduct = 0x1000,
2779 /* Traktor Audio 6 */
2780 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2782 .idProduct = 0x1010,
2785 /* Traktor Audio 10 */
2786 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2788 .idProduct = 0x1020,
2791 /* QinHeng devices */
2793 USB_DEVICE(0x1a86, 0x752d),
2794 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2795 .vendor_name = "QinHeng",
2796 .product_name = "CH345",
2798 .type = QUIRK_MIDI_CH345
2802 /* KeithMcMillen Stringport */
2803 { USB_DEVICE(0x1f38, 0x0001) }, /* FIXME: should be more restrictive matching */
2805 /* Miditech devices */
2807 USB_DEVICE(0x4752, 0x0011),
2808 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2809 .vendor_name = "Miditech",
2810 .product_name = "Midistart-2",
2812 .type = QUIRK_MIDI_CME
2816 /* Central Music devices */
2818 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2819 USB_DEVICE(0x7104, 0x2202),
2820 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2822 .type = QUIRK_MIDI_CME
2827 * Auvitek au0828 devices with audio interface.
2828 * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
2829 * Please notice that some drivers are DVB only, and don't need to be
2830 * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2833 #define AU0828_DEVICE(vid, pid, vname, pname) { \
2834 USB_AUDIO_DEVICE(vid, pid), \
2835 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2836 .vendor_name = vname, \
2837 .product_name = pname, \
2838 .ifnum = QUIRK_ANY_INTERFACE, \
2839 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
2840 .shares_media_device = 1, \
2844 AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2845 AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2846 AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
2847 AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
2848 AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
2849 AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
2850 AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
2851 AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
2852 AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
2853 AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
2854 AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
2855 AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
2856 AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
2857 AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
2858 AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
2859 AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
2860 AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
2862 /* Syntek STK1160 */
2864 USB_AUDIO_DEVICE(0x05e1, 0x0408),
2865 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2866 .vendor_name = "Syntek",
2867 .product_name = "STK1160",
2868 .ifnum = QUIRK_ANY_INTERFACE,
2869 .type = QUIRK_AUDIO_ALIGN_TRANSFER
2873 /* Digidesign Mbox */
2875 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2876 USB_DEVICE(0x0dba, 0x1000),
2877 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2878 .vendor_name = "Digidesign",
2879 .product_name = "MBox",
2880 .ifnum = QUIRK_ANY_INTERFACE,
2881 .type = QUIRK_COMPOSITE,
2882 .data = (const struct snd_usb_audio_quirk[]){
2885 .type = QUIRK_AUDIO_STANDARD_MIXER,
2889 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2890 .data = &(const struct audioformat) {
2891 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2898 .ep_attr = USB_ENDPOINT_XFER_ISOC |
2899 USB_ENDPOINT_SYNC_SYNC,
2900 .maxpacksize = 0x130,
2901 .rates = SNDRV_PCM_RATE_48000,
2905 .rate_table = (unsigned int[]) {
2912 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2913 .data = &(const struct audioformat) {
2914 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2921 .ep_attr = USB_ENDPOINT_XFER_ISOC |
2922 USB_ENDPOINT_SYNC_ASYNC,
2923 .maxpacksize = 0x130,
2924 .rates = SNDRV_PCM_RATE_48000,
2928 .rate_table = (unsigned int[]) {
2940 /* DIGIDESIGN MBOX 2 */
2942 USB_DEVICE(0x0dba, 0x3000),
2943 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2944 .vendor_name = "Digidesign",
2945 .product_name = "Mbox 2",
2946 .ifnum = QUIRK_ANY_INTERFACE,
2947 .type = QUIRK_COMPOSITE,
2948 .data = (const struct snd_usb_audio_quirk[]) {
2951 .type = QUIRK_IGNORE_INTERFACE
2955 .type = QUIRK_IGNORE_INTERFACE
2959 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2960 .data = &(const struct audioformat) {
2961 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2968 .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
2969 .rates = SNDRV_PCM_RATE_48000,
2973 .rate_table = (unsigned int[]) {
2980 .type = QUIRK_IGNORE_INTERFACE
2984 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2985 .data = &(const struct audioformat) {
2986 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2991 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2993 .ep_attr = USB_ENDPOINT_SYNC_SYNC,
2994 .rates = SNDRV_PCM_RATE_48000,
2998 .rate_table = (unsigned int[]) {
3005 .type = QUIRK_IGNORE_INTERFACE
3009 .type = QUIRK_MIDI_MIDIMAN,
3010 .data = &(const struct snd_usb_midi_endpoint_info) {
3012 .out_cables = 0x0001,
3014 .in_interval = 0x01,
3025 /* Tascam US122 MKII - playback-only support */
3026 USB_DEVICE_VENDOR_SPEC(0x0644, 0x8021),
3027 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3028 .vendor_name = "TASCAM",
3029 .product_name = "US122 MKII",
3030 .ifnum = QUIRK_ANY_INTERFACE,
3031 .type = QUIRK_COMPOSITE,
3032 .data = (const struct snd_usb_audio_quirk[]) {
3035 .type = QUIRK_IGNORE_INTERFACE
3039 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3040 .data = &(const struct audioformat) {
3041 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3046 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3048 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3049 .rates = SNDRV_PCM_RATE_44100 |
3050 SNDRV_PCM_RATE_48000 |
3051 SNDRV_PCM_RATE_88200 |
3052 SNDRV_PCM_RATE_96000,
3056 .rate_table = (unsigned int[]) {
3057 44100, 48000, 88200, 96000
3068 /* Microsoft XboxLive Headset/Xbox Communicator */
3070 USB_DEVICE(0x045e, 0x0283),
3071 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3072 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3073 .vendor_name = "Microsoft",
3074 .product_name = "XboxLive Headset/Xbox Communicator",
3075 .ifnum = QUIRK_ANY_INTERFACE,
3076 .type = QUIRK_COMPOSITE,
3077 .data = &(const struct snd_usb_audio_quirk[]) {
3081 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3082 .data = &(const struct audioformat) {
3083 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3091 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3099 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3100 .data = &(const struct audioformat) {
3101 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3109 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3123 USB_DEVICE(0x200c, 0x100b),
3124 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3125 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3126 .ifnum = QUIRK_ANY_INTERFACE,
3127 .type = QUIRK_COMPOSITE,
3128 .data = &(const struct snd_usb_audio_quirk[]) {
3131 .type = QUIRK_AUDIO_STANDARD_MIXER,
3135 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3136 .data = &(const struct audioformat) {
3137 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3142 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3144 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3145 .rates = SNDRV_PCM_RATE_44100 |
3146 SNDRV_PCM_RATE_48000,
3150 .rate_table = (unsigned int[]) {
3164 * ZOOM R16/24 in audio interface mode.
3165 * Playback requires an extra four byte LE length indicator
3166 * at the start of each isochronous packet. This quirk is
3167 * enabled in create_standard_audio_quirk().
3169 USB_DEVICE(0x1686, 0x00dd),
3170 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3171 .ifnum = QUIRK_ANY_INTERFACE,
3172 .type = QUIRK_COMPOSITE,
3173 .data = (const struct snd_usb_audio_quirk[]) {
3177 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3182 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3187 .type = QUIRK_MIDI_STANDARD_INTERFACE
3198 * Some USB MIDI devices don't have an audio control interface,
3199 * so we have to grab MIDI streaming interfaces here.
3201 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3202 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3203 .bInterfaceClass = USB_CLASS_AUDIO,
3204 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3205 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3206 .ifnum = QUIRK_ANY_INTERFACE,
3207 .type = QUIRK_MIDI_STANDARD_INTERFACE
3211 /* disabled due to regression for other devices;
3212 * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3217 * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3218 * ID, but it looks like the product ID actually is only for Nura.
3219 * The capture interface does not work at all (even on Windows),
3220 * and only the 48 kHz sample rate works for the playback interface.
3222 USB_DEVICE(0x0a12, 0x1243),
3223 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3224 .ifnum = QUIRK_ANY_INTERFACE,
3225 .type = QUIRK_COMPOSITE,
3226 .data = (const struct snd_usb_audio_quirk[]) {
3229 .type = QUIRK_AUDIO_STANDARD_MIXER,
3234 .type = QUIRK_IGNORE_INTERFACE,
3239 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3240 .data = &(const struct audioformat) {
3241 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3246 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3247 UAC_EP_CS_ATTR_SAMPLE_RATE,
3249 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3250 .rates = SNDRV_PCM_RATE_48000,
3254 .rate_table = (unsigned int[]) {
3265 #endif /* disabled */
3269 * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3270 * even though it advertises more. The capture interface doesn't work
3273 USB_DEVICE(0x19b5, 0x0021),
3274 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3275 .ifnum = QUIRK_ANY_INTERFACE,
3276 .type = QUIRK_COMPOSITE,
3277 .data = (const struct snd_usb_audio_quirk[]) {
3280 .type = QUIRK_AUDIO_STANDARD_MIXER,
3285 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3286 .data = &(const struct audioformat) {
3287 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3292 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3293 UAC_EP_CS_ATTR_SAMPLE_RATE,
3295 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3296 .rates = SNDRV_PCM_RATE_48000,
3300 .rate_table = (unsigned int[]) {
3311 /* Dell WD19 Dock */
3313 USB_DEVICE(0x0bda, 0x402e),
3314 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3315 .ifnum = QUIRK_ANY_INTERFACE,
3316 .type = QUIRK_SETUP_FMT_AFTER_RESUME
3319 /* MOTU Microbook II */
3321 USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004),
3322 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3323 .vendor_name = "MOTU",
3324 .product_name = "MicroBookII",
3325 .ifnum = QUIRK_ANY_INTERFACE,
3326 .type = QUIRK_COMPOSITE,
3327 .data = (const struct snd_usb_audio_quirk[]) {
3330 .type = QUIRK_AUDIO_STANDARD_MIXER,
3334 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3335 .data = &(const struct audioformat) {
3336 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3343 .rates = SNDRV_PCM_RATE_96000,
3344 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3345 USB_ENDPOINT_SYNC_ASYNC,
3349 .maxpacksize = 0x00d8,
3350 .rate_table = (unsigned int[]) {
3357 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3358 .data = &(const struct audioformat) {
3359 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3366 .rates = SNDRV_PCM_RATE_96000,
3367 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3368 USB_ENDPOINT_SYNC_ASYNC,
3372 .maxpacksize = 0x0120,
3373 .rate_table = (unsigned int[]) {
3386 * PIONEER DJ DDJ-SX3
3387 * PCM is 12 channels out, 10 channels in @ 44.1 fixed
3388 * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
3389 * The feedback for the output is the input.
3391 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
3392 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3393 .ifnum = QUIRK_ANY_INTERFACE,
3394 .type = QUIRK_COMPOSITE,
3395 .data = (const struct snd_usb_audio_quirk[]) {
3398 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3399 .data = &(const struct audioformat) {
3400 .formats = SNDRV_PCM_FMTBIT_S32_LE,
3406 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3407 USB_ENDPOINT_SYNC_ASYNC,
3408 .rates = SNDRV_PCM_RATE_44100,
3412 .rate_table = (unsigned int[]) { 44100 }
3417 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3418 .data = &(const struct audioformat) {
3419 .formats = SNDRV_PCM_FMTBIT_S32_LE,
3425 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3426 USB_ENDPOINT_SYNC_ASYNC|
3427 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3428 .rates = SNDRV_PCM_RATE_44100,
3432 .rate_table = (unsigned int[]) { 44100 }
3443 * Pioneer DJ DJM-250MK2
3444 * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
3445 * and 8 channels in @ 48 fixed (endpoint 0x82).
3447 * Both playback and recording is working, even simultaneously.
3449 * Playback channels could be mapped to:
3454 * Recording channels could be mapped to:
3463 * There is remaining problem with recording directly from PHONO/LINE.
3464 * If we map a channel to:
3465 * - CH1 Control Tone PHONO
3466 * - CH1 Control Tone LINE
3467 * - CH2 Control Tone PHONO
3468 * - CH2 Control Tone LINE
3470 * There is no signal even on other operating systems with official drivers.
3471 * The signal appears only when a supported application is started.
3472 * This needs to be investigated yet...
3473 * (there is quite a lot communication on the USB in both directions)
3475 * In current version this mixer could be used for playback
3476 * and for recording from vinyls (through Post CH* Fader)
3477 * but not for DVS (Digital Vinyl Systems) like in Mixxx.
3479 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3480 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3481 .ifnum = QUIRK_ANY_INTERFACE,
3482 .type = QUIRK_COMPOSITE,
3483 .data = (const struct snd_usb_audio_quirk[]) {
3486 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3487 .data = &(const struct audioformat) {
3488 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3489 .channels = 8, // outputs
3494 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3495 USB_ENDPOINT_SYNC_ASYNC,
3496 .rates = SNDRV_PCM_RATE_48000,
3500 .rate_table = (unsigned int[]) { 48000 }
3505 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3506 .data = &(const struct audioformat) {
3507 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3508 .channels = 8, // inputs
3513 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3514 USB_ENDPOINT_SYNC_ASYNC|
3515 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3516 .rates = SNDRV_PCM_RATE_48000,
3520 .rate_table = (unsigned int[]) { 48000 }
3532 * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3533 * The feedback for the output is the dummy input.
3535 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3536 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3537 .ifnum = QUIRK_ANY_INTERFACE,
3538 .type = QUIRK_COMPOSITE,
3539 .data = (const struct snd_usb_audio_quirk[]) {
3542 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3543 .data = &(const struct audioformat) {
3544 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3550 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3551 USB_ENDPOINT_SYNC_ASYNC,
3552 .rates = SNDRV_PCM_RATE_44100,
3556 .rate_table = (unsigned int[]) { 44100 }
3561 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3562 .data = &(const struct audioformat) {
3563 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3569 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3570 USB_ENDPOINT_SYNC_ASYNC|
3571 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3572 .rates = SNDRV_PCM_RATE_44100,
3576 .rate_table = (unsigned int[]) { 44100 }
3588 * Pioneer DJ DJM-900NXS2
3589 * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE
3591 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a),
3592 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3593 .ifnum = QUIRK_ANY_INTERFACE,
3594 .type = QUIRK_COMPOSITE,
3595 .data = (const struct snd_usb_audio_quirk[]) {
3598 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3599 .data = &(const struct audioformat) {
3600 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3606 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3607 USB_ENDPOINT_SYNC_ASYNC,
3608 .rates = SNDRV_PCM_RATE_44100|
3609 SNDRV_PCM_RATE_48000|
3610 SNDRV_PCM_RATE_96000,
3614 .rate_table = (unsigned int[]) {
3621 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3622 .data = &(const struct audioformat) {
3623 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3629 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3630 USB_ENDPOINT_SYNC_ASYNC|
3631 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3632 .rates = SNDRV_PCM_RATE_44100|
3633 SNDRV_PCM_RATE_48000|
3634 SNDRV_PCM_RATE_96000,
3638 .rate_table = (unsigned int[]) {
3651 * MacroSilicon MS2109 based HDMI capture cards
3653 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3654 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if
3655 * they pretend to be 96kHz mono as a workaround for stereo being broken
3658 * They also have an issue with initial stream alignment that causes the
3659 * channels to be swapped and out of phase, which is dealt with in quirks.c.
3662 USB_AUDIO_DEVICE(0x534d, 0x2109),
3663 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3664 .vendor_name = "MacroSilicon",
3665 .product_name = "MS2109",
3666 .ifnum = QUIRK_ANY_INTERFACE,
3667 .type = QUIRK_COMPOSITE,
3668 .data = &(const struct snd_usb_audio_quirk[]) {
3671 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
3675 .type = QUIRK_AUDIO_STANDARD_MIXER,
3679 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3680 .data = &(const struct audioformat) {
3681 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3688 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3689 USB_ENDPOINT_SYNC_ASYNC,
3690 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3704 * Change order of interfaces loaded
3706 USB_DEVICE(0x1395, 0x0300),
3707 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3708 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3709 .ifnum = QUIRK_ANY_INTERFACE,
3710 .type = QUIRK_COMPOSITE,
3711 .data = &(const struct snd_usb_audio_quirk[]) {
3715 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3720 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3725 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3734 #undef USB_DEVICE_VENDOR_SPEC
3735 #undef USB_AUDIO_DEVICE