2 * ALSA USB Audio Driver
4 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>,
5 * Clemens Ladisch <clemens@ladisch.de>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 * The contents of this file are part of the driver's id_table.
26 * In a perfect world, this file would be empty.
30 * Use this for devices where other interfaces are standard compliant,
31 * to prevent the quirk being applied to those interfaces. (To work with
32 * hotplugging, bDeviceClass must be set to USB_CLASS_PER_INTERFACE.)
34 #define USB_DEVICE_VENDOR_SPEC(vend, prod) \
35 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | \
36 USB_DEVICE_ID_MATCH_PRODUCT | \
37 USB_DEVICE_ID_MATCH_INT_CLASS, \
40 .bInterfaceClass = USB_CLASS_VENDOR_SPEC
44 USB_DEVICE(0x0403, 0xb8d8),
45 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
46 /* .vendor_name = "STARR LABS", */
47 /* .product_name = "Starr Labs MIDI USB device", */
49 .type = QUIRK_MIDI_FTDI
55 USB_DEVICE(0x041e, 0x0005),
56 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
58 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
59 .data = &(const struct audioformat) {
60 .formats = SNDRV_PCM_FMTBIT_S16_LE,
66 .ep_attr = USB_ENDPOINT_XFER_ISOC,
68 .rates = SNDRV_PCM_RATE_CONTINUOUS,
75 /* Creative/E-Mu devices */
77 USB_DEVICE(0x041e, 0x3010),
78 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
79 .vendor_name = "Creative Labs",
80 .product_name = "Sound Blaster MP3+",
81 .ifnum = QUIRK_NO_INTERFACE
84 /* Creative/Toshiba Multimedia Center SB-0500 */
86 USB_DEVICE(0x041e, 0x3048),
87 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
88 .vendor_name = "Toshiba",
89 .product_name = "SB-0500",
90 .ifnum = QUIRK_NO_INTERFACE
95 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
98 .bInterfaceClass = USB_CLASS_AUDIO,
102 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
105 .bInterfaceClass = USB_CLASS_AUDIO,
108 /* E-Mu Tracker Pre */
109 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
112 .bInterfaceClass = USB_CLASS_AUDIO,
116 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
119 .bInterfaceClass = USB_CLASS_AUDIO,
124 * When not ignored, causes instability issues for some users, forcing them to
125 * blacklist 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.
163 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
164 USB_DEVICE_ID_MATCH_INT_CLASS |
165 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
168 .bInterfaceClass = USB_CLASS_AUDIO,
169 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
172 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
173 USB_DEVICE_ID_MATCH_INT_CLASS |
174 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
177 .bInterfaceClass = USB_CLASS_AUDIO,
178 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
181 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
182 USB_DEVICE_ID_MATCH_INT_CLASS |
183 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
186 .bInterfaceClass = USB_CLASS_AUDIO,
187 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
190 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
191 USB_DEVICE_ID_MATCH_INT_CLASS |
192 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
195 .bInterfaceClass = USB_CLASS_AUDIO,
196 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
199 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
200 USB_DEVICE_ID_MATCH_INT_CLASS |
201 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
204 .bInterfaceClass = USB_CLASS_AUDIO,
205 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
208 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
209 USB_DEVICE_ID_MATCH_INT_CLASS |
210 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
213 .bInterfaceClass = USB_CLASS_AUDIO,
214 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
217 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
218 USB_DEVICE_ID_MATCH_INT_CLASS |
219 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
222 .bInterfaceClass = USB_CLASS_AUDIO,
223 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
224 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
225 .vendor_name = "Logitech, Inc.",
226 .product_name = "QuickCam Pro 9000",
227 .ifnum = QUIRK_NO_INTERFACE
235 #define YAMAHA_DEVICE(id, name) { \
236 USB_DEVICE(0x0499, id), \
237 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
238 .vendor_name = "Yamaha", \
239 .product_name = name, \
240 .ifnum = QUIRK_ANY_INTERFACE, \
241 .type = QUIRK_MIDI_YAMAHA \
244 #define YAMAHA_INTERFACE(id, intf, name) { \
245 USB_DEVICE_VENDOR_SPEC(0x0499, id), \
246 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
247 .vendor_name = "Yamaha", \
248 .product_name = name, \
250 .type = QUIRK_MIDI_YAMAHA \
253 YAMAHA_DEVICE(0x1000, "UX256"),
254 YAMAHA_DEVICE(0x1001, "MU1000"),
255 YAMAHA_DEVICE(0x1002, "MU2000"),
256 YAMAHA_DEVICE(0x1003, "MU500"),
257 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
258 YAMAHA_DEVICE(0x1005, "MOTIF6"),
259 YAMAHA_DEVICE(0x1006, "MOTIF7"),
260 YAMAHA_DEVICE(0x1007, "MOTIF8"),
261 YAMAHA_DEVICE(0x1008, "UX96"),
262 YAMAHA_DEVICE(0x1009, "UX16"),
263 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
264 YAMAHA_DEVICE(0x100c, "UC-MX"),
265 YAMAHA_DEVICE(0x100d, "UC-KX"),
266 YAMAHA_DEVICE(0x100e, "S08"),
267 YAMAHA_DEVICE(0x100f, "CLP-150"),
268 YAMAHA_DEVICE(0x1010, "CLP-170"),
269 YAMAHA_DEVICE(0x1011, "P-250"),
270 YAMAHA_DEVICE(0x1012, "TYROS"),
271 YAMAHA_DEVICE(0x1013, "PF-500"),
272 YAMAHA_DEVICE(0x1014, "S90"),
273 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
274 YAMAHA_DEVICE(0x1016, "MDP-5"),
275 YAMAHA_DEVICE(0x1017, "CVP-204"),
276 YAMAHA_DEVICE(0x1018, "CVP-206"),
277 YAMAHA_DEVICE(0x1019, "CVP-208"),
278 YAMAHA_DEVICE(0x101a, "CVP-210"),
279 YAMAHA_DEVICE(0x101b, "PSR-1100"),
280 YAMAHA_DEVICE(0x101c, "PSR-2100"),
281 YAMAHA_DEVICE(0x101d, "CLP-175"),
282 YAMAHA_DEVICE(0x101e, "PSR-K1"),
283 YAMAHA_DEVICE(0x101f, "EZ-J24"),
284 YAMAHA_DEVICE(0x1020, "EZ-250i"),
285 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
286 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
287 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
288 YAMAHA_DEVICE(0x1024, "CVP-301"),
289 YAMAHA_DEVICE(0x1025, "CVP-303"),
290 YAMAHA_DEVICE(0x1026, "CVP-305"),
291 YAMAHA_DEVICE(0x1027, "CVP-307"),
292 YAMAHA_DEVICE(0x1028, "CVP-309"),
293 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
294 YAMAHA_DEVICE(0x102a, "PSR-1500"),
295 YAMAHA_DEVICE(0x102b, "PSR-3000"),
296 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
297 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
298 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
299 YAMAHA_DEVICE(0x1032, "DGX-305"),
300 YAMAHA_DEVICE(0x1033, "DGX-505"),
301 YAMAHA_DEVICE(0x1034, NULL),
302 YAMAHA_DEVICE(0x1035, NULL),
303 YAMAHA_DEVICE(0x1036, NULL),
304 YAMAHA_DEVICE(0x1037, NULL),
305 YAMAHA_DEVICE(0x1038, NULL),
306 YAMAHA_DEVICE(0x1039, NULL),
307 YAMAHA_DEVICE(0x103a, NULL),
308 YAMAHA_DEVICE(0x103b, NULL),
309 YAMAHA_DEVICE(0x103c, NULL),
310 YAMAHA_DEVICE(0x103d, NULL),
311 YAMAHA_DEVICE(0x103e, NULL),
312 YAMAHA_DEVICE(0x103f, NULL),
313 YAMAHA_DEVICE(0x1040, NULL),
314 YAMAHA_DEVICE(0x1041, NULL),
315 YAMAHA_DEVICE(0x1042, NULL),
316 YAMAHA_DEVICE(0x1043, NULL),
317 YAMAHA_DEVICE(0x1044, NULL),
318 YAMAHA_DEVICE(0x1045, NULL),
319 YAMAHA_INTERFACE(0x104e, 0, NULL),
320 YAMAHA_DEVICE(0x104f, NULL),
321 YAMAHA_DEVICE(0x1050, NULL),
322 YAMAHA_DEVICE(0x1051, NULL),
323 YAMAHA_DEVICE(0x1052, NULL),
324 YAMAHA_INTERFACE(0x1053, 0, NULL),
325 YAMAHA_INTERFACE(0x1054, 0, NULL),
326 YAMAHA_DEVICE(0x1055, NULL),
327 YAMAHA_DEVICE(0x1056, NULL),
328 YAMAHA_DEVICE(0x1057, NULL),
329 YAMAHA_DEVICE(0x1058, NULL),
330 YAMAHA_DEVICE(0x1059, NULL),
331 YAMAHA_DEVICE(0x105a, NULL),
332 YAMAHA_DEVICE(0x105b, NULL),
333 YAMAHA_DEVICE(0x105c, NULL),
334 YAMAHA_DEVICE(0x105d, NULL),
336 USB_DEVICE(0x0499, 0x1503),
337 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
338 /* .vendor_name = "Yamaha", */
339 /* .product_name = "MOX6/MOX8", */
340 .ifnum = QUIRK_ANY_INTERFACE,
341 .type = QUIRK_COMPOSITE,
342 .data = (const struct snd_usb_audio_quirk[]) {
345 .type = QUIRK_AUDIO_STANDARD_INTERFACE
349 .type = QUIRK_AUDIO_STANDARD_INTERFACE
353 .type = QUIRK_MIDI_YAMAHA
362 USB_DEVICE(0x0499, 0x1507),
363 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
364 /* .vendor_name = "Yamaha", */
365 /* .product_name = "THR10", */
366 .ifnum = QUIRK_ANY_INTERFACE,
367 .type = QUIRK_COMPOSITE,
368 .data = (const struct snd_usb_audio_quirk[]) {
371 .type = QUIRK_AUDIO_STANDARD_INTERFACE
375 .type = QUIRK_AUDIO_STANDARD_INTERFACE
379 .type = QUIRK_MIDI_YAMAHA
388 USB_DEVICE(0x0499, 0x1509),
389 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
390 /* .vendor_name = "Yamaha", */
391 /* .product_name = "Steinberg UR22", */
392 .ifnum = QUIRK_ANY_INTERFACE,
393 .type = QUIRK_COMPOSITE,
394 .data = (const struct snd_usb_audio_quirk[]) {
397 .type = QUIRK_AUDIO_STANDARD_INTERFACE
401 .type = QUIRK_AUDIO_STANDARD_INTERFACE
405 .type = QUIRK_MIDI_YAMAHA
409 .type = QUIRK_IGNORE_INTERFACE
418 USB_DEVICE(0x0499, 0x150a),
419 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
420 /* .vendor_name = "Yamaha", */
421 /* .product_name = "THR5A", */
422 .ifnum = QUIRK_ANY_INTERFACE,
423 .type = QUIRK_COMPOSITE,
424 .data = (const struct snd_usb_audio_quirk[]) {
427 .type = QUIRK_AUDIO_STANDARD_INTERFACE
431 .type = QUIRK_AUDIO_STANDARD_INTERFACE
435 .type = QUIRK_MIDI_YAMAHA
444 USB_DEVICE(0x0499, 0x150c),
445 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
446 /* .vendor_name = "Yamaha", */
447 /* .product_name = "THR10C", */
448 .ifnum = QUIRK_ANY_INTERFACE,
449 .type = QUIRK_COMPOSITE,
450 .data = (const struct snd_usb_audio_quirk[]) {
453 .type = QUIRK_AUDIO_STANDARD_INTERFACE
457 .type = QUIRK_AUDIO_STANDARD_INTERFACE
461 .type = QUIRK_MIDI_YAMAHA
469 YAMAHA_DEVICE(0x2000, "DGP-7"),
470 YAMAHA_DEVICE(0x2001, "DGP-5"),
471 YAMAHA_DEVICE(0x2002, NULL),
472 YAMAHA_DEVICE(0x2003, NULL),
473 YAMAHA_DEVICE(0x5000, "CS1D"),
474 YAMAHA_DEVICE(0x5001, "DSP1D"),
475 YAMAHA_DEVICE(0x5002, "DME32"),
476 YAMAHA_DEVICE(0x5003, "DM2000"),
477 YAMAHA_DEVICE(0x5004, "02R96"),
478 YAMAHA_DEVICE(0x5005, "ACU16-C"),
479 YAMAHA_DEVICE(0x5006, "NHB32-C"),
480 YAMAHA_DEVICE(0x5007, "DM1000"),
481 YAMAHA_DEVICE(0x5008, "01V96"),
482 YAMAHA_DEVICE(0x5009, "SPX2000"),
483 YAMAHA_DEVICE(0x500a, "PM5D"),
484 YAMAHA_DEVICE(0x500b, "DME64N"),
485 YAMAHA_DEVICE(0x500c, "DME24N"),
486 YAMAHA_DEVICE(0x500d, NULL),
487 YAMAHA_DEVICE(0x500e, NULL),
488 YAMAHA_DEVICE(0x500f, NULL),
489 YAMAHA_DEVICE(0x7000, "DTX"),
490 YAMAHA_DEVICE(0x7010, "UB99"),
492 #undef YAMAHA_INTERFACE
493 /* this catches most recent vendor-specific Yamaha devices */
495 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
496 USB_DEVICE_ID_MATCH_INT_CLASS,
498 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
499 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
500 .ifnum = QUIRK_ANY_INTERFACE,
501 .type = QUIRK_AUTODETECT
506 * Roland/RolandED/Edirol/BOSS devices
509 USB_DEVICE(0x0582, 0x0000),
510 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
511 .vendor_name = "Roland",
512 .product_name = "UA-100",
513 .ifnum = QUIRK_ANY_INTERFACE,
514 .type = QUIRK_COMPOSITE,
515 .data = (const struct snd_usb_audio_quirk[]) {
518 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
519 .data = & (const struct audioformat) {
520 .formats = SNDRV_PCM_FMTBIT_S16_LE,
528 .rates = SNDRV_PCM_RATE_CONTINUOUS,
535 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
536 .data = & (const struct audioformat) {
537 .formats = SNDRV_PCM_FMTBIT_S16_LE,
542 .attributes = UAC_EP_CS_ATTR_FILL_MAX,
545 .rates = SNDRV_PCM_RATE_CONTINUOUS,
552 .type = QUIRK_MIDI_FIXED_ENDPOINT,
553 .data = & (const struct snd_usb_midi_endpoint_info) {
554 .out_cables = 0x0007,
565 USB_DEVICE(0x0582, 0x0002),
566 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
567 .vendor_name = "EDIROL",
568 .product_name = "UM-4",
569 .ifnum = QUIRK_ANY_INTERFACE,
570 .type = QUIRK_COMPOSITE,
571 .data = (const struct snd_usb_audio_quirk[]) {
574 .type = QUIRK_IGNORE_INTERFACE
578 .type = QUIRK_IGNORE_INTERFACE
582 .type = QUIRK_MIDI_FIXED_ENDPOINT,
583 .data = & (const struct snd_usb_midi_endpoint_info) {
584 .out_cables = 0x000f,
595 USB_DEVICE(0x0582, 0x0003),
596 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
597 .vendor_name = "Roland",
598 .product_name = "SC-8850",
599 .ifnum = QUIRK_ANY_INTERFACE,
600 .type = QUIRK_COMPOSITE,
601 .data = (const struct snd_usb_audio_quirk[]) {
604 .type = QUIRK_IGNORE_INTERFACE
608 .type = QUIRK_IGNORE_INTERFACE
612 .type = QUIRK_MIDI_FIXED_ENDPOINT,
613 .data = & (const struct snd_usb_midi_endpoint_info) {
614 .out_cables = 0x003f,
625 USB_DEVICE(0x0582, 0x0004),
626 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
627 .vendor_name = "Roland",
628 .product_name = "U-8",
629 .ifnum = QUIRK_ANY_INTERFACE,
630 .type = QUIRK_COMPOSITE,
631 .data = (const struct snd_usb_audio_quirk[]) {
634 .type = QUIRK_IGNORE_INTERFACE
638 .type = QUIRK_IGNORE_INTERFACE
642 .type = QUIRK_MIDI_FIXED_ENDPOINT,
643 .data = & (const struct snd_usb_midi_endpoint_info) {
644 .out_cables = 0x0005,
655 /* Has ID 0x0099 when not in "Advanced Driver" mode.
656 * The UM-2EX has only one input, but we cannot detect this. */
657 USB_DEVICE(0x0582, 0x0005),
658 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
659 .vendor_name = "EDIROL",
660 .product_name = "UM-2",
661 .ifnum = QUIRK_ANY_INTERFACE,
662 .type = QUIRK_COMPOSITE,
663 .data = (const struct snd_usb_audio_quirk[]) {
666 .type = QUIRK_IGNORE_INTERFACE
670 .type = QUIRK_IGNORE_INTERFACE
674 .type = QUIRK_MIDI_FIXED_ENDPOINT,
675 .data = & (const struct snd_usb_midi_endpoint_info) {
676 .out_cables = 0x0003,
687 USB_DEVICE(0x0582, 0x0007),
688 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
689 .vendor_name = "Roland",
690 .product_name = "SC-8820",
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 = 0x0013,
717 USB_DEVICE(0x0582, 0x0008),
718 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
719 .vendor_name = "Roland",
720 .product_name = "PC-300",
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 = 0x0001,
747 /* has ID 0x009d when not in "Advanced Driver" mode */
748 USB_DEVICE(0x0582, 0x0009),
749 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
750 .vendor_name = "EDIROL",
751 .product_name = "UM-1",
752 .ifnum = QUIRK_ANY_INTERFACE,
753 .type = QUIRK_COMPOSITE,
754 .data = (const struct snd_usb_audio_quirk[]) {
757 .type = QUIRK_IGNORE_INTERFACE
761 .type = QUIRK_IGNORE_INTERFACE
765 .type = QUIRK_MIDI_FIXED_ENDPOINT,
766 .data = & (const struct snd_usb_midi_endpoint_info) {
767 .out_cables = 0x0001,
778 USB_DEVICE(0x0582, 0x000b),
779 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
780 .vendor_name = "Roland",
781 .product_name = "SK-500",
782 .ifnum = QUIRK_ANY_INTERFACE,
783 .type = QUIRK_COMPOSITE,
784 .data = (const struct snd_usb_audio_quirk[]) {
787 .type = QUIRK_IGNORE_INTERFACE
791 .type = QUIRK_IGNORE_INTERFACE
795 .type = QUIRK_MIDI_FIXED_ENDPOINT,
796 .data = & (const struct snd_usb_midi_endpoint_info) {
797 .out_cables = 0x0013,
808 /* thanks to Emiliano Grilli <emillo@libero.it>
809 * for helping researching this data */
810 USB_DEVICE(0x0582, 0x000c),
811 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
812 .vendor_name = "Roland",
813 .product_name = "SC-D70",
814 .ifnum = QUIRK_ANY_INTERFACE,
815 .type = QUIRK_COMPOSITE,
816 .data = (const struct snd_usb_audio_quirk[]) {
819 .type = QUIRK_AUDIO_STANDARD_INTERFACE
823 .type = QUIRK_AUDIO_STANDARD_INTERFACE
827 .type = QUIRK_MIDI_FIXED_ENDPOINT,
828 .data = & (const struct snd_usb_midi_endpoint_info) {
829 .out_cables = 0x0007,
840 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
841 * If the advanced mode switch at the back of the unit is off, the
842 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
843 * but offers only 16-bit PCM.
844 * In advanced mode, the UA-5 will output S24_3LE samples (two
845 * channels) at the rate indicated on the front switch, including
846 * the 96kHz sample rate.
848 USB_DEVICE(0x0582, 0x0010),
849 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
850 .vendor_name = "EDIROL",
851 .product_name = "UA-5",
852 .ifnum = QUIRK_ANY_INTERFACE,
853 .type = QUIRK_COMPOSITE,
854 .data = (const struct snd_usb_audio_quirk[]) {
857 .type = QUIRK_AUDIO_STANDARD_INTERFACE
861 .type = QUIRK_AUDIO_STANDARD_INTERFACE
870 /* has ID 0x0013 when not in "Advanced Driver" mode */
871 USB_DEVICE(0x0582, 0x0012),
872 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
873 .vendor_name = "Roland",
874 .product_name = "XV-5050",
876 .type = QUIRK_MIDI_FIXED_ENDPOINT,
877 .data = & (const struct snd_usb_midi_endpoint_info) {
878 .out_cables = 0x0001,
884 /* has ID 0x0015 when not in "Advanced Driver" mode */
885 USB_DEVICE(0x0582, 0x0014),
886 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
887 .vendor_name = "EDIROL",
888 .product_name = "UM-880",
890 .type = QUIRK_MIDI_FIXED_ENDPOINT,
891 .data = & (const struct snd_usb_midi_endpoint_info) {
892 .out_cables = 0x01ff,
898 /* has ID 0x0017 when not in "Advanced Driver" mode */
899 USB_DEVICE(0x0582, 0x0016),
900 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
901 .vendor_name = "EDIROL",
902 .product_name = "SD-90",
903 .ifnum = QUIRK_ANY_INTERFACE,
904 .type = QUIRK_COMPOSITE,
905 .data = (const struct snd_usb_audio_quirk[]) {
908 .type = QUIRK_AUDIO_STANDARD_INTERFACE
912 .type = QUIRK_AUDIO_STANDARD_INTERFACE
916 .type = QUIRK_MIDI_FIXED_ENDPOINT,
917 .data = & (const struct snd_usb_midi_endpoint_info) {
918 .out_cables = 0x000f,
929 /* has ID 0x001c when not in "Advanced Driver" mode */
930 USB_DEVICE(0x0582, 0x001b),
931 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
932 .vendor_name = "Roland",
933 .product_name = "MMP-2",
934 .ifnum = QUIRK_ANY_INTERFACE,
935 .type = QUIRK_COMPOSITE,
936 .data = (const struct snd_usb_audio_quirk[]) {
939 .type = QUIRK_IGNORE_INTERFACE
943 .type = QUIRK_IGNORE_INTERFACE
947 .type = QUIRK_MIDI_FIXED_ENDPOINT,
948 .data = & (const struct snd_usb_midi_endpoint_info) {
949 .out_cables = 0x0001,
960 /* has ID 0x001e when not in "Advanced Driver" mode */
961 USB_DEVICE(0x0582, 0x001d),
962 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
963 .vendor_name = "Roland",
964 .product_name = "V-SYNTH",
966 .type = QUIRK_MIDI_FIXED_ENDPOINT,
967 .data = & (const struct snd_usb_midi_endpoint_info) {
968 .out_cables = 0x0001,
974 /* has ID 0x0024 when not in "Advanced Driver" mode */
975 USB_DEVICE(0x0582, 0x0023),
976 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
977 .vendor_name = "EDIROL",
978 .product_name = "UM-550",
980 .type = QUIRK_MIDI_FIXED_ENDPOINT,
981 .data = & (const struct snd_usb_midi_endpoint_info) {
982 .out_cables = 0x003f,
989 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
990 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
993 USB_DEVICE(0x0582, 0x0025),
994 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
995 .vendor_name = "EDIROL",
996 .product_name = "UA-20",
997 .ifnum = QUIRK_ANY_INTERFACE,
998 .type = QUIRK_COMPOSITE,
999 .data = (const struct snd_usb_audio_quirk[]) {
1002 .type = QUIRK_IGNORE_INTERFACE
1006 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1007 .data = & (const struct audioformat) {
1008 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
1016 .rates = SNDRV_PCM_RATE_CONTINUOUS,
1023 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1024 .data = & (const struct audioformat) {
1025 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
1033 .rates = SNDRV_PCM_RATE_CONTINUOUS,
1040 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1041 .data = & (const struct snd_usb_midi_endpoint_info) {
1042 .out_cables = 0x0001,
1053 /* has ID 0x0028 when not in "Advanced Driver" mode */
1054 USB_DEVICE(0x0582, 0x0027),
1055 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1056 .vendor_name = "EDIROL",
1057 .product_name = "SD-20",
1059 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1060 .data = & (const struct snd_usb_midi_endpoint_info) {
1061 .out_cables = 0x0003,
1067 /* has ID 0x002a when not in "Advanced Driver" mode */
1068 USB_DEVICE(0x0582, 0x0029),
1069 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1070 .vendor_name = "EDIROL",
1071 .product_name = "SD-80",
1073 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1074 .data = & (const struct snd_usb_midi_endpoint_info) {
1075 .out_cables = 0x000f,
1081 * This quirk is for the "Advanced" modes of the Edirol UA-700.
1082 * If the sample format switch is not in an advanced setting, the
1083 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
1084 * but offers only 16-bit PCM and no MIDI.
1086 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
1087 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1088 .vendor_name = "EDIROL",
1089 .product_name = "UA-700",
1090 .ifnum = QUIRK_ANY_INTERFACE,
1091 .type = QUIRK_COMPOSITE,
1092 .data = (const struct snd_usb_audio_quirk[]) {
1095 .type = QUIRK_AUDIO_EDIROL_UAXX
1099 .type = QUIRK_AUDIO_EDIROL_UAXX
1103 .type = QUIRK_AUDIO_EDIROL_UAXX
1112 /* has ID 0x002e when not in "Advanced Driver" mode */
1113 USB_DEVICE(0x0582, 0x002d),
1114 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1115 .vendor_name = "Roland",
1116 .product_name = "XV-2020",
1118 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1119 .data = & (const struct snd_usb_midi_endpoint_info) {
1120 .out_cables = 0x0001,
1126 /* has ID 0x0030 when not in "Advanced Driver" mode */
1127 USB_DEVICE(0x0582, 0x002f),
1128 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1129 .vendor_name = "Roland",
1130 .product_name = "VariOS",
1132 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1133 .data = & (const struct snd_usb_midi_endpoint_info) {
1134 .out_cables = 0x0007,
1140 /* has ID 0x0034 when not in "Advanced Driver" mode */
1141 USB_DEVICE(0x0582, 0x0033),
1142 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1143 .vendor_name = "EDIROL",
1144 .product_name = "PCR",
1146 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1147 .data = & (const struct snd_usb_midi_endpoint_info) {
1148 .out_cables = 0x0003,
1155 * Has ID 0x0038 when not in "Advanced Driver" mode;
1156 * later revisions use IDs 0x0054 and 0x00a2.
1158 USB_DEVICE(0x0582, 0x0037),
1159 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1160 .vendor_name = "Roland",
1161 .product_name = "Digital Piano",
1163 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1164 .data = & (const struct snd_usb_midi_endpoint_info) {
1165 .out_cables = 0x0001,
1172 * This quirk is for the "Advanced Driver" mode. If off, the GS-10
1173 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1176 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1177 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1178 .vendor_name = "BOSS",
1179 .product_name = "GS-10",
1180 .ifnum = QUIRK_ANY_INTERFACE,
1181 .type = QUIRK_COMPOSITE,
1182 .data = & (const struct snd_usb_audio_quirk[]) {
1185 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1189 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1193 .type = QUIRK_MIDI_STANDARD_INTERFACE
1202 /* has ID 0x0041 when not in "Advanced Driver" mode */
1203 USB_DEVICE(0x0582, 0x0040),
1204 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1205 .vendor_name = "Roland",
1206 .product_name = "GI-20",
1208 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1209 .data = & (const struct snd_usb_midi_endpoint_info) {
1210 .out_cables = 0x0001,
1216 /* has ID 0x0043 when not in "Advanced Driver" mode */
1217 USB_DEVICE(0x0582, 0x0042),
1218 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1219 .vendor_name = "Roland",
1220 .product_name = "RS-70",
1222 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1223 .data = & (const struct snd_usb_midi_endpoint_info) {
1224 .out_cables = 0x0001,
1230 /* has ID 0x0049 when not in "Advanced Driver" mode */
1231 USB_DEVICE(0x0582, 0x0047),
1232 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1233 /* .vendor_name = "EDIROL", */
1234 /* .product_name = "UR-80", */
1235 .ifnum = QUIRK_ANY_INTERFACE,
1236 .type = QUIRK_COMPOSITE,
1237 .data = (const struct snd_usb_audio_quirk[]) {
1238 /* in the 96 kHz modes, only interface 1 is there */
1241 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1245 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1254 /* has ID 0x004a when not in "Advanced Driver" mode */
1255 USB_DEVICE(0x0582, 0x0048),
1256 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1257 /* .vendor_name = "EDIROL", */
1258 /* .product_name = "UR-80", */
1260 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1261 .data = & (const struct snd_usb_midi_endpoint_info) {
1262 .out_cables = 0x0003,
1268 /* has ID 0x004e when not in "Advanced Driver" mode */
1269 USB_DEVICE(0x0582, 0x004c),
1270 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1271 .vendor_name = "EDIROL",
1272 .product_name = "PCR-A",
1273 .ifnum = QUIRK_ANY_INTERFACE,
1274 .type = QUIRK_COMPOSITE,
1275 .data = (const struct snd_usb_audio_quirk[]) {
1278 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1282 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1291 /* has ID 0x004f when not in "Advanced Driver" mode */
1292 USB_DEVICE(0x0582, 0x004d),
1293 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1294 .vendor_name = "EDIROL",
1295 .product_name = "PCR-A",
1297 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1298 .data = & (const struct snd_usb_midi_endpoint_info) {
1299 .out_cables = 0x0003,
1306 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1307 * is standard compliant, but has only 16-bit PCM.
1309 USB_DEVICE(0x0582, 0x0050),
1310 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1311 .vendor_name = "EDIROL",
1312 .product_name = "UA-3FX",
1313 .ifnum = QUIRK_ANY_INTERFACE,
1314 .type = QUIRK_COMPOSITE,
1315 .data = (const struct snd_usb_audio_quirk[]) {
1318 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1322 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1331 USB_DEVICE(0x0582, 0x0052),
1332 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1333 .vendor_name = "EDIROL",
1334 .product_name = "UM-1SX",
1336 .type = QUIRK_MIDI_STANDARD_INTERFACE
1340 USB_DEVICE(0x0582, 0x0060),
1341 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1342 .vendor_name = "Roland",
1343 .product_name = "EXR Series",
1345 .type = QUIRK_MIDI_STANDARD_INTERFACE
1349 /* has ID 0x0066 when not in "Advanced Driver" mode */
1350 USB_DEVICE(0x0582, 0x0064),
1351 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1352 /* .vendor_name = "EDIROL", */
1353 /* .product_name = "PCR-1", */
1354 .ifnum = QUIRK_ANY_INTERFACE,
1355 .type = QUIRK_COMPOSITE,
1356 .data = (const struct snd_usb_audio_quirk[]) {
1359 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1363 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1372 /* has ID 0x0067 when not in "Advanced Driver" mode */
1373 USB_DEVICE(0x0582, 0x0065),
1374 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1375 /* .vendor_name = "EDIROL", */
1376 /* .product_name = "PCR-1", */
1378 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1379 .data = & (const struct snd_usb_midi_endpoint_info) {
1380 .out_cables = 0x0001,
1386 /* has ID 0x006e when not in "Advanced Driver" mode */
1387 USB_DEVICE(0x0582, 0x006d),
1388 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1389 .vendor_name = "Roland",
1390 .product_name = "FANTOM-X",
1392 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1393 .data = & (const struct snd_usb_midi_endpoint_info) {
1394 .out_cables = 0x0001,
1400 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1401 * If the switch is not in an advanced setting, the UA-25 has
1402 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1403 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1405 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1406 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1407 .vendor_name = "EDIROL",
1408 .product_name = "UA-25",
1409 .ifnum = QUIRK_ANY_INTERFACE,
1410 .type = QUIRK_COMPOSITE,
1411 .data = (const struct snd_usb_audio_quirk[]) {
1414 .type = QUIRK_AUDIO_EDIROL_UAXX
1418 .type = QUIRK_AUDIO_EDIROL_UAXX
1422 .type = QUIRK_AUDIO_EDIROL_UAXX
1431 /* has ID 0x0076 when not in "Advanced Driver" mode */
1432 USB_DEVICE(0x0582, 0x0075),
1433 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1434 .vendor_name = "BOSS",
1435 .product_name = "DR-880",
1437 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1438 .data = & (const struct snd_usb_midi_endpoint_info) {
1439 .out_cables = 0x0001,
1445 /* has ID 0x007b when not in "Advanced Driver" mode */
1446 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1447 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1448 .vendor_name = "Roland",
1449 /* "RD" or "RD-700SX"? */
1451 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1452 .data = & (const struct snd_usb_midi_endpoint_info) {
1453 .out_cables = 0x0003,
1459 /* has ID 0x0081 when not in "Advanced Driver" mode */
1460 USB_DEVICE(0x0582, 0x0080),
1461 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1462 .vendor_name = "Roland",
1463 .product_name = "G-70",
1465 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1466 .data = & (const struct snd_usb_midi_endpoint_info) {
1467 .out_cables = 0x0001,
1473 /* has ID 0x008c when not in "Advanced Driver" mode */
1474 USB_DEVICE(0x0582, 0x008b),
1475 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1476 .vendor_name = "EDIROL",
1477 .product_name = "PC-50",
1479 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1480 .data = & (const struct snd_usb_midi_endpoint_info) {
1481 .out_cables = 0x0001,
1488 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1489 * is standard compliant, but has only 16-bit PCM and no MIDI.
1491 USB_DEVICE(0x0582, 0x00a3),
1492 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1493 .vendor_name = "EDIROL",
1494 .product_name = "UA-4FX",
1495 .ifnum = QUIRK_ANY_INTERFACE,
1496 .type = QUIRK_COMPOSITE,
1497 .data = (const struct snd_usb_audio_quirk[]) {
1500 .type = QUIRK_AUDIO_EDIROL_UAXX
1504 .type = QUIRK_AUDIO_EDIROL_UAXX
1508 .type = QUIRK_AUDIO_EDIROL_UAXX
1518 USB_DEVICE(0x0582, 0x00c4),
1519 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1520 .ifnum = QUIRK_ANY_INTERFACE,
1521 .type = QUIRK_COMPOSITE,
1522 .data = (const struct snd_usb_audio_quirk[]) {
1525 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1529 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1533 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1534 .data = & (const struct snd_usb_midi_endpoint_info) {
1535 .out_cables = 0x0001,
1546 /* Advanced modes of the Edirol UA-25EX.
1547 * For the standard mode, UA-25EX has ID 0582:00e7, which
1548 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1550 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1551 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1552 .vendor_name = "EDIROL",
1553 .product_name = "UA-25EX",
1554 .ifnum = QUIRK_ANY_INTERFACE,
1555 .type = QUIRK_COMPOSITE,
1556 .data = (const struct snd_usb_audio_quirk[]) {
1559 .type = QUIRK_AUDIO_EDIROL_UAXX
1563 .type = QUIRK_AUDIO_EDIROL_UAXX
1567 .type = QUIRK_AUDIO_EDIROL_UAXX
1577 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1578 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1580 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1581 .data = & (const struct snd_usb_midi_endpoint_info) {
1582 .out_cables = 0x0007,
1589 USB_DEVICE(0x0582, 0x0113),
1590 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1591 .ifnum = QUIRK_ANY_INTERFACE,
1592 .type = QUIRK_COMPOSITE,
1593 .data = (const struct snd_usb_audio_quirk[]) {
1596 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1600 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1604 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1605 .data = & (const struct snd_usb_midi_endpoint_info) {
1606 .out_cables = 0x0001,
1617 /* only 44.1 kHz works at the moment */
1618 USB_DEVICE(0x0582, 0x0120),
1619 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1620 /* .vendor_name = "Roland", */
1621 /* .product_name = "OCTO-CAPTURE", */
1622 .ifnum = QUIRK_ANY_INTERFACE,
1623 .type = QUIRK_COMPOSITE,
1624 .data = (const struct snd_usb_audio_quirk[]) {
1627 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1628 .data = & (const struct audioformat) {
1629 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1636 .rates = SNDRV_PCM_RATE_44100,
1640 .rate_table = (unsigned int[]) { 44100 }
1645 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1646 .data = & (const struct audioformat) {
1647 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1654 .rates = SNDRV_PCM_RATE_44100,
1658 .rate_table = (unsigned int[]) { 44100 }
1663 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1664 .data = & (const struct snd_usb_midi_endpoint_info) {
1665 .out_cables = 0x0001,
1671 .type = QUIRK_IGNORE_INTERFACE
1675 .type = QUIRK_IGNORE_INTERFACE
1684 /* only 44.1 kHz works at the moment */
1685 USB_DEVICE(0x0582, 0x012f),
1686 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1687 /* .vendor_name = "Roland", */
1688 /* .product_name = "QUAD-CAPTURE", */
1689 .ifnum = QUIRK_ANY_INTERFACE,
1690 .type = QUIRK_COMPOSITE,
1691 .data = (const struct snd_usb_audio_quirk[]) {
1694 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1695 .data = & (const struct audioformat) {
1696 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1703 .rates = SNDRV_PCM_RATE_44100,
1707 .rate_table = (unsigned int[]) { 44100 }
1712 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1713 .data = & (const struct audioformat) {
1714 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1721 .rates = SNDRV_PCM_RATE_44100,
1725 .rate_table = (unsigned int[]) { 44100 }
1730 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1731 .data = & (const struct snd_usb_midi_endpoint_info) {
1732 .out_cables = 0x0001,
1738 .type = QUIRK_IGNORE_INTERFACE
1742 .type = QUIRK_IGNORE_INTERFACE
1751 USB_DEVICE(0x0582, 0x0159),
1752 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1753 /* .vendor_name = "Roland", */
1754 /* .product_name = "UA-22", */
1755 .ifnum = QUIRK_ANY_INTERFACE,
1756 .type = QUIRK_COMPOSITE,
1757 .data = (const struct snd_usb_audio_quirk[]) {
1760 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1764 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1768 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1769 .data = & (const struct snd_usb_midi_endpoint_info) {
1770 .out_cables = 0x0001,
1780 /* this catches most recent vendor-specific Roland devices */
1782 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1783 USB_DEVICE_ID_MATCH_INT_CLASS,
1785 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1786 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1787 .ifnum = QUIRK_ANY_INTERFACE,
1788 .type = QUIRK_AUTODETECT
1792 /* Guillemot devices */
1795 * This is for the "Windows Edition" where the external MIDI ports are
1796 * the only MIDI ports; the control data is reported through HID
1797 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard
1798 * compliant USB MIDI ports for external MIDI and controls.
1800 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1801 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1802 .vendor_name = "Hercules",
1803 .product_name = "DJ Console (WE)",
1805 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1806 .data = & (const struct snd_usb_midi_endpoint_info) {
1807 .out_cables = 0x0001,
1813 /* Midiman/M-Audio devices */
1815 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1816 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1817 .vendor_name = "M-Audio",
1818 .product_name = "MidiSport 2x2",
1819 .ifnum = QUIRK_ANY_INTERFACE,
1820 .type = QUIRK_MIDI_MIDIMAN,
1821 .data = & (const struct snd_usb_midi_endpoint_info) {
1822 .out_cables = 0x0003,
1828 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1829 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1830 .vendor_name = "M-Audio",
1831 .product_name = "MidiSport 1x1",
1832 .ifnum = QUIRK_ANY_INTERFACE,
1833 .type = QUIRK_MIDI_MIDIMAN,
1834 .data = & (const struct snd_usb_midi_endpoint_info) {
1835 .out_cables = 0x0001,
1841 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1842 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1843 .vendor_name = "M-Audio",
1844 .product_name = "Keystation",
1845 .ifnum = QUIRK_ANY_INTERFACE,
1846 .type = QUIRK_MIDI_MIDIMAN,
1847 .data = & (const struct snd_usb_midi_endpoint_info) {
1848 .out_cables = 0x0001,
1854 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1855 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1856 .vendor_name = "M-Audio",
1857 .product_name = "MidiSport 4x4",
1858 .ifnum = QUIRK_ANY_INTERFACE,
1859 .type = QUIRK_MIDI_MIDIMAN,
1860 .data = & (const struct snd_usb_midi_endpoint_info) {
1861 .out_cables = 0x000f,
1868 * For hardware revision 1.05; in the later revisions (1.10 and
1869 * 1.21), 0x1031 is the ID for the device without firmware.
1870 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1872 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1873 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1874 .vendor_name = "M-Audio",
1875 .product_name = "MidiSport 8x8",
1876 .ifnum = QUIRK_ANY_INTERFACE,
1877 .type = QUIRK_MIDI_MIDIMAN,
1878 .data = & (const struct snd_usb_midi_endpoint_info) {
1879 .out_cables = 0x01ff,
1885 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1886 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1887 .vendor_name = "M-Audio",
1888 .product_name = "MidiSport 8x8",
1889 .ifnum = QUIRK_ANY_INTERFACE,
1890 .type = QUIRK_MIDI_MIDIMAN,
1891 .data = & (const struct snd_usb_midi_endpoint_info) {
1892 .out_cables = 0x01ff,
1898 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1899 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1900 .vendor_name = "M-Audio",
1901 .product_name = "MidiSport 2x4",
1902 .ifnum = QUIRK_ANY_INTERFACE,
1903 .type = QUIRK_MIDI_MIDIMAN,
1904 .data = & (const struct snd_usb_midi_endpoint_info) {
1905 .out_cables = 0x000f,
1911 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1912 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1913 .vendor_name = "M-Audio",
1914 .product_name = "Quattro",
1915 .ifnum = QUIRK_ANY_INTERFACE,
1916 .type = QUIRK_COMPOSITE,
1917 .data = & (const struct snd_usb_audio_quirk[]) {
1919 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1920 * and share endpoints with the other interfaces.
1921 * Ignore them. The other interfaces can do 24 bits,
1922 * but captured samples are big-endian (see usbaudio.c).
1926 .type = QUIRK_IGNORE_INTERFACE
1930 .type = QUIRK_IGNORE_INTERFACE
1934 .type = QUIRK_IGNORE_INTERFACE
1938 .type = QUIRK_IGNORE_INTERFACE
1942 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1946 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1950 .type = QUIRK_IGNORE_INTERFACE
1954 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1958 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1962 .type = QUIRK_MIDI_MIDIMAN,
1963 .data = & (const struct snd_usb_midi_endpoint_info) {
1964 .out_cables = 0x0001,
1975 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1976 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1977 .vendor_name = "M-Audio",
1978 .product_name = "AudioPhile",
1980 .type = QUIRK_MIDI_MIDIMAN,
1981 .data = & (const struct snd_usb_midi_endpoint_info) {
1982 .out_cables = 0x0001,
1988 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1989 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1990 .vendor_name = "M-Audio",
1991 .product_name = "Ozone",
1993 .type = QUIRK_MIDI_MIDIMAN,
1994 .data = & (const struct snd_usb_midi_endpoint_info) {
1995 .out_cables = 0x0001,
2001 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
2002 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2003 .vendor_name = "M-Audio",
2004 .product_name = "OmniStudio",
2005 .ifnum = QUIRK_ANY_INTERFACE,
2006 .type = QUIRK_COMPOSITE,
2007 .data = & (const struct snd_usb_audio_quirk[]) {
2010 .type = QUIRK_IGNORE_INTERFACE
2014 .type = QUIRK_IGNORE_INTERFACE
2018 .type = QUIRK_IGNORE_INTERFACE
2022 .type = QUIRK_IGNORE_INTERFACE
2026 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2030 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2034 .type = QUIRK_IGNORE_INTERFACE
2038 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2042 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2046 .type = QUIRK_MIDI_MIDIMAN,
2047 .data = & (const struct snd_usb_midi_endpoint_info) {
2048 .out_cables = 0x0001,
2059 USB_DEVICE(0x0763, 0x2019),
2060 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2061 /* .vendor_name = "M-Audio", */
2062 /* .product_name = "Ozone Academic", */
2063 .ifnum = QUIRK_ANY_INTERFACE,
2064 .type = QUIRK_COMPOSITE,
2065 .data = & (const struct snd_usb_audio_quirk[]) {
2068 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2072 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2076 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2080 .type = QUIRK_MIDI_MIDIMAN,
2081 .data = & (const struct snd_usb_midi_endpoint_info) {
2082 .out_cables = 0x0001,
2094 USB_DEVICE_VENDOR_SPEC(0x0763, 0x201a),
2097 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2098 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2099 /* .vendor_name = "M-Audio", */
2100 /* .product_name = "Fast Track C400", */
2101 .ifnum = QUIRK_ANY_INTERFACE,
2102 .type = QUIRK_COMPOSITE,
2103 .data = &(const struct snd_usb_audio_quirk[]) {
2106 .type = QUIRK_AUDIO_STANDARD_MIXER,
2111 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2112 .data = &(const struct audioformat) {
2113 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2118 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2121 .rates = SNDRV_PCM_RATE_44100 |
2122 SNDRV_PCM_RATE_48000 |
2123 SNDRV_PCM_RATE_88200 |
2124 SNDRV_PCM_RATE_96000,
2128 .rate_table = (unsigned int[]) {
2129 44100, 48000, 88200, 96000
2137 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2138 .data = &(const struct audioformat) {
2139 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2144 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2147 .rates = SNDRV_PCM_RATE_44100 |
2148 SNDRV_PCM_RATE_48000 |
2149 SNDRV_PCM_RATE_88200 |
2150 SNDRV_PCM_RATE_96000,
2154 .rate_table = (unsigned int[]) {
2155 44100, 48000, 88200, 96000
2162 .ifnum = -1 /* Interface = 4 */
2168 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2169 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2170 /* .vendor_name = "M-Audio", */
2171 /* .product_name = "Fast Track C600", */
2172 .ifnum = QUIRK_ANY_INTERFACE,
2173 .type = QUIRK_COMPOSITE,
2174 .data = &(const struct snd_usb_audio_quirk[]) {
2177 .type = QUIRK_AUDIO_STANDARD_MIXER,
2182 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2183 .data = &(const struct audioformat) {
2184 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2189 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2192 .rates = SNDRV_PCM_RATE_44100 |
2193 SNDRV_PCM_RATE_48000 |
2194 SNDRV_PCM_RATE_88200 |
2195 SNDRV_PCM_RATE_96000,
2199 .rate_table = (unsigned int[]) {
2200 44100, 48000, 88200, 96000
2208 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2209 .data = &(const struct audioformat) {
2210 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2215 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2218 .rates = SNDRV_PCM_RATE_44100 |
2219 SNDRV_PCM_RATE_48000 |
2220 SNDRV_PCM_RATE_88200 |
2221 SNDRV_PCM_RATE_96000,
2225 .rate_table = (unsigned int[]) {
2226 44100, 48000, 88200, 96000
2233 .ifnum = -1 /* Interface = 4 */
2239 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2240 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2241 /* .vendor_name = "M-Audio", */
2242 /* .product_name = "Fast Track Ultra", */
2243 .ifnum = QUIRK_ANY_INTERFACE,
2244 .type = QUIRK_COMPOSITE,
2245 .data = & (const struct snd_usb_audio_quirk[]) {
2248 .type = QUIRK_AUDIO_STANDARD_MIXER,
2252 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2253 .data = & (const struct audioformat) {
2254 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2259 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2262 .rates = SNDRV_PCM_RATE_44100 |
2263 SNDRV_PCM_RATE_48000 |
2264 SNDRV_PCM_RATE_88200 |
2265 SNDRV_PCM_RATE_96000,
2269 .rate_table = (unsigned int[]) {
2270 44100, 48000, 88200, 96000
2276 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2277 .data = & (const struct audioformat) {
2278 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2283 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2286 .rates = SNDRV_PCM_RATE_44100 |
2287 SNDRV_PCM_RATE_48000 |
2288 SNDRV_PCM_RATE_88200 |
2289 SNDRV_PCM_RATE_96000,
2293 .rate_table = (unsigned int[]) {
2294 44100, 48000, 88200, 96000
2298 /* interface 3 (MIDI) is standard compliant */
2306 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2307 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2308 /* .vendor_name = "M-Audio", */
2309 /* .product_name = "Fast Track Ultra 8R", */
2310 .ifnum = QUIRK_ANY_INTERFACE,
2311 .type = QUIRK_COMPOSITE,
2312 .data = & (const struct snd_usb_audio_quirk[]) {
2315 .type = QUIRK_AUDIO_STANDARD_MIXER,
2319 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2320 .data = & (const struct audioformat) {
2321 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2326 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2329 .rates = SNDRV_PCM_RATE_44100 |
2330 SNDRV_PCM_RATE_48000 |
2331 SNDRV_PCM_RATE_88200 |
2332 SNDRV_PCM_RATE_96000,
2336 .rate_table = (unsigned int[]) {
2337 44100, 48000, 88200, 96000
2343 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2344 .data = & (const struct audioformat) {
2345 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2350 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2353 .rates = SNDRV_PCM_RATE_44100 |
2354 SNDRV_PCM_RATE_48000 |
2355 SNDRV_PCM_RATE_88200 |
2356 SNDRV_PCM_RATE_96000,
2360 .rate_table = (unsigned int[]) {
2361 44100, 48000, 88200, 96000
2365 /* interface 3 (MIDI) is standard compliant */
2375 USB_DEVICE(0x07cf, 0x6801),
2376 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2377 .vendor_name = "Casio",
2378 .product_name = "PL-40R",
2380 .type = QUIRK_MIDI_YAMAHA
2384 /* this ID is used by several devices without a product ID */
2385 USB_DEVICE(0x07cf, 0x6802),
2386 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2387 .vendor_name = "Casio",
2388 .product_name = "Keyboard",
2390 .type = QUIRK_MIDI_YAMAHA
2394 /* Mark of the Unicorn devices */
2396 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2397 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2398 USB_DEVICE_ID_MATCH_PRODUCT |
2399 USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2401 .idProduct = 0x0001,
2402 .bDeviceSubClass = 2,
2403 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2404 .vendor_name = "MOTU",
2405 .product_name = "Fastlane",
2406 .ifnum = QUIRK_ANY_INTERFACE,
2407 .type = QUIRK_COMPOSITE,
2408 .data = & (const struct snd_usb_audio_quirk[]) {
2411 .type = QUIRK_MIDI_RAW_BYTES
2415 .type = QUIRK_IGNORE_INTERFACE
2424 /* Emagic devices */
2426 USB_DEVICE(0x086a, 0x0001),
2427 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2428 .vendor_name = "Emagic",
2429 /* .product_name = "Unitor8", */
2431 .type = QUIRK_MIDI_EMAGIC,
2432 .data = & (const struct snd_usb_midi_endpoint_info) {
2433 .out_cables = 0x80ff,
2439 USB_DEVICE(0x086a, 0x0002),
2440 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2441 .vendor_name = "Emagic",
2442 /* .product_name = "AMT8", */
2444 .type = QUIRK_MIDI_EMAGIC,
2445 .data = & (const struct snd_usb_midi_endpoint_info) {
2446 .out_cables = 0x80ff,
2452 USB_DEVICE(0x086a, 0x0003),
2453 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2454 .vendor_name = "Emagic",
2455 /* .product_name = "MT4", */
2457 .type = QUIRK_MIDI_EMAGIC,
2458 .data = & (const struct snd_usb_midi_endpoint_info) {
2459 .out_cables = 0x800f,
2467 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2468 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2469 .vendor_name = "KORG, Inc.",
2470 /* .product_name = "PANDORA PX5D", */
2472 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2477 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2478 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2479 .vendor_name = "KORG, Inc.",
2480 /* .product_name = "ToneLab ST", */
2482 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2487 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0204),
2488 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2489 .vendor_name = "KORG, Inc.",
2490 /* .product_name = "ToneLab EX", */
2492 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2498 USB_DEVICE(0x09e8, 0x0062),
2499 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2500 .vendor_name = "AKAI",
2501 .product_name = "MPD16",
2503 .type = QUIRK_MIDI_AKAI,
2508 /* Akai MPC Element */
2509 USB_DEVICE(0x09e8, 0x0021),
2510 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2511 .ifnum = QUIRK_ANY_INTERFACE,
2512 .type = QUIRK_COMPOSITE,
2513 .data = & (const struct snd_usb_audio_quirk[]) {
2516 .type = QUIRK_IGNORE_INTERFACE
2520 .type = QUIRK_MIDI_STANDARD_INTERFACE
2529 /* Steinberg devices */
2532 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2533 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2534 .ifnum = QUIRK_ANY_INTERFACE,
2535 .type = QUIRK_COMPOSITE,
2536 .data = & (const struct snd_usb_audio_quirk[]) {
2539 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2543 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2547 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2551 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2552 .data = &(const struct snd_usb_midi_endpoint_info) {
2553 .out_cables = 0x0001,
2565 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2566 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2567 .ifnum = QUIRK_ANY_INTERFACE,
2568 .type = QUIRK_COMPOSITE,
2569 .data = & (const struct snd_usb_audio_quirk[]) {
2572 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2576 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2580 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2584 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2585 .data = &(const struct snd_usb_midi_endpoint_info) {
2586 .out_cables = 0x0001,
2597 /* TerraTec devices */
2599 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2600 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2601 .vendor_name = "TerraTec",
2602 .product_name = "PHASE 26",
2604 .type = QUIRK_MIDI_STANDARD_INTERFACE
2608 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2609 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2610 .vendor_name = "TerraTec",
2611 .product_name = "PHASE 26",
2613 .type = QUIRK_MIDI_STANDARD_INTERFACE
2617 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2618 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2619 .vendor_name = "TerraTec",
2620 .product_name = "PHASE 26",
2622 .type = QUIRK_MIDI_STANDARD_INTERFACE
2626 USB_DEVICE(0x0ccd, 0x0028),
2627 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2628 .vendor_name = "TerraTec",
2629 .product_name = "Aureon5.1MkII",
2630 .ifnum = QUIRK_NO_INTERFACE
2634 USB_DEVICE(0x0ccd, 0x0035),
2635 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2636 .vendor_name = "Miditech",
2637 .product_name = "Play'n Roll",
2639 .type = QUIRK_MIDI_CME
2643 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2645 USB_DEVICE(0x103d, 0x0100),
2646 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2647 .vendor_name = "Stanton",
2648 .product_name = "ScratchAmp",
2649 .ifnum = QUIRK_NO_INTERFACE
2653 USB_DEVICE(0x103d, 0x0101),
2654 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2655 .vendor_name = "Stanton",
2656 .product_name = "ScratchAmp",
2657 .ifnum = QUIRK_NO_INTERFACE
2661 /* Novation EMS devices */
2663 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2664 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2665 .vendor_name = "Novation",
2666 .product_name = "ReMOTE Audio/XStation",
2668 .type = QUIRK_MIDI_NOVATION
2672 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2673 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2674 .vendor_name = "Novation",
2675 .product_name = "Speedio",
2677 .type = QUIRK_MIDI_NOVATION
2681 USB_DEVICE(0x1235, 0x000a),
2682 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2683 /* .vendor_name = "Novation", */
2684 /* .product_name = "Nocturn", */
2686 .type = QUIRK_MIDI_RAW_BYTES
2690 USB_DEVICE(0x1235, 0x000e),
2691 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2692 /* .vendor_name = "Novation", */
2693 /* .product_name = "Launchpad", */
2695 .type = QUIRK_MIDI_RAW_BYTES
2699 USB_DEVICE(0x1235, 0x0010),
2700 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2701 .vendor_name = "Focusrite",
2702 .product_name = "Saffire 6 USB",
2703 .ifnum = QUIRK_ANY_INTERFACE,
2704 .type = QUIRK_COMPOSITE,
2705 .data = (const struct snd_usb_audio_quirk[]) {
2708 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2709 .data = &(const struct audioformat) {
2710 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2715 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2717 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2718 .rates = SNDRV_PCM_RATE_44100 |
2719 SNDRV_PCM_RATE_48000,
2723 .rate_table = (unsigned int[]) {
2730 .type = QUIRK_MIDI_RAW_BYTES
2739 USB_DEVICE(0x1235, 0x0018),
2740 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2741 .vendor_name = "Novation",
2742 .product_name = "Twitch",
2743 .ifnum = QUIRK_ANY_INTERFACE,
2744 .type = QUIRK_COMPOSITE,
2745 .data = (const struct snd_usb_audio_quirk[]) {
2748 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2749 .data = & (const struct audioformat) {
2750 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2755 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2757 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2758 .rates = SNDRV_PCM_RATE_44100 |
2759 SNDRV_PCM_RATE_48000,
2763 .rate_table = (unsigned int[]) {
2770 .type = QUIRK_MIDI_RAW_BYTES
2779 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2780 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2781 .vendor_name = "Novation",
2782 .product_name = "ReMOTE25",
2784 .type = QUIRK_MIDI_NOVATION
2788 /* Access Music devices */
2790 /* VirusTI Desktop */
2791 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2792 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2793 .ifnum = QUIRK_ANY_INTERFACE,
2794 .type = QUIRK_COMPOSITE,
2795 .data = &(const struct snd_usb_audio_quirk[]) {
2798 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2799 .data = &(const struct snd_usb_midi_endpoint_info) {
2800 .out_cables = 0x0003,
2806 .type = QUIRK_IGNORE_INTERFACE
2817 /* aka. Serato Scratch Live DJ Box */
2818 USB_DEVICE(0x13e5, 0x0001),
2819 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2820 .vendor_name = "Rane",
2821 .product_name = "SL-1",
2822 .ifnum = QUIRK_NO_INTERFACE
2826 /* Native Instruments MK2 series */
2828 /* Komplete Audio 6 */
2829 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2831 .idProduct = 0x1000,
2834 /* Traktor Audio 6 */
2835 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2837 .idProduct = 0x1010,
2840 /* Traktor Audio 10 */
2841 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2843 .idProduct = 0x1020,
2846 /* QinHeng devices */
2848 USB_DEVICE(0x1a86, 0x752d),
2849 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2850 .vendor_name = "QinHeng",
2851 .product_name = "CH345",
2853 .type = QUIRK_MIDI_CH345
2857 /* KeithMcMillen Stringport */
2859 USB_DEVICE(0x1f38, 0x0001),
2860 .bInterfaceClass = USB_CLASS_AUDIO,
2863 /* Miditech devices */
2865 USB_DEVICE(0x4752, 0x0011),
2866 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2867 .vendor_name = "Miditech",
2868 .product_name = "Midistart-2",
2870 .type = QUIRK_MIDI_CME
2874 /* Central Music devices */
2876 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2877 USB_DEVICE(0x7104, 0x2202),
2878 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2880 .type = QUIRK_MIDI_CME
2885 * Auvitek au0828 devices with audio interface.
2886 * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
2887 * Please notice that some drivers are DVB only, and don't need to be
2888 * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2891 #define AU0828_DEVICE(vid, pid, vname, pname) { \
2894 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
2895 USB_DEVICE_ID_MATCH_INT_CLASS | \
2896 USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
2897 .bInterfaceClass = USB_CLASS_AUDIO, \
2898 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, \
2899 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2900 .vendor_name = vname, \
2901 .product_name = pname, \
2902 .ifnum = QUIRK_ANY_INTERFACE, \
2903 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
2907 AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2908 AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2909 AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
2910 AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
2911 AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
2912 AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
2913 AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
2914 AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
2915 AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
2916 AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
2917 AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
2918 AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
2919 AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
2920 AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
2921 AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
2922 AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
2923 AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
2925 /* Syntek STK1160 */
2927 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2928 USB_DEVICE_ID_MATCH_INT_CLASS |
2929 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2931 .idProduct = 0x0408,
2932 .bInterfaceClass = USB_CLASS_AUDIO,
2933 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2934 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2935 .vendor_name = "Syntek",
2936 .product_name = "STK1160",
2937 .ifnum = QUIRK_ANY_INTERFACE,
2938 .type = QUIRK_AUDIO_ALIGN_TRANSFER
2942 /* Digidesign Mbox */
2944 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2945 USB_DEVICE(0x0dba, 0x1000),
2946 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2947 .vendor_name = "Digidesign",
2948 .product_name = "MBox",
2949 .ifnum = QUIRK_ANY_INTERFACE,
2950 .type = QUIRK_COMPOSITE,
2951 .data = (const struct snd_usb_audio_quirk[]){
2954 .type = QUIRK_AUDIO_STANDARD_MIXER,
2958 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2959 .data = &(const struct audioformat) {
2960 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2967 .ep_attr = USB_ENDPOINT_XFER_ISOC |
2968 USB_ENDPOINT_SYNC_SYNC,
2969 .maxpacksize = 0x130,
2970 .rates = SNDRV_PCM_RATE_48000,
2974 .rate_table = (unsigned int[]) {
2981 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2982 .data = &(const struct audioformat) {
2983 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2990 .ep_attr = USB_ENDPOINT_XFER_ISOC |
2991 USB_ENDPOINT_SYNC_ASYNC,
2992 .maxpacksize = 0x130,
2993 .rates = SNDRV_PCM_RATE_48000,
2997 .rate_table = (unsigned int[]) {
3009 /* DIGIDESIGN MBOX 2 */
3011 USB_DEVICE(0x0dba, 0x3000),
3012 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3013 .vendor_name = "Digidesign",
3014 .product_name = "Mbox 2",
3015 .ifnum = QUIRK_ANY_INTERFACE,
3016 .type = QUIRK_COMPOSITE,
3017 .data = (const struct snd_usb_audio_quirk[]) {
3020 .type = QUIRK_IGNORE_INTERFACE
3024 .type = QUIRK_IGNORE_INTERFACE
3028 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3029 .data = &(const struct audioformat) {
3030 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3037 .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
3038 .rates = SNDRV_PCM_RATE_48000,
3042 .rate_table = (unsigned int[]) {
3049 .type = QUIRK_IGNORE_INTERFACE
3053 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3054 .data = &(const struct audioformat) {
3055 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3060 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3062 .ep_attr = USB_ENDPOINT_SYNC_SYNC,
3063 .rates = SNDRV_PCM_RATE_48000,
3067 .rate_table = (unsigned int[]) {
3074 .type = QUIRK_IGNORE_INTERFACE
3078 .type = QUIRK_MIDI_MIDIMAN,
3079 .data = &(const struct snd_usb_midi_endpoint_info) {
3081 .out_cables = 0x0001,
3083 .in_interval = 0x01,
3094 /* Tascam US122 MKII - playback-only support */
3095 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
3097 .idProduct = 0x8021,
3098 .bInterfaceClass = USB_CLASS_AUDIO,
3099 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3100 .vendor_name = "TASCAM",
3101 .product_name = "US122 MKII",
3102 .ifnum = QUIRK_ANY_INTERFACE,
3103 .type = QUIRK_COMPOSITE,
3104 .data = (const struct snd_usb_audio_quirk[]) {
3107 .type = QUIRK_IGNORE_INTERFACE
3111 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3112 .data = &(const struct audioformat) {
3113 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3118 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3120 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3121 .rates = SNDRV_PCM_RATE_44100 |
3122 SNDRV_PCM_RATE_48000 |
3123 SNDRV_PCM_RATE_88200 |
3124 SNDRV_PCM_RATE_96000,
3128 .rate_table = (unsigned int[]) {
3129 44100, 48000, 88200, 96000
3140 /* Microsoft XboxLive Headset/Xbox Communicator */
3142 USB_DEVICE(0x045e, 0x0283),
3143 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3144 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3145 .vendor_name = "Microsoft",
3146 .product_name = "XboxLive Headset/Xbox Communicator",
3147 .ifnum = QUIRK_ANY_INTERFACE,
3148 .type = QUIRK_COMPOSITE,
3149 .data = &(const struct snd_usb_audio_quirk[]) {
3153 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3154 .data = &(const struct audioformat) {
3155 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3163 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3171 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3172 .data = &(const struct audioformat) {
3173 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3181 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3195 USB_DEVICE(0x200c, 0x100b),
3196 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3197 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3198 .ifnum = QUIRK_ANY_INTERFACE,
3199 .type = QUIRK_COMPOSITE,
3200 .data = &(const struct snd_usb_audio_quirk[]) {
3203 .type = QUIRK_AUDIO_STANDARD_MIXER,
3207 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3208 .data = &(const struct audioformat) {
3209 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3214 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3216 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3217 .rates = SNDRV_PCM_RATE_44100 |
3218 SNDRV_PCM_RATE_48000,
3222 .rate_table = (unsigned int[]) {
3236 * ZOOM R16/24 in audio interface mode.
3237 * Playback requires an extra four byte LE length indicator
3238 * at the start of each isochronous packet. This quirk is
3239 * enabled in create_standard_audio_quirk().
3241 USB_DEVICE(0x1686, 0x00dd),
3242 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3243 .ifnum = QUIRK_ANY_INTERFACE,
3244 .type = QUIRK_COMPOSITE,
3245 .data = (const struct snd_usb_audio_quirk[]) {
3249 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3254 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3259 .type = QUIRK_MIDI_STANDARD_INTERFACE
3270 * Some USB MIDI devices don't have an audio control interface,
3271 * so we have to grab MIDI streaming interfaces here.
3273 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3274 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3275 .bInterfaceClass = USB_CLASS_AUDIO,
3276 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3277 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3278 .ifnum = QUIRK_ANY_INTERFACE,
3279 .type = QUIRK_MIDI_STANDARD_INTERFACE
3285 * The original product_name is "USB Sound Device", however this name
3286 * is also used by the CM106 based cards, so make it unique.
3288 USB_DEVICE(0x0d8c, 0x0103),
3289 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3290 .product_name = "Audio Advantage MicroII",
3291 .ifnum = QUIRK_NO_INTERFACE
3297 * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3298 * even though it advertises more. The capture interface doesn't work
3301 USB_DEVICE(0x19b5, 0x0021),
3302 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3303 .ifnum = QUIRK_ANY_INTERFACE,
3304 .type = QUIRK_COMPOSITE,
3305 .data = (const struct snd_usb_audio_quirk[]) {
3308 .type = QUIRK_AUDIO_STANDARD_MIXER,
3313 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3314 .data = &(const struct audioformat) {
3315 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3320 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3321 UAC_EP_CS_ATTR_SAMPLE_RATE,
3323 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3324 .rates = SNDRV_PCM_RATE_48000,
3328 .rate_table = (unsigned int[]) {
3341 * MacroSilicon MS2100/MS2106 based AV capture cards
3343 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3344 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if
3345 * they pretend to be 96kHz mono as a workaround for stereo being broken
3348 * They also have an issue with initial stream alignment that causes the
3349 * channels to be swapped and out of phase, which is dealt with in quirks.c.
3352 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
3353 USB_DEVICE_ID_MATCH_INT_CLASS |
3354 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3356 .idProduct = 0x0021,
3357 .bInterfaceClass = USB_CLASS_AUDIO,
3358 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
3359 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3360 .vendor_name = "MacroSilicon",
3361 .product_name = "MS210x",
3362 .ifnum = QUIRK_ANY_INTERFACE,
3363 .type = QUIRK_COMPOSITE,
3364 .data = &(const struct snd_usb_audio_quirk[]) {
3367 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
3371 .type = QUIRK_AUDIO_STANDARD_MIXER,
3375 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3376 .data = &(const struct audioformat) {
3377 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3384 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3385 USB_ENDPOINT_SYNC_ASYNC,
3386 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3399 * MacroSilicon MS2109 based HDMI capture cards
3401 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3402 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if
3403 * they pretend to be 96kHz mono as a workaround for stereo being broken
3406 * They also have an issue with initial stream alignment that causes the
3407 * channels to be swapped and out of phase, which is dealt with in quirks.c.
3410 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
3411 USB_DEVICE_ID_MATCH_INT_CLASS |
3412 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3414 .idProduct = 0x2109,
3415 .bInterfaceClass = USB_CLASS_AUDIO,
3416 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
3417 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3418 .vendor_name = "MacroSilicon",
3419 .product_name = "MS2109",
3420 .ifnum = QUIRK_ANY_INTERFACE,
3421 .type = QUIRK_COMPOSITE,
3422 .data = &(const struct snd_usb_audio_quirk[]) {
3425 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
3429 .type = QUIRK_AUDIO_STANDARD_MIXER,
3433 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3434 .data = &(const struct audioformat) {
3435 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3442 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3443 USB_ENDPOINT_SYNC_ASYNC,
3444 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3458 * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3459 * The feedback for the output is the dummy input.
3461 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3462 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3463 .ifnum = QUIRK_ANY_INTERFACE,
3464 .type = QUIRK_COMPOSITE,
3465 .data = (const struct snd_usb_audio_quirk[]) {
3468 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3469 .data = &(const struct audioformat) {
3470 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3476 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3477 USB_ENDPOINT_SYNC_ASYNC,
3478 .rates = SNDRV_PCM_RATE_44100,
3482 .rate_table = (unsigned int[]) { 44100 }
3487 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3488 .data = &(const struct audioformat) {
3489 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3495 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3496 USB_ENDPOINT_SYNC_ASYNC|
3497 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3498 .rates = SNDRV_PCM_RATE_44100,
3502 .rate_table = (unsigned int[]) { 44100 }
3514 * Change order of interfaces loaded
3516 USB_DEVICE(0x1395, 0x0300),
3517 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3518 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3519 .ifnum = QUIRK_ANY_INTERFACE,
3520 .type = QUIRK_COMPOSITE,
3521 .data = &(const struct snd_usb_audio_quirk[]) {
3525 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3530 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3535 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3544 #undef USB_DEVICE_VENDOR_SPEC