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
42 /* HP Thunderbolt Dock Audio Headset */
44 USB_DEVICE(0x03f0, 0x0269),
45 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
47 .product_name = "Thunderbolt Dock Audio Headset",
48 .profile_name = "HP-Thunderbolt-Dock-Audio-Headset",
49 .ifnum = QUIRK_NO_INTERFACE
52 /* HP Thunderbolt Dock Audio Module */
54 USB_DEVICE(0x03f0, 0x0567),
55 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
57 .product_name = "Thunderbolt Dock Audio Module",
58 .profile_name = "HP-Thunderbolt-Dock-Audio-Module",
59 .ifnum = QUIRK_NO_INTERFACE
64 USB_DEVICE(0x0403, 0xb8d8),
65 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
66 /* .vendor_name = "STARR LABS", */
67 /* .product_name = "Starr Labs MIDI USB device", */
69 .type = QUIRK_MIDI_FTDI
75 USB_DEVICE(0x041e, 0x0005),
76 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
78 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
79 .data = &(const struct audioformat) {
80 .formats = SNDRV_PCM_FMTBIT_S16_LE,
86 .ep_attr = USB_ENDPOINT_XFER_ISOC,
88 .rates = SNDRV_PCM_RATE_CONTINUOUS,
95 /* Creative/E-Mu devices */
97 USB_DEVICE(0x041e, 0x3010),
98 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
99 .vendor_name = "Creative Labs",
100 .product_name = "Sound Blaster MP3+",
101 .ifnum = QUIRK_NO_INTERFACE
104 /* Creative/Toshiba Multimedia Center SB-0500 */
106 USB_DEVICE(0x041e, 0x3048),
107 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
108 .vendor_name = "Toshiba",
109 .product_name = "SB-0500",
110 .ifnum = QUIRK_NO_INTERFACE
115 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
118 .bInterfaceClass = USB_CLASS_AUDIO,
122 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
125 .bInterfaceClass = USB_CLASS_AUDIO,
128 /* E-Mu Tracker Pre */
129 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
132 .bInterfaceClass = USB_CLASS_AUDIO,
136 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
139 .bInterfaceClass = USB_CLASS_AUDIO,
144 * When not ignored, causes instability issues for some users, forcing them to
145 * blacklist the entire module.
148 USB_DEVICE(0x0424, 0xb832),
149 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
150 .vendor_name = "Standard Microsystems Corp.",
151 .product_name = "HP Wireless Audio",
152 .ifnum = QUIRK_ANY_INTERFACE,
153 .type = QUIRK_COMPOSITE,
154 .data = (const struct snd_usb_audio_quirk[]) {
158 .type = QUIRK_IGNORE_INTERFACE,
163 .type = QUIRK_IGNORE_INTERFACE,
168 .type = QUIRK_IGNORE_INTERFACE,
170 /* HID Device, .ifnum = 3 */
179 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
180 * class matches do not take effect without an explicit ID match.
183 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
184 USB_DEVICE_ID_MATCH_INT_CLASS |
185 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
188 .bInterfaceClass = USB_CLASS_AUDIO,
189 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
192 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
193 USB_DEVICE_ID_MATCH_INT_CLASS |
194 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
197 .bInterfaceClass = USB_CLASS_AUDIO,
198 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
201 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
202 USB_DEVICE_ID_MATCH_INT_CLASS |
203 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
206 .bInterfaceClass = USB_CLASS_AUDIO,
207 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
210 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
211 USB_DEVICE_ID_MATCH_INT_CLASS |
212 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
215 .bInterfaceClass = USB_CLASS_AUDIO,
216 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
219 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
220 USB_DEVICE_ID_MATCH_INT_CLASS |
221 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
224 .bInterfaceClass = USB_CLASS_AUDIO,
225 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
228 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
229 USB_DEVICE_ID_MATCH_INT_CLASS |
230 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
233 .bInterfaceClass = USB_CLASS_AUDIO,
234 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
237 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
238 USB_DEVICE_ID_MATCH_INT_CLASS |
239 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
242 .bInterfaceClass = USB_CLASS_AUDIO,
243 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
244 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
245 .vendor_name = "Logitech, Inc.",
246 .product_name = "QuickCam Pro 9000",
247 .ifnum = QUIRK_NO_INTERFACE
255 #define YAMAHA_DEVICE(id, name) { \
256 USB_DEVICE(0x0499, id), \
257 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
258 .vendor_name = "Yamaha", \
259 .product_name = name, \
260 .ifnum = QUIRK_ANY_INTERFACE, \
261 .type = QUIRK_MIDI_YAMAHA \
264 #define YAMAHA_INTERFACE(id, intf, name) { \
265 USB_DEVICE_VENDOR_SPEC(0x0499, id), \
266 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
267 .vendor_name = "Yamaha", \
268 .product_name = name, \
270 .type = QUIRK_MIDI_YAMAHA \
273 YAMAHA_DEVICE(0x1000, "UX256"),
274 YAMAHA_DEVICE(0x1001, "MU1000"),
275 YAMAHA_DEVICE(0x1002, "MU2000"),
276 YAMAHA_DEVICE(0x1003, "MU500"),
277 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
278 YAMAHA_DEVICE(0x1005, "MOTIF6"),
279 YAMAHA_DEVICE(0x1006, "MOTIF7"),
280 YAMAHA_DEVICE(0x1007, "MOTIF8"),
281 YAMAHA_DEVICE(0x1008, "UX96"),
282 YAMAHA_DEVICE(0x1009, "UX16"),
283 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
284 YAMAHA_DEVICE(0x100c, "UC-MX"),
285 YAMAHA_DEVICE(0x100d, "UC-KX"),
286 YAMAHA_DEVICE(0x100e, "S08"),
287 YAMAHA_DEVICE(0x100f, "CLP-150"),
288 YAMAHA_DEVICE(0x1010, "CLP-170"),
289 YAMAHA_DEVICE(0x1011, "P-250"),
290 YAMAHA_DEVICE(0x1012, "TYROS"),
291 YAMAHA_DEVICE(0x1013, "PF-500"),
292 YAMAHA_DEVICE(0x1014, "S90"),
293 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
294 YAMAHA_DEVICE(0x1016, "MDP-5"),
295 YAMAHA_DEVICE(0x1017, "CVP-204"),
296 YAMAHA_DEVICE(0x1018, "CVP-206"),
297 YAMAHA_DEVICE(0x1019, "CVP-208"),
298 YAMAHA_DEVICE(0x101a, "CVP-210"),
299 YAMAHA_DEVICE(0x101b, "PSR-1100"),
300 YAMAHA_DEVICE(0x101c, "PSR-2100"),
301 YAMAHA_DEVICE(0x101d, "CLP-175"),
302 YAMAHA_DEVICE(0x101e, "PSR-K1"),
303 YAMAHA_DEVICE(0x101f, "EZ-J24"),
304 YAMAHA_DEVICE(0x1020, "EZ-250i"),
305 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
306 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
307 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
308 YAMAHA_DEVICE(0x1024, "CVP-301"),
309 YAMAHA_DEVICE(0x1025, "CVP-303"),
310 YAMAHA_DEVICE(0x1026, "CVP-305"),
311 YAMAHA_DEVICE(0x1027, "CVP-307"),
312 YAMAHA_DEVICE(0x1028, "CVP-309"),
313 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
314 YAMAHA_DEVICE(0x102a, "PSR-1500"),
315 YAMAHA_DEVICE(0x102b, "PSR-3000"),
316 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
317 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
318 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
319 YAMAHA_DEVICE(0x1032, "DGX-305"),
320 YAMAHA_DEVICE(0x1033, "DGX-505"),
321 YAMAHA_DEVICE(0x1034, NULL),
322 YAMAHA_DEVICE(0x1035, NULL),
323 YAMAHA_DEVICE(0x1036, NULL),
324 YAMAHA_DEVICE(0x1037, NULL),
325 YAMAHA_DEVICE(0x1038, NULL),
326 YAMAHA_DEVICE(0x1039, NULL),
327 YAMAHA_DEVICE(0x103a, NULL),
328 YAMAHA_DEVICE(0x103b, NULL),
329 YAMAHA_DEVICE(0x103c, NULL),
330 YAMAHA_DEVICE(0x103d, NULL),
331 YAMAHA_DEVICE(0x103e, NULL),
332 YAMAHA_DEVICE(0x103f, NULL),
333 YAMAHA_DEVICE(0x1040, NULL),
334 YAMAHA_DEVICE(0x1041, NULL),
335 YAMAHA_DEVICE(0x1042, NULL),
336 YAMAHA_DEVICE(0x1043, NULL),
337 YAMAHA_DEVICE(0x1044, NULL),
338 YAMAHA_DEVICE(0x1045, NULL),
339 YAMAHA_INTERFACE(0x104e, 0, NULL),
340 YAMAHA_DEVICE(0x104f, NULL),
341 YAMAHA_DEVICE(0x1050, NULL),
342 YAMAHA_DEVICE(0x1051, NULL),
343 YAMAHA_DEVICE(0x1052, NULL),
344 YAMAHA_INTERFACE(0x1053, 0, NULL),
345 YAMAHA_INTERFACE(0x1054, 0, NULL),
346 YAMAHA_DEVICE(0x1055, NULL),
347 YAMAHA_DEVICE(0x1056, NULL),
348 YAMAHA_DEVICE(0x1057, NULL),
349 YAMAHA_DEVICE(0x1058, NULL),
350 YAMAHA_DEVICE(0x1059, NULL),
351 YAMAHA_DEVICE(0x105a, NULL),
352 YAMAHA_DEVICE(0x105b, NULL),
353 YAMAHA_DEVICE(0x105c, NULL),
354 YAMAHA_DEVICE(0x105d, NULL),
356 USB_DEVICE(0x0499, 0x1503),
357 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
358 /* .vendor_name = "Yamaha", */
359 /* .product_name = "MOX6/MOX8", */
360 .ifnum = QUIRK_ANY_INTERFACE,
361 .type = QUIRK_COMPOSITE,
362 .data = (const struct snd_usb_audio_quirk[]) {
365 .type = QUIRK_AUDIO_STANDARD_INTERFACE
369 .type = QUIRK_AUDIO_STANDARD_INTERFACE
373 .type = QUIRK_MIDI_YAMAHA
382 USB_DEVICE(0x0499, 0x1507),
383 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
384 /* .vendor_name = "Yamaha", */
385 /* .product_name = "THR10", */
386 .ifnum = QUIRK_ANY_INTERFACE,
387 .type = QUIRK_COMPOSITE,
388 .data = (const struct snd_usb_audio_quirk[]) {
391 .type = QUIRK_AUDIO_STANDARD_INTERFACE
395 .type = QUIRK_AUDIO_STANDARD_INTERFACE
399 .type = QUIRK_MIDI_YAMAHA
408 USB_DEVICE(0x0499, 0x1509),
409 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
410 /* .vendor_name = "Yamaha", */
411 /* .product_name = "Steinberg UR22", */
412 .ifnum = QUIRK_ANY_INTERFACE,
413 .type = QUIRK_COMPOSITE,
414 .data = (const struct snd_usb_audio_quirk[]) {
417 .type = QUIRK_AUDIO_STANDARD_INTERFACE
421 .type = QUIRK_AUDIO_STANDARD_INTERFACE
425 .type = QUIRK_MIDI_YAMAHA
429 .type = QUIRK_IGNORE_INTERFACE
438 USB_DEVICE(0x0499, 0x150a),
439 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
440 /* .vendor_name = "Yamaha", */
441 /* .product_name = "THR5A", */
442 .ifnum = QUIRK_ANY_INTERFACE,
443 .type = QUIRK_COMPOSITE,
444 .data = (const struct snd_usb_audio_quirk[]) {
447 .type = QUIRK_AUDIO_STANDARD_INTERFACE
451 .type = QUIRK_AUDIO_STANDARD_INTERFACE
455 .type = QUIRK_MIDI_YAMAHA
464 USB_DEVICE(0x0499, 0x150c),
465 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
466 /* .vendor_name = "Yamaha", */
467 /* .product_name = "THR10C", */
468 .ifnum = QUIRK_ANY_INTERFACE,
469 .type = QUIRK_COMPOSITE,
470 .data = (const struct snd_usb_audio_quirk[]) {
473 .type = QUIRK_AUDIO_STANDARD_INTERFACE
477 .type = QUIRK_AUDIO_STANDARD_INTERFACE
481 .type = QUIRK_MIDI_YAMAHA
489 YAMAHA_DEVICE(0x2000, "DGP-7"),
490 YAMAHA_DEVICE(0x2001, "DGP-5"),
491 YAMAHA_DEVICE(0x2002, NULL),
492 YAMAHA_DEVICE(0x2003, NULL),
493 YAMAHA_DEVICE(0x5000, "CS1D"),
494 YAMAHA_DEVICE(0x5001, "DSP1D"),
495 YAMAHA_DEVICE(0x5002, "DME32"),
496 YAMAHA_DEVICE(0x5003, "DM2000"),
497 YAMAHA_DEVICE(0x5004, "02R96"),
498 YAMAHA_DEVICE(0x5005, "ACU16-C"),
499 YAMAHA_DEVICE(0x5006, "NHB32-C"),
500 YAMAHA_DEVICE(0x5007, "DM1000"),
501 YAMAHA_DEVICE(0x5008, "01V96"),
502 YAMAHA_DEVICE(0x5009, "SPX2000"),
503 YAMAHA_DEVICE(0x500a, "PM5D"),
504 YAMAHA_DEVICE(0x500b, "DME64N"),
505 YAMAHA_DEVICE(0x500c, "DME24N"),
506 YAMAHA_DEVICE(0x500d, NULL),
507 YAMAHA_DEVICE(0x500e, NULL),
508 YAMAHA_DEVICE(0x500f, NULL),
509 YAMAHA_DEVICE(0x7000, "DTX"),
510 YAMAHA_DEVICE(0x7010, "UB99"),
512 #undef YAMAHA_INTERFACE
513 /* this catches most recent vendor-specific Yamaha devices */
515 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
516 USB_DEVICE_ID_MATCH_INT_CLASS,
518 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
519 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
520 .ifnum = QUIRK_ANY_INTERFACE,
521 .type = QUIRK_AUTODETECT
526 * Roland/RolandED/Edirol/BOSS devices
529 USB_DEVICE(0x0582, 0x0000),
530 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
531 .vendor_name = "Roland",
532 .product_name = "UA-100",
533 .ifnum = QUIRK_ANY_INTERFACE,
534 .type = QUIRK_COMPOSITE,
535 .data = (const struct snd_usb_audio_quirk[]) {
538 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
539 .data = & (const struct audioformat) {
540 .formats = SNDRV_PCM_FMTBIT_S16_LE,
548 .rates = SNDRV_PCM_RATE_CONTINUOUS,
555 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
556 .data = & (const struct audioformat) {
557 .formats = SNDRV_PCM_FMTBIT_S16_LE,
562 .attributes = UAC_EP_CS_ATTR_FILL_MAX,
565 .rates = SNDRV_PCM_RATE_CONTINUOUS,
572 .type = QUIRK_MIDI_FIXED_ENDPOINT,
573 .data = & (const struct snd_usb_midi_endpoint_info) {
574 .out_cables = 0x0007,
585 USB_DEVICE(0x0582, 0x0002),
586 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
587 .vendor_name = "EDIROL",
588 .product_name = "UM-4",
589 .ifnum = QUIRK_ANY_INTERFACE,
590 .type = QUIRK_COMPOSITE,
591 .data = (const struct snd_usb_audio_quirk[]) {
594 .type = QUIRK_IGNORE_INTERFACE
598 .type = QUIRK_IGNORE_INTERFACE
602 .type = QUIRK_MIDI_FIXED_ENDPOINT,
603 .data = & (const struct snd_usb_midi_endpoint_info) {
604 .out_cables = 0x000f,
615 USB_DEVICE(0x0582, 0x0003),
616 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
617 .vendor_name = "Roland",
618 .product_name = "SC-8850",
619 .ifnum = QUIRK_ANY_INTERFACE,
620 .type = QUIRK_COMPOSITE,
621 .data = (const struct snd_usb_audio_quirk[]) {
624 .type = QUIRK_IGNORE_INTERFACE
628 .type = QUIRK_IGNORE_INTERFACE
632 .type = QUIRK_MIDI_FIXED_ENDPOINT,
633 .data = & (const struct snd_usb_midi_endpoint_info) {
634 .out_cables = 0x003f,
645 USB_DEVICE(0x0582, 0x0004),
646 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
647 .vendor_name = "Roland",
648 .product_name = "U-8",
649 .ifnum = QUIRK_ANY_INTERFACE,
650 .type = QUIRK_COMPOSITE,
651 .data = (const struct snd_usb_audio_quirk[]) {
654 .type = QUIRK_IGNORE_INTERFACE
658 .type = QUIRK_IGNORE_INTERFACE
662 .type = QUIRK_MIDI_FIXED_ENDPOINT,
663 .data = & (const struct snd_usb_midi_endpoint_info) {
664 .out_cables = 0x0005,
675 /* Has ID 0x0099 when not in "Advanced Driver" mode.
676 * The UM-2EX has only one input, but we cannot detect this. */
677 USB_DEVICE(0x0582, 0x0005),
678 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
679 .vendor_name = "EDIROL",
680 .product_name = "UM-2",
681 .ifnum = QUIRK_ANY_INTERFACE,
682 .type = QUIRK_COMPOSITE,
683 .data = (const struct snd_usb_audio_quirk[]) {
686 .type = QUIRK_IGNORE_INTERFACE
690 .type = QUIRK_IGNORE_INTERFACE
694 .type = QUIRK_MIDI_FIXED_ENDPOINT,
695 .data = & (const struct snd_usb_midi_endpoint_info) {
696 .out_cables = 0x0003,
707 USB_DEVICE(0x0582, 0x0007),
708 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
709 .vendor_name = "Roland",
710 .product_name = "SC-8820",
711 .ifnum = QUIRK_ANY_INTERFACE,
712 .type = QUIRK_COMPOSITE,
713 .data = (const struct snd_usb_audio_quirk[]) {
716 .type = QUIRK_IGNORE_INTERFACE
720 .type = QUIRK_IGNORE_INTERFACE
724 .type = QUIRK_MIDI_FIXED_ENDPOINT,
725 .data = & (const struct snd_usb_midi_endpoint_info) {
726 .out_cables = 0x0013,
737 USB_DEVICE(0x0582, 0x0008),
738 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
739 .vendor_name = "Roland",
740 .product_name = "PC-300",
741 .ifnum = QUIRK_ANY_INTERFACE,
742 .type = QUIRK_COMPOSITE,
743 .data = (const struct snd_usb_audio_quirk[]) {
746 .type = QUIRK_IGNORE_INTERFACE
750 .type = QUIRK_IGNORE_INTERFACE
754 .type = QUIRK_MIDI_FIXED_ENDPOINT,
755 .data = & (const struct snd_usb_midi_endpoint_info) {
756 .out_cables = 0x0001,
767 /* has ID 0x009d when not in "Advanced Driver" mode */
768 USB_DEVICE(0x0582, 0x0009),
769 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
770 .vendor_name = "EDIROL",
771 .product_name = "UM-1",
772 .ifnum = QUIRK_ANY_INTERFACE,
773 .type = QUIRK_COMPOSITE,
774 .data = (const struct snd_usb_audio_quirk[]) {
777 .type = QUIRK_IGNORE_INTERFACE
781 .type = QUIRK_IGNORE_INTERFACE
785 .type = QUIRK_MIDI_FIXED_ENDPOINT,
786 .data = & (const struct snd_usb_midi_endpoint_info) {
787 .out_cables = 0x0001,
798 USB_DEVICE(0x0582, 0x000b),
799 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
800 .vendor_name = "Roland",
801 .product_name = "SK-500",
802 .ifnum = QUIRK_ANY_INTERFACE,
803 .type = QUIRK_COMPOSITE,
804 .data = (const struct snd_usb_audio_quirk[]) {
807 .type = QUIRK_IGNORE_INTERFACE
811 .type = QUIRK_IGNORE_INTERFACE
815 .type = QUIRK_MIDI_FIXED_ENDPOINT,
816 .data = & (const struct snd_usb_midi_endpoint_info) {
817 .out_cables = 0x0013,
828 /* thanks to Emiliano Grilli <emillo@libero.it>
829 * for helping researching this data */
830 USB_DEVICE(0x0582, 0x000c),
831 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
832 .vendor_name = "Roland",
833 .product_name = "SC-D70",
834 .ifnum = QUIRK_ANY_INTERFACE,
835 .type = QUIRK_COMPOSITE,
836 .data = (const struct snd_usb_audio_quirk[]) {
839 .type = QUIRK_AUDIO_STANDARD_INTERFACE
843 .type = QUIRK_AUDIO_STANDARD_INTERFACE
847 .type = QUIRK_MIDI_FIXED_ENDPOINT,
848 .data = & (const struct snd_usb_midi_endpoint_info) {
849 .out_cables = 0x0007,
860 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
861 * If the advanced mode switch at the back of the unit is off, the
862 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
863 * but offers only 16-bit PCM.
864 * In advanced mode, the UA-5 will output S24_3LE samples (two
865 * channels) at the rate indicated on the front switch, including
866 * the 96kHz sample rate.
868 USB_DEVICE(0x0582, 0x0010),
869 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
870 .vendor_name = "EDIROL",
871 .product_name = "UA-5",
872 .ifnum = QUIRK_ANY_INTERFACE,
873 .type = QUIRK_COMPOSITE,
874 .data = (const struct snd_usb_audio_quirk[]) {
877 .type = QUIRK_AUDIO_STANDARD_INTERFACE
881 .type = QUIRK_AUDIO_STANDARD_INTERFACE
890 /* has ID 0x0013 when not in "Advanced Driver" mode */
891 USB_DEVICE(0x0582, 0x0012),
892 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
893 .vendor_name = "Roland",
894 .product_name = "XV-5050",
896 .type = QUIRK_MIDI_FIXED_ENDPOINT,
897 .data = & (const struct snd_usb_midi_endpoint_info) {
898 .out_cables = 0x0001,
904 /* has ID 0x0015 when not in "Advanced Driver" mode */
905 USB_DEVICE(0x0582, 0x0014),
906 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
907 .vendor_name = "EDIROL",
908 .product_name = "UM-880",
910 .type = QUIRK_MIDI_FIXED_ENDPOINT,
911 .data = & (const struct snd_usb_midi_endpoint_info) {
912 .out_cables = 0x01ff,
918 /* has ID 0x0017 when not in "Advanced Driver" mode */
919 USB_DEVICE(0x0582, 0x0016),
920 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
921 .vendor_name = "EDIROL",
922 .product_name = "SD-90",
923 .ifnum = QUIRK_ANY_INTERFACE,
924 .type = QUIRK_COMPOSITE,
925 .data = (const struct snd_usb_audio_quirk[]) {
928 .type = QUIRK_AUDIO_STANDARD_INTERFACE
932 .type = QUIRK_AUDIO_STANDARD_INTERFACE
936 .type = QUIRK_MIDI_FIXED_ENDPOINT,
937 .data = & (const struct snd_usb_midi_endpoint_info) {
938 .out_cables = 0x000f,
949 /* has ID 0x001c when not in "Advanced Driver" mode */
950 USB_DEVICE(0x0582, 0x001b),
951 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
952 .vendor_name = "Roland",
953 .product_name = "MMP-2",
954 .ifnum = QUIRK_ANY_INTERFACE,
955 .type = QUIRK_COMPOSITE,
956 .data = (const struct snd_usb_audio_quirk[]) {
959 .type = QUIRK_IGNORE_INTERFACE
963 .type = QUIRK_IGNORE_INTERFACE
967 .type = QUIRK_MIDI_FIXED_ENDPOINT,
968 .data = & (const struct snd_usb_midi_endpoint_info) {
969 .out_cables = 0x0001,
980 /* has ID 0x001e when not in "Advanced Driver" mode */
981 USB_DEVICE(0x0582, 0x001d),
982 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
983 .vendor_name = "Roland",
984 .product_name = "V-SYNTH",
986 .type = QUIRK_MIDI_FIXED_ENDPOINT,
987 .data = & (const struct snd_usb_midi_endpoint_info) {
988 .out_cables = 0x0001,
994 /* has ID 0x0024 when not in "Advanced Driver" mode */
995 USB_DEVICE(0x0582, 0x0023),
996 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
997 .vendor_name = "EDIROL",
998 .product_name = "UM-550",
1000 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1001 .data = & (const struct snd_usb_midi_endpoint_info) {
1002 .out_cables = 0x003f,
1009 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
1010 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
1013 USB_DEVICE(0x0582, 0x0025),
1014 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1015 .vendor_name = "EDIROL",
1016 .product_name = "UA-20",
1017 .ifnum = QUIRK_ANY_INTERFACE,
1018 .type = QUIRK_COMPOSITE,
1019 .data = (const struct snd_usb_audio_quirk[]) {
1022 .type = QUIRK_IGNORE_INTERFACE
1026 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1027 .data = & (const struct audioformat) {
1028 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
1036 .rates = SNDRV_PCM_RATE_CONTINUOUS,
1043 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1044 .data = & (const struct audioformat) {
1045 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
1053 .rates = SNDRV_PCM_RATE_CONTINUOUS,
1060 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1061 .data = & (const struct snd_usb_midi_endpoint_info) {
1062 .out_cables = 0x0001,
1073 /* has ID 0x0028 when not in "Advanced Driver" mode */
1074 USB_DEVICE(0x0582, 0x0027),
1075 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1076 .vendor_name = "EDIROL",
1077 .product_name = "SD-20",
1079 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1080 .data = & (const struct snd_usb_midi_endpoint_info) {
1081 .out_cables = 0x0003,
1087 /* has ID 0x002a when not in "Advanced Driver" mode */
1088 USB_DEVICE(0x0582, 0x0029),
1089 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1090 .vendor_name = "EDIROL",
1091 .product_name = "SD-80",
1093 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1094 .data = & (const struct snd_usb_midi_endpoint_info) {
1095 .out_cables = 0x000f,
1101 * This quirk is for the "Advanced" modes of the Edirol UA-700.
1102 * If the sample format switch is not in an advanced setting, the
1103 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
1104 * but offers only 16-bit PCM and no MIDI.
1106 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
1107 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1108 .vendor_name = "EDIROL",
1109 .product_name = "UA-700",
1110 .ifnum = QUIRK_ANY_INTERFACE,
1111 .type = QUIRK_COMPOSITE,
1112 .data = (const struct snd_usb_audio_quirk[]) {
1115 .type = QUIRK_AUDIO_EDIROL_UAXX
1119 .type = QUIRK_AUDIO_EDIROL_UAXX
1123 .type = QUIRK_AUDIO_EDIROL_UAXX
1132 /* has ID 0x002e when not in "Advanced Driver" mode */
1133 USB_DEVICE(0x0582, 0x002d),
1134 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1135 .vendor_name = "Roland",
1136 .product_name = "XV-2020",
1138 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1139 .data = & (const struct snd_usb_midi_endpoint_info) {
1140 .out_cables = 0x0001,
1146 /* has ID 0x0030 when not in "Advanced Driver" mode */
1147 USB_DEVICE(0x0582, 0x002f),
1148 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1149 .vendor_name = "Roland",
1150 .product_name = "VariOS",
1152 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1153 .data = & (const struct snd_usb_midi_endpoint_info) {
1154 .out_cables = 0x0007,
1160 /* has ID 0x0034 when not in "Advanced Driver" mode */
1161 USB_DEVICE(0x0582, 0x0033),
1162 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1163 .vendor_name = "EDIROL",
1164 .product_name = "PCR",
1166 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1167 .data = & (const struct snd_usb_midi_endpoint_info) {
1168 .out_cables = 0x0003,
1175 * Has ID 0x0038 when not in "Advanced Driver" mode;
1176 * later revisions use IDs 0x0054 and 0x00a2.
1178 USB_DEVICE(0x0582, 0x0037),
1179 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1180 .vendor_name = "Roland",
1181 .product_name = "Digital Piano",
1183 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1184 .data = & (const struct snd_usb_midi_endpoint_info) {
1185 .out_cables = 0x0001,
1192 * This quirk is for the "Advanced Driver" mode. If off, the GS-10
1193 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1196 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1197 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1198 .vendor_name = "BOSS",
1199 .product_name = "GS-10",
1200 .ifnum = QUIRK_ANY_INTERFACE,
1201 .type = QUIRK_COMPOSITE,
1202 .data = & (const struct snd_usb_audio_quirk[]) {
1205 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1209 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1213 .type = QUIRK_MIDI_STANDARD_INTERFACE
1222 /* has ID 0x0041 when not in "Advanced Driver" mode */
1223 USB_DEVICE(0x0582, 0x0040),
1224 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1225 .vendor_name = "Roland",
1226 .product_name = "GI-20",
1228 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1229 .data = & (const struct snd_usb_midi_endpoint_info) {
1230 .out_cables = 0x0001,
1236 /* has ID 0x0043 when not in "Advanced Driver" mode */
1237 USB_DEVICE(0x0582, 0x0042),
1238 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1239 .vendor_name = "Roland",
1240 .product_name = "RS-70",
1242 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1243 .data = & (const struct snd_usb_midi_endpoint_info) {
1244 .out_cables = 0x0001,
1250 /* has ID 0x0049 when not in "Advanced Driver" mode */
1251 USB_DEVICE(0x0582, 0x0047),
1252 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1253 /* .vendor_name = "EDIROL", */
1254 /* .product_name = "UR-80", */
1255 .ifnum = QUIRK_ANY_INTERFACE,
1256 .type = QUIRK_COMPOSITE,
1257 .data = (const struct snd_usb_audio_quirk[]) {
1258 /* in the 96 kHz modes, only interface 1 is there */
1261 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1265 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1274 /* has ID 0x004a when not in "Advanced Driver" mode */
1275 USB_DEVICE(0x0582, 0x0048),
1276 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1277 /* .vendor_name = "EDIROL", */
1278 /* .product_name = "UR-80", */
1280 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1281 .data = & (const struct snd_usb_midi_endpoint_info) {
1282 .out_cables = 0x0003,
1288 /* has ID 0x004e when not in "Advanced Driver" mode */
1289 USB_DEVICE(0x0582, 0x004c),
1290 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1291 .vendor_name = "EDIROL",
1292 .product_name = "PCR-A",
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 0x004f when not in "Advanced Driver" mode */
1312 USB_DEVICE(0x0582, 0x004d),
1313 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1314 .vendor_name = "EDIROL",
1315 .product_name = "PCR-A",
1317 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1318 .data = & (const struct snd_usb_midi_endpoint_info) {
1319 .out_cables = 0x0003,
1326 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1327 * is standard compliant, but has only 16-bit PCM.
1329 USB_DEVICE(0x0582, 0x0050),
1330 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1331 .vendor_name = "EDIROL",
1332 .product_name = "UA-3FX",
1333 .ifnum = QUIRK_ANY_INTERFACE,
1334 .type = QUIRK_COMPOSITE,
1335 .data = (const struct snd_usb_audio_quirk[]) {
1338 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1342 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1351 USB_DEVICE(0x0582, 0x0052),
1352 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1353 .vendor_name = "EDIROL",
1354 .product_name = "UM-1SX",
1356 .type = QUIRK_MIDI_STANDARD_INTERFACE
1360 USB_DEVICE(0x0582, 0x0060),
1361 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1362 .vendor_name = "Roland",
1363 .product_name = "EXR Series",
1365 .type = QUIRK_MIDI_STANDARD_INTERFACE
1369 /* has ID 0x0066 when not in "Advanced Driver" mode */
1370 USB_DEVICE(0x0582, 0x0064),
1371 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1372 /* .vendor_name = "EDIROL", */
1373 /* .product_name = "PCR-1", */
1374 .ifnum = QUIRK_ANY_INTERFACE,
1375 .type = QUIRK_COMPOSITE,
1376 .data = (const struct snd_usb_audio_quirk[]) {
1379 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1383 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1392 /* has ID 0x0067 when not in "Advanced Driver" mode */
1393 USB_DEVICE(0x0582, 0x0065),
1394 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1395 /* .vendor_name = "EDIROL", */
1396 /* .product_name = "PCR-1", */
1398 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1399 .data = & (const struct snd_usb_midi_endpoint_info) {
1400 .out_cables = 0x0001,
1406 /* has ID 0x006e when not in "Advanced Driver" mode */
1407 USB_DEVICE(0x0582, 0x006d),
1408 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1409 .vendor_name = "Roland",
1410 .product_name = "FANTOM-X",
1412 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1413 .data = & (const struct snd_usb_midi_endpoint_info) {
1414 .out_cables = 0x0001,
1420 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1421 * If the switch is not in an advanced setting, the UA-25 has
1422 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1423 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1425 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1426 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1427 .vendor_name = "EDIROL",
1428 .product_name = "UA-25",
1429 .ifnum = QUIRK_ANY_INTERFACE,
1430 .type = QUIRK_COMPOSITE,
1431 .data = (const struct snd_usb_audio_quirk[]) {
1434 .type = QUIRK_AUDIO_EDIROL_UAXX
1438 .type = QUIRK_AUDIO_EDIROL_UAXX
1442 .type = QUIRK_AUDIO_EDIROL_UAXX
1451 /* has ID 0x0076 when not in "Advanced Driver" mode */
1452 USB_DEVICE(0x0582, 0x0075),
1453 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1454 .vendor_name = "BOSS",
1455 .product_name = "DR-880",
1457 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1458 .data = & (const struct snd_usb_midi_endpoint_info) {
1459 .out_cables = 0x0001,
1465 /* has ID 0x007b when not in "Advanced Driver" mode */
1466 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1467 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1468 .vendor_name = "Roland",
1469 /* "RD" or "RD-700SX"? */
1471 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1472 .data = & (const struct snd_usb_midi_endpoint_info) {
1473 .out_cables = 0x0003,
1479 /* has ID 0x0081 when not in "Advanced Driver" mode */
1480 USB_DEVICE(0x0582, 0x0080),
1481 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1482 .vendor_name = "Roland",
1483 .product_name = "G-70",
1485 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1486 .data = & (const struct snd_usb_midi_endpoint_info) {
1487 .out_cables = 0x0001,
1493 /* has ID 0x008c when not in "Advanced Driver" mode */
1494 USB_DEVICE(0x0582, 0x008b),
1495 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1496 .vendor_name = "EDIROL",
1497 .product_name = "PC-50",
1499 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1500 .data = & (const struct snd_usb_midi_endpoint_info) {
1501 .out_cables = 0x0001,
1508 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1509 * is standard compliant, but has only 16-bit PCM and no MIDI.
1511 USB_DEVICE(0x0582, 0x00a3),
1512 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1513 .vendor_name = "EDIROL",
1514 .product_name = "UA-4FX",
1515 .ifnum = QUIRK_ANY_INTERFACE,
1516 .type = QUIRK_COMPOSITE,
1517 .data = (const struct snd_usb_audio_quirk[]) {
1520 .type = QUIRK_AUDIO_EDIROL_UAXX
1524 .type = QUIRK_AUDIO_EDIROL_UAXX
1528 .type = QUIRK_AUDIO_EDIROL_UAXX
1538 USB_DEVICE(0x0582, 0x00c4),
1539 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1540 .ifnum = QUIRK_ANY_INTERFACE,
1541 .type = QUIRK_COMPOSITE,
1542 .data = (const struct snd_usb_audio_quirk[]) {
1545 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1549 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1553 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1554 .data = & (const struct snd_usb_midi_endpoint_info) {
1555 .out_cables = 0x0001,
1566 /* Advanced modes of the Edirol UA-25EX.
1567 * For the standard mode, UA-25EX has ID 0582:00e7, which
1568 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1570 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1571 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1572 .vendor_name = "EDIROL",
1573 .product_name = "UA-25EX",
1574 .ifnum = QUIRK_ANY_INTERFACE,
1575 .type = QUIRK_COMPOSITE,
1576 .data = (const struct snd_usb_audio_quirk[]) {
1579 .type = QUIRK_AUDIO_EDIROL_UAXX
1583 .type = QUIRK_AUDIO_EDIROL_UAXX
1587 .type = QUIRK_AUDIO_EDIROL_UAXX
1597 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1598 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1600 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1601 .data = & (const struct snd_usb_midi_endpoint_info) {
1602 .out_cables = 0x0007,
1609 USB_DEVICE(0x0582, 0x0113),
1610 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1611 .ifnum = QUIRK_ANY_INTERFACE,
1612 .type = QUIRK_COMPOSITE,
1613 .data = (const struct snd_usb_audio_quirk[]) {
1616 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1620 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1624 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1625 .data = & (const struct snd_usb_midi_endpoint_info) {
1626 .out_cables = 0x0001,
1637 /* only 44.1 kHz works at the moment */
1638 USB_DEVICE(0x0582, 0x0120),
1639 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1640 /* .vendor_name = "Roland", */
1641 /* .product_name = "OCTO-CAPTURE", */
1642 .ifnum = QUIRK_ANY_INTERFACE,
1643 .type = QUIRK_COMPOSITE,
1644 .data = (const struct snd_usb_audio_quirk[]) {
1647 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1648 .data = & (const struct audioformat) {
1649 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1656 .rates = SNDRV_PCM_RATE_44100,
1660 .rate_table = (unsigned int[]) { 44100 }
1665 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1666 .data = & (const struct audioformat) {
1667 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1674 .rates = SNDRV_PCM_RATE_44100,
1678 .rate_table = (unsigned int[]) { 44100 }
1683 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1684 .data = & (const struct snd_usb_midi_endpoint_info) {
1685 .out_cables = 0x0001,
1691 .type = QUIRK_IGNORE_INTERFACE
1695 .type = QUIRK_IGNORE_INTERFACE
1704 /* only 44.1 kHz works at the moment */
1705 USB_DEVICE(0x0582, 0x012f),
1706 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1707 /* .vendor_name = "Roland", */
1708 /* .product_name = "QUAD-CAPTURE", */
1709 .ifnum = QUIRK_ANY_INTERFACE,
1710 .type = QUIRK_COMPOSITE,
1711 .data = (const struct snd_usb_audio_quirk[]) {
1714 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1715 .data = & (const struct audioformat) {
1716 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1723 .rates = SNDRV_PCM_RATE_44100,
1727 .rate_table = (unsigned int[]) { 44100 }
1732 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1733 .data = & (const struct audioformat) {
1734 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1741 .rates = SNDRV_PCM_RATE_44100,
1745 .rate_table = (unsigned int[]) { 44100 }
1750 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1751 .data = & (const struct snd_usb_midi_endpoint_info) {
1752 .out_cables = 0x0001,
1758 .type = QUIRK_IGNORE_INTERFACE
1762 .type = QUIRK_IGNORE_INTERFACE
1771 USB_DEVICE(0x0582, 0x0159),
1772 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1773 /* .vendor_name = "Roland", */
1774 /* .product_name = "UA-22", */
1775 .ifnum = QUIRK_ANY_INTERFACE,
1776 .type = QUIRK_COMPOSITE,
1777 .data = (const struct snd_usb_audio_quirk[]) {
1780 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1784 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1788 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1789 .data = & (const struct snd_usb_midi_endpoint_info) {
1790 .out_cables = 0x0001,
1800 /* this catches most recent vendor-specific Roland devices */
1802 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1803 USB_DEVICE_ID_MATCH_INT_CLASS,
1805 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1806 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1807 .ifnum = QUIRK_ANY_INTERFACE,
1808 .type = QUIRK_AUTODETECT
1812 /* Guillemot devices */
1815 * This is for the "Windows Edition" where the external MIDI ports are
1816 * the only MIDI ports; the control data is reported through HID
1817 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard
1818 * compliant USB MIDI ports for external MIDI and controls.
1820 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1821 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1822 .vendor_name = "Hercules",
1823 .product_name = "DJ Console (WE)",
1825 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1826 .data = & (const struct snd_usb_midi_endpoint_info) {
1827 .out_cables = 0x0001,
1833 /* Midiman/M-Audio devices */
1835 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1836 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1837 .vendor_name = "M-Audio",
1838 .product_name = "MidiSport 2x2",
1839 .ifnum = QUIRK_ANY_INTERFACE,
1840 .type = QUIRK_MIDI_MIDIMAN,
1841 .data = & (const struct snd_usb_midi_endpoint_info) {
1842 .out_cables = 0x0003,
1848 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1849 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1850 .vendor_name = "M-Audio",
1851 .product_name = "MidiSport 1x1",
1852 .ifnum = QUIRK_ANY_INTERFACE,
1853 .type = QUIRK_MIDI_MIDIMAN,
1854 .data = & (const struct snd_usb_midi_endpoint_info) {
1855 .out_cables = 0x0001,
1861 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1862 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1863 .vendor_name = "M-Audio",
1864 .product_name = "Keystation",
1865 .ifnum = QUIRK_ANY_INTERFACE,
1866 .type = QUIRK_MIDI_MIDIMAN,
1867 .data = & (const struct snd_usb_midi_endpoint_info) {
1868 .out_cables = 0x0001,
1874 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1875 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1876 .vendor_name = "M-Audio",
1877 .product_name = "MidiSport 4x4",
1878 .ifnum = QUIRK_ANY_INTERFACE,
1879 .type = QUIRK_MIDI_MIDIMAN,
1880 .data = & (const struct snd_usb_midi_endpoint_info) {
1881 .out_cables = 0x000f,
1888 * For hardware revision 1.05; in the later revisions (1.10 and
1889 * 1.21), 0x1031 is the ID for the device without firmware.
1890 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1892 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1893 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1894 .vendor_name = "M-Audio",
1895 .product_name = "MidiSport 8x8",
1896 .ifnum = QUIRK_ANY_INTERFACE,
1897 .type = QUIRK_MIDI_MIDIMAN,
1898 .data = & (const struct snd_usb_midi_endpoint_info) {
1899 .out_cables = 0x01ff,
1905 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1906 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1907 .vendor_name = "M-Audio",
1908 .product_name = "MidiSport 8x8",
1909 .ifnum = QUIRK_ANY_INTERFACE,
1910 .type = QUIRK_MIDI_MIDIMAN,
1911 .data = & (const struct snd_usb_midi_endpoint_info) {
1912 .out_cables = 0x01ff,
1918 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1919 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1920 .vendor_name = "M-Audio",
1921 .product_name = "MidiSport 2x4",
1922 .ifnum = QUIRK_ANY_INTERFACE,
1923 .type = QUIRK_MIDI_MIDIMAN,
1924 .data = & (const struct snd_usb_midi_endpoint_info) {
1925 .out_cables = 0x000f,
1931 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1932 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1933 .vendor_name = "M-Audio",
1934 .product_name = "Quattro",
1935 .ifnum = QUIRK_ANY_INTERFACE,
1936 .type = QUIRK_COMPOSITE,
1937 .data = & (const struct snd_usb_audio_quirk[]) {
1939 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1940 * and share endpoints with the other interfaces.
1941 * Ignore them. The other interfaces can do 24 bits,
1942 * but captured samples are big-endian (see usbaudio.c).
1946 .type = QUIRK_IGNORE_INTERFACE
1950 .type = QUIRK_IGNORE_INTERFACE
1954 .type = QUIRK_IGNORE_INTERFACE
1958 .type = QUIRK_IGNORE_INTERFACE
1962 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1966 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1970 .type = QUIRK_IGNORE_INTERFACE
1974 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1978 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1982 .type = QUIRK_MIDI_MIDIMAN,
1983 .data = & (const struct snd_usb_midi_endpoint_info) {
1984 .out_cables = 0x0001,
1995 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1996 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1997 .vendor_name = "M-Audio",
1998 .product_name = "AudioPhile",
2000 .type = QUIRK_MIDI_MIDIMAN,
2001 .data = & (const struct snd_usb_midi_endpoint_info) {
2002 .out_cables = 0x0001,
2008 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
2009 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2010 .vendor_name = "M-Audio",
2011 .product_name = "Ozone",
2013 .type = QUIRK_MIDI_MIDIMAN,
2014 .data = & (const struct snd_usb_midi_endpoint_info) {
2015 .out_cables = 0x0001,
2021 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
2022 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2023 .vendor_name = "M-Audio",
2024 .product_name = "OmniStudio",
2025 .ifnum = QUIRK_ANY_INTERFACE,
2026 .type = QUIRK_COMPOSITE,
2027 .data = & (const struct snd_usb_audio_quirk[]) {
2030 .type = QUIRK_IGNORE_INTERFACE
2034 .type = QUIRK_IGNORE_INTERFACE
2038 .type = QUIRK_IGNORE_INTERFACE
2042 .type = QUIRK_IGNORE_INTERFACE
2046 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2050 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2054 .type = QUIRK_IGNORE_INTERFACE
2058 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2062 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2066 .type = QUIRK_MIDI_MIDIMAN,
2067 .data = & (const struct snd_usb_midi_endpoint_info) {
2068 .out_cables = 0x0001,
2079 USB_DEVICE(0x0763, 0x2019),
2080 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2081 /* .vendor_name = "M-Audio", */
2082 /* .product_name = "Ozone Academic", */
2083 .ifnum = QUIRK_ANY_INTERFACE,
2084 .type = QUIRK_COMPOSITE,
2085 .data = & (const struct snd_usb_audio_quirk[]) {
2088 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2092 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2096 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2100 .type = QUIRK_MIDI_MIDIMAN,
2101 .data = & (const struct snd_usb_midi_endpoint_info) {
2102 .out_cables = 0x0001,
2113 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2114 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2115 /* .vendor_name = "M-Audio", */
2116 /* .product_name = "Fast Track C400", */
2117 .ifnum = QUIRK_ANY_INTERFACE,
2118 .type = QUIRK_COMPOSITE,
2119 .data = &(const struct snd_usb_audio_quirk[]) {
2122 .type = QUIRK_AUDIO_STANDARD_MIXER,
2127 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2128 .data = &(const struct audioformat) {
2129 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2134 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2137 .rates = SNDRV_PCM_RATE_44100 |
2138 SNDRV_PCM_RATE_48000 |
2139 SNDRV_PCM_RATE_88200 |
2140 SNDRV_PCM_RATE_96000,
2144 .rate_table = (unsigned int[]) {
2145 44100, 48000, 88200, 96000
2153 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2154 .data = &(const struct audioformat) {
2155 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2160 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2163 .rates = SNDRV_PCM_RATE_44100 |
2164 SNDRV_PCM_RATE_48000 |
2165 SNDRV_PCM_RATE_88200 |
2166 SNDRV_PCM_RATE_96000,
2170 .rate_table = (unsigned int[]) {
2171 44100, 48000, 88200, 96000
2178 .ifnum = -1 /* Interface = 4 */
2184 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2185 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2186 /* .vendor_name = "M-Audio", */
2187 /* .product_name = "Fast Track C600", */
2188 .ifnum = QUIRK_ANY_INTERFACE,
2189 .type = QUIRK_COMPOSITE,
2190 .data = &(const struct snd_usb_audio_quirk[]) {
2193 .type = QUIRK_AUDIO_STANDARD_MIXER,
2198 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2199 .data = &(const struct audioformat) {
2200 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2205 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2208 .rates = SNDRV_PCM_RATE_44100 |
2209 SNDRV_PCM_RATE_48000 |
2210 SNDRV_PCM_RATE_88200 |
2211 SNDRV_PCM_RATE_96000,
2215 .rate_table = (unsigned int[]) {
2216 44100, 48000, 88200, 96000
2224 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2225 .data = &(const struct audioformat) {
2226 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2231 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2234 .rates = SNDRV_PCM_RATE_44100 |
2235 SNDRV_PCM_RATE_48000 |
2236 SNDRV_PCM_RATE_88200 |
2237 SNDRV_PCM_RATE_96000,
2241 .rate_table = (unsigned int[]) {
2242 44100, 48000, 88200, 96000
2249 .ifnum = -1 /* Interface = 4 */
2255 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2256 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2257 /* .vendor_name = "M-Audio", */
2258 /* .product_name = "Fast Track Ultra", */
2259 .ifnum = QUIRK_ANY_INTERFACE,
2260 .type = QUIRK_COMPOSITE,
2261 .data = & (const struct snd_usb_audio_quirk[]) {
2264 .type = QUIRK_AUDIO_STANDARD_MIXER,
2268 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2269 .data = & (const struct audioformat) {
2270 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2275 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2278 .rates = SNDRV_PCM_RATE_44100 |
2279 SNDRV_PCM_RATE_48000 |
2280 SNDRV_PCM_RATE_88200 |
2281 SNDRV_PCM_RATE_96000,
2285 .rate_table = (unsigned int[]) {
2286 44100, 48000, 88200, 96000
2292 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2293 .data = & (const struct audioformat) {
2294 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2299 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2302 .rates = SNDRV_PCM_RATE_44100 |
2303 SNDRV_PCM_RATE_48000 |
2304 SNDRV_PCM_RATE_88200 |
2305 SNDRV_PCM_RATE_96000,
2309 .rate_table = (unsigned int[]) {
2310 44100, 48000, 88200, 96000
2314 /* interface 3 (MIDI) is standard compliant */
2322 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2323 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2324 /* .vendor_name = "M-Audio", */
2325 /* .product_name = "Fast Track Ultra 8R", */
2326 .ifnum = QUIRK_ANY_INTERFACE,
2327 .type = QUIRK_COMPOSITE,
2328 .data = & (const struct snd_usb_audio_quirk[]) {
2331 .type = QUIRK_AUDIO_STANDARD_MIXER,
2335 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2336 .data = & (const struct audioformat) {
2337 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2342 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2345 .rates = SNDRV_PCM_RATE_44100 |
2346 SNDRV_PCM_RATE_48000 |
2347 SNDRV_PCM_RATE_88200 |
2348 SNDRV_PCM_RATE_96000,
2352 .rate_table = (unsigned int[]) {
2353 44100, 48000, 88200, 96000
2359 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2360 .data = & (const struct audioformat) {
2361 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2366 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2369 .rates = SNDRV_PCM_RATE_44100 |
2370 SNDRV_PCM_RATE_48000 |
2371 SNDRV_PCM_RATE_88200 |
2372 SNDRV_PCM_RATE_96000,
2376 .rate_table = (unsigned int[]) {
2377 44100, 48000, 88200, 96000
2381 /* interface 3 (MIDI) is standard compliant */
2391 USB_DEVICE(0x07cf, 0x6801),
2392 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2393 .vendor_name = "Casio",
2394 .product_name = "PL-40R",
2396 .type = QUIRK_MIDI_YAMAHA
2400 /* this ID is used by several devices without a product ID */
2401 USB_DEVICE(0x07cf, 0x6802),
2402 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2403 .vendor_name = "Casio",
2404 .product_name = "Keyboard",
2406 .type = QUIRK_MIDI_YAMAHA
2410 /* Mark of the Unicorn devices */
2412 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2413 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2414 USB_DEVICE_ID_MATCH_PRODUCT |
2415 USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2417 .idProduct = 0x0001,
2418 .bDeviceSubClass = 2,
2419 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2420 .vendor_name = "MOTU",
2421 .product_name = "Fastlane",
2422 .ifnum = QUIRK_ANY_INTERFACE,
2423 .type = QUIRK_COMPOSITE,
2424 .data = & (const struct snd_usb_audio_quirk[]) {
2427 .type = QUIRK_MIDI_RAW_BYTES
2431 .type = QUIRK_IGNORE_INTERFACE
2440 /* Emagic devices */
2442 USB_DEVICE(0x086a, 0x0001),
2443 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2444 .vendor_name = "Emagic",
2445 /* .product_name = "Unitor8", */
2447 .type = QUIRK_MIDI_EMAGIC,
2448 .data = & (const struct snd_usb_midi_endpoint_info) {
2449 .out_cables = 0x80ff,
2455 USB_DEVICE(0x086a, 0x0002),
2456 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2457 .vendor_name = "Emagic",
2458 /* .product_name = "AMT8", */
2460 .type = QUIRK_MIDI_EMAGIC,
2461 .data = & (const struct snd_usb_midi_endpoint_info) {
2462 .out_cables = 0x80ff,
2468 USB_DEVICE(0x086a, 0x0003),
2469 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2470 .vendor_name = "Emagic",
2471 /* .product_name = "MT4", */
2473 .type = QUIRK_MIDI_EMAGIC,
2474 .data = & (const struct snd_usb_midi_endpoint_info) {
2475 .out_cables = 0x800f,
2483 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2484 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2485 .vendor_name = "KORG, Inc.",
2486 /* .product_name = "PANDORA PX5D", */
2488 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2493 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2494 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2495 .vendor_name = "KORG, Inc.",
2496 /* .product_name = "ToneLab ST", */
2498 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2503 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0204),
2504 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2505 .vendor_name = "KORG, Inc.",
2506 /* .product_name = "ToneLab EX", */
2508 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2514 USB_DEVICE(0x09e8, 0x0062),
2515 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2516 .vendor_name = "AKAI",
2517 .product_name = "MPD16",
2519 .type = QUIRK_MIDI_AKAI,
2524 /* Akai MPC Element */
2525 USB_DEVICE(0x09e8, 0x0021),
2526 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2527 .ifnum = QUIRK_ANY_INTERFACE,
2528 .type = QUIRK_COMPOSITE,
2529 .data = & (const struct snd_usb_audio_quirk[]) {
2532 .type = QUIRK_IGNORE_INTERFACE
2536 .type = QUIRK_MIDI_STANDARD_INTERFACE
2545 /* Steinberg devices */
2548 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2549 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2550 .ifnum = QUIRK_ANY_INTERFACE,
2551 .type = QUIRK_COMPOSITE,
2552 .data = & (const struct snd_usb_audio_quirk[]) {
2555 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2559 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2563 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2567 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2568 .data = &(const struct snd_usb_midi_endpoint_info) {
2569 .out_cables = 0x0001,
2581 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2582 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2583 .ifnum = QUIRK_ANY_INTERFACE,
2584 .type = QUIRK_COMPOSITE,
2585 .data = & (const struct snd_usb_audio_quirk[]) {
2588 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2592 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2596 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2600 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2601 .data = &(const struct snd_usb_midi_endpoint_info) {
2602 .out_cables = 0x0001,
2613 /* TerraTec devices */
2615 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2616 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2617 .vendor_name = "TerraTec",
2618 .product_name = "PHASE 26",
2620 .type = QUIRK_MIDI_STANDARD_INTERFACE
2624 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2625 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2626 .vendor_name = "TerraTec",
2627 .product_name = "PHASE 26",
2629 .type = QUIRK_MIDI_STANDARD_INTERFACE
2633 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2634 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2635 .vendor_name = "TerraTec",
2636 .product_name = "PHASE 26",
2638 .type = QUIRK_MIDI_STANDARD_INTERFACE
2642 USB_DEVICE(0x0ccd, 0x0028),
2643 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2644 .vendor_name = "TerraTec",
2645 .product_name = "Aureon5.1MkII",
2646 .ifnum = QUIRK_NO_INTERFACE
2650 USB_DEVICE(0x0ccd, 0x0035),
2651 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2652 .vendor_name = "Miditech",
2653 .product_name = "Play'n Roll",
2655 .type = QUIRK_MIDI_CME
2659 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2661 USB_DEVICE(0x103d, 0x0100),
2662 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2663 .vendor_name = "Stanton",
2664 .product_name = "ScratchAmp",
2665 .ifnum = QUIRK_NO_INTERFACE
2669 USB_DEVICE(0x103d, 0x0101),
2670 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2671 .vendor_name = "Stanton",
2672 .product_name = "ScratchAmp",
2673 .ifnum = QUIRK_NO_INTERFACE
2677 /* Novation EMS devices */
2679 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2680 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2681 .vendor_name = "Novation",
2682 .product_name = "ReMOTE Audio/XStation",
2684 .type = QUIRK_MIDI_NOVATION
2688 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2689 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2690 .vendor_name = "Novation",
2691 .product_name = "Speedio",
2693 .type = QUIRK_MIDI_NOVATION
2697 USB_DEVICE(0x1235, 0x000a),
2698 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2699 /* .vendor_name = "Novation", */
2700 /* .product_name = "Nocturn", */
2702 .type = QUIRK_MIDI_RAW_BYTES
2706 USB_DEVICE(0x1235, 0x000e),
2707 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2708 /* .vendor_name = "Novation", */
2709 /* .product_name = "Launchpad", */
2711 .type = QUIRK_MIDI_RAW_BYTES
2715 USB_DEVICE(0x1235, 0x0010),
2716 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2717 .vendor_name = "Focusrite",
2718 .product_name = "Saffire 6 USB",
2719 .ifnum = QUIRK_ANY_INTERFACE,
2720 .type = QUIRK_COMPOSITE,
2721 .data = (const struct snd_usb_audio_quirk[]) {
2724 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2725 .data = &(const struct audioformat) {
2726 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2731 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2733 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2734 .rates = SNDRV_PCM_RATE_44100 |
2735 SNDRV_PCM_RATE_48000,
2739 .rate_table = (unsigned int[]) {
2746 .type = QUIRK_MIDI_RAW_BYTES
2755 USB_DEVICE(0x1235, 0x0018),
2756 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2757 .vendor_name = "Novation",
2758 .product_name = "Twitch",
2759 .ifnum = QUIRK_ANY_INTERFACE,
2760 .type = QUIRK_COMPOSITE,
2761 .data = (const struct snd_usb_audio_quirk[]) {
2764 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2765 .data = & (const struct audioformat) {
2766 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2771 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2773 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2774 .rates = SNDRV_PCM_RATE_44100 |
2775 SNDRV_PCM_RATE_48000,
2779 .rate_table = (unsigned int[]) {
2786 .type = QUIRK_MIDI_RAW_BYTES
2795 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2796 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2797 .vendor_name = "Novation",
2798 .product_name = "ReMOTE25",
2800 .type = QUIRK_MIDI_NOVATION
2804 /* Access Music devices */
2806 /* VirusTI Desktop */
2807 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2808 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2809 .ifnum = QUIRK_ANY_INTERFACE,
2810 .type = QUIRK_COMPOSITE,
2811 .data = &(const struct snd_usb_audio_quirk[]) {
2814 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2815 .data = &(const struct snd_usb_midi_endpoint_info) {
2816 .out_cables = 0x0003,
2822 .type = QUIRK_IGNORE_INTERFACE
2833 /* aka. Serato Scratch Live DJ Box */
2834 USB_DEVICE(0x13e5, 0x0001),
2835 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2836 .vendor_name = "Rane",
2837 .product_name = "SL-1",
2838 .ifnum = QUIRK_NO_INTERFACE
2842 /* Native Instruments MK2 series */
2844 /* Komplete Audio 6 */
2845 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2847 .idProduct = 0x1000,
2850 /* Traktor Audio 6 */
2851 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2853 .idProduct = 0x1010,
2856 /* Traktor Audio 10 */
2857 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2859 .idProduct = 0x1020,
2862 /* QinHeng devices */
2864 USB_DEVICE(0x1a86, 0x752d),
2865 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2866 .vendor_name = "QinHeng",
2867 .product_name = "CH345",
2869 .type = QUIRK_MIDI_CH345
2873 /* KeithMcMillen Stringport */
2875 USB_DEVICE(0x1f38, 0x0001),
2876 .bInterfaceClass = USB_CLASS_AUDIO,
2879 /* Miditech devices */
2881 USB_DEVICE(0x4752, 0x0011),
2882 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2883 .vendor_name = "Miditech",
2884 .product_name = "Midistart-2",
2886 .type = QUIRK_MIDI_CME
2890 /* Central Music devices */
2892 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2893 USB_DEVICE(0x7104, 0x2202),
2894 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2896 .type = QUIRK_MIDI_CME
2901 * Auvitek au0828 devices with audio interface.
2902 * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
2903 * Please notice that some drivers are DVB only, and don't need to be
2904 * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2907 #define AU0828_DEVICE(vid, pid, vname, pname) { \
2910 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
2911 USB_DEVICE_ID_MATCH_INT_CLASS | \
2912 USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
2913 .bInterfaceClass = USB_CLASS_AUDIO, \
2914 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, \
2915 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2916 .vendor_name = vname, \
2917 .product_name = pname, \
2918 .ifnum = QUIRK_ANY_INTERFACE, \
2919 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
2923 AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2924 AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2925 AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
2926 AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
2927 AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
2928 AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
2929 AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
2930 AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
2931 AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
2932 AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
2933 AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
2934 AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
2935 AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
2936 AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
2937 AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
2938 AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
2939 AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
2941 /* Syntek STK1160 */
2943 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2944 USB_DEVICE_ID_MATCH_INT_CLASS |
2945 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2947 .idProduct = 0x0408,
2948 .bInterfaceClass = USB_CLASS_AUDIO,
2949 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2950 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2951 .vendor_name = "Syntek",
2952 .product_name = "STK1160",
2953 .ifnum = QUIRK_ANY_INTERFACE,
2954 .type = QUIRK_AUDIO_ALIGN_TRANSFER
2958 /* Digidesign Mbox */
2960 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2961 USB_DEVICE(0x0dba, 0x1000),
2962 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2963 .vendor_name = "Digidesign",
2964 .product_name = "MBox",
2965 .ifnum = QUIRK_ANY_INTERFACE,
2966 .type = QUIRK_COMPOSITE,
2967 .data = (const struct snd_usb_audio_quirk[]){
2970 .type = QUIRK_AUDIO_STANDARD_MIXER,
2974 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2975 .data = &(const struct audioformat) {
2976 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2983 .ep_attr = USB_ENDPOINT_XFER_ISOC |
2984 USB_ENDPOINT_SYNC_SYNC,
2985 .maxpacksize = 0x130,
2986 .rates = SNDRV_PCM_RATE_48000,
2990 .rate_table = (unsigned int[]) {
2997 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2998 .data = &(const struct audioformat) {
2999 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3006 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3007 USB_ENDPOINT_SYNC_ASYNC,
3008 .maxpacksize = 0x130,
3009 .rates = SNDRV_PCM_RATE_48000,
3013 .rate_table = (unsigned int[]) {
3025 /* DIGIDESIGN MBOX 2 */
3027 USB_DEVICE(0x0dba, 0x3000),
3028 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3029 .vendor_name = "Digidesign",
3030 .product_name = "Mbox 2",
3031 .ifnum = QUIRK_ANY_INTERFACE,
3032 .type = QUIRK_COMPOSITE,
3033 .data = (const struct snd_usb_audio_quirk[]) {
3036 .type = QUIRK_IGNORE_INTERFACE
3040 .type = QUIRK_IGNORE_INTERFACE
3044 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3045 .data = &(const struct audioformat) {
3046 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3053 .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
3054 .rates = SNDRV_PCM_RATE_48000,
3058 .rate_table = (unsigned int[]) {
3065 .type = QUIRK_IGNORE_INTERFACE
3069 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3070 .data = &(const struct audioformat) {
3071 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3076 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3078 .ep_attr = USB_ENDPOINT_SYNC_SYNC,
3079 .rates = SNDRV_PCM_RATE_48000,
3083 .rate_table = (unsigned int[]) {
3090 .type = QUIRK_IGNORE_INTERFACE
3094 .type = QUIRK_MIDI_MIDIMAN,
3095 .data = &(const struct snd_usb_midi_endpoint_info) {
3097 .out_cables = 0x0001,
3099 .in_interval = 0x01,
3110 /* Tascam US122 MKII - playback-only support */
3111 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
3113 .idProduct = 0x8021,
3114 .bInterfaceClass = USB_CLASS_AUDIO,
3115 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3116 .vendor_name = "TASCAM",
3117 .product_name = "US122 MKII",
3118 .ifnum = QUIRK_ANY_INTERFACE,
3119 .type = QUIRK_COMPOSITE,
3120 .data = (const struct snd_usb_audio_quirk[]) {
3123 .type = QUIRK_IGNORE_INTERFACE
3127 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3128 .data = &(const struct audioformat) {
3129 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3134 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3136 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3137 .rates = SNDRV_PCM_RATE_44100 |
3138 SNDRV_PCM_RATE_48000 |
3139 SNDRV_PCM_RATE_88200 |
3140 SNDRV_PCM_RATE_96000,
3144 .rate_table = (unsigned int[]) {
3145 44100, 48000, 88200, 96000
3156 /* Microsoft XboxLive Headset/Xbox Communicator */
3158 USB_DEVICE(0x045e, 0x0283),
3159 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3160 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3161 .vendor_name = "Microsoft",
3162 .product_name = "XboxLive Headset/Xbox Communicator",
3163 .ifnum = QUIRK_ANY_INTERFACE,
3164 .type = QUIRK_COMPOSITE,
3165 .data = &(const struct snd_usb_audio_quirk[]) {
3169 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3170 .data = &(const struct audioformat) {
3171 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3179 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3187 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3188 .data = &(const struct audioformat) {
3189 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3197 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3211 USB_DEVICE(0x200c, 0x100b),
3212 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3213 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3214 .ifnum = QUIRK_ANY_INTERFACE,
3215 .type = QUIRK_COMPOSITE,
3216 .data = &(const struct snd_usb_audio_quirk[]) {
3219 .type = QUIRK_AUDIO_STANDARD_MIXER,
3223 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3224 .data = &(const struct audioformat) {
3225 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3230 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3232 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3233 .rates = SNDRV_PCM_RATE_44100 |
3234 SNDRV_PCM_RATE_48000,
3238 .rate_table = (unsigned int[]) {
3252 * ZOOM R16/24 in audio interface mode.
3253 * Playback requires an extra four byte LE length indicator
3254 * at the start of each isochronous packet. This quirk is
3255 * enabled in create_standard_audio_quirk().
3257 USB_DEVICE(0x1686, 0x00dd),
3258 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3259 .ifnum = QUIRK_ANY_INTERFACE,
3260 .type = QUIRK_COMPOSITE,
3261 .data = (const struct snd_usb_audio_quirk[]) {
3265 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3270 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3275 .type = QUIRK_MIDI_STANDARD_INTERFACE
3286 * Some USB MIDI devices don't have an audio control interface,
3287 * so we have to grab MIDI streaming interfaces here.
3289 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3290 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3291 .bInterfaceClass = USB_CLASS_AUDIO,
3292 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3293 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3294 .ifnum = QUIRK_ANY_INTERFACE,
3295 .type = QUIRK_MIDI_STANDARD_INTERFACE
3301 * The original product_name is "USB Sound Device", however this name
3302 * is also used by the CM106 based cards, so make it unique.
3304 USB_DEVICE(0x0d8c, 0x0103),
3305 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3306 .product_name = "Audio Advantage MicroII",
3307 .ifnum = QUIRK_NO_INTERFACE
3311 /* disabled due to regression for other devices;
3312 * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3317 * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3318 * ID, but it looks like the product ID actually is only for Nura.
3319 * The capture interface does not work at all (even on Windows),
3320 * and only the 48 kHz sample rate works for the playback interface.
3322 USB_DEVICE(0x0a12, 0x1243),
3323 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3324 .ifnum = QUIRK_ANY_INTERFACE,
3325 .type = QUIRK_COMPOSITE,
3326 .data = (const struct snd_usb_audio_quirk[]) {
3329 .type = QUIRK_AUDIO_STANDARD_MIXER,
3334 .type = QUIRK_IGNORE_INTERFACE,
3339 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3340 .data = &(const struct audioformat) {
3341 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3346 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3347 UAC_EP_CS_ATTR_SAMPLE_RATE,
3349 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3350 .rates = SNDRV_PCM_RATE_48000,
3354 .rate_table = (unsigned int[]) {
3365 #endif /* disabled */
3369 * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3370 * even though it advertises more. The capture interface doesn't work
3373 USB_DEVICE(0x19b5, 0x0021),
3374 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3375 .ifnum = QUIRK_ANY_INTERFACE,
3376 .type = QUIRK_COMPOSITE,
3377 .data = (const struct snd_usb_audio_quirk[]) {
3380 .type = QUIRK_AUDIO_STANDARD_MIXER,
3385 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3386 .data = &(const struct audioformat) {
3387 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3392 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3393 UAC_EP_CS_ATTR_SAMPLE_RATE,
3395 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3396 .rates = SNDRV_PCM_RATE_48000,
3400 .rate_table = (unsigned int[]) {
3411 /* Dell WD15 Dock */
3413 USB_DEVICE(0x0bda, 0x4014),
3414 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3415 .vendor_name = "Dell",
3416 .product_name = "WD15 Dock",
3417 .profile_name = "Dell-WD15-Dock",
3418 .ifnum = QUIRK_NO_INTERFACE
3421 /* Dell WD19 Dock */
3423 USB_DEVICE(0x0bda, 0x402e),
3424 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3425 .vendor_name = "Dell",
3426 .product_name = "WD19 Dock",
3427 .profile_name = "Dell-WD15-Dock",
3428 .ifnum = QUIRK_ANY_INTERFACE,
3429 .type = QUIRK_SETUP_FMT_AFTER_RESUME
3435 * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3436 * The feedback for the output is the dummy input.
3438 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3439 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3440 .ifnum = QUIRK_ANY_INTERFACE,
3441 .type = QUIRK_COMPOSITE,
3442 .data = (const struct snd_usb_audio_quirk[]) {
3445 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3446 .data = &(const struct audioformat) {
3447 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3453 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3454 USB_ENDPOINT_SYNC_ASYNC,
3455 .rates = SNDRV_PCM_RATE_44100,
3459 .rate_table = (unsigned int[]) { 44100 }
3464 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3465 .data = &(const struct audioformat) {
3466 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3472 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3473 USB_ENDPOINT_SYNC_ASYNC|
3474 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3475 .rates = SNDRV_PCM_RATE_44100,
3479 .rate_table = (unsigned int[]) { 44100 }
3489 #define ALC1220_VB_DESKTOP(vend, prod) { \
3490 USB_DEVICE(vend, prod), \
3491 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
3492 .vendor_name = "Realtek", \
3493 .product_name = "ALC1220-VB-DT", \
3494 .profile_name = "Realtek-ALC1220-VB-Desktop", \
3495 .ifnum = QUIRK_NO_INTERFACE \
3498 ALC1220_VB_DESKTOP(0x0414, 0xa002), /* Gigabyte TRX40 Aorus Pro WiFi */
3499 ALC1220_VB_DESKTOP(0x0db0, 0x0d64), /* MSI TRX40 Creator */
3500 ALC1220_VB_DESKTOP(0x0db0, 0x543d), /* MSI TRX40 */
3501 ALC1220_VB_DESKTOP(0x26ce, 0x0a01), /* Asrock TRX40 Creator */
3502 #undef ALC1220_VB_DESKTOP
3504 /* Two entries for Gigabyte TRX40 Aorus Master:
3505 * TRX40 Aorus Master has two USB-audio devices, one for the front headphone
3506 * with ESS SABRE9218 DAC chip, while another for the rest I/O (the rear
3507 * panel and the front mic) with Realtek ALC1220-VB.
3508 * Here we provide two distinct names for making UCM profiles easier.
3511 USB_DEVICE(0x0414, 0xa000),
3512 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3513 .vendor_name = "Gigabyte",
3514 .product_name = "Aorus Master Front Headphone",
3515 .profile_name = "Gigabyte-Aorus-Master-Front-Headphone",
3516 .ifnum = QUIRK_NO_INTERFACE
3520 USB_DEVICE(0x0414, 0xa001),
3521 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3522 .vendor_name = "Gigabyte",
3523 .product_name = "Aorus Master Main Audio",
3524 .profile_name = "Gigabyte-Aorus-Master-Main-Audio",
3525 .ifnum = QUIRK_NO_INTERFACE
3530 * MacroSilicon MS2109 based HDMI capture cards
3532 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3533 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if
3534 * they pretend to be 96kHz mono as a workaround for stereo being broken
3537 * They also have an issue with initial stream alignment that causes the
3538 * channels to be swapped and out of phase, which is dealt with in quirks.c.
3541 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
3542 USB_DEVICE_ID_MATCH_INT_CLASS |
3543 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3545 .idProduct = 0x2109,
3546 .bInterfaceClass = USB_CLASS_AUDIO,
3547 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
3548 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3549 .vendor_name = "MacroSilicon",
3550 .product_name = "MS2109",
3551 .ifnum = QUIRK_ANY_INTERFACE,
3552 .type = QUIRK_COMPOSITE,
3553 .data = &(const struct snd_usb_audio_quirk[]) {
3556 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
3560 .type = QUIRK_AUDIO_STANDARD_MIXER,
3564 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3565 .data = &(const struct audioformat) {
3566 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3573 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3574 USB_ENDPOINT_SYNC_ASYNC,
3575 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3589 * Change order of interfaces loaded
3591 USB_DEVICE(0x1395, 0x0300),
3592 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3593 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3594 .ifnum = QUIRK_ANY_INTERFACE,
3595 .type = QUIRK_COMPOSITE,
3596 .data = &(const struct snd_usb_audio_quirk[]) {
3600 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3605 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3610 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3619 #undef USB_DEVICE_VENDOR_SPEC