Gitiles
Code Review Sign In
192.168.1.100 / T108 / e958203796650e3959a43708d67534bf36f4c83b / . / marvell / linux / sound / usb / quirks-table.h
blob: a5b0a1a0fc576441e83128c585a80677b809eea4 [file] [log] [blame]
b.liue9582032025-04-17 19:18:16 +0800[diff] [blame^]1/* SPDX-License-Identifier: GPL-2.0-or-later */
2/*
3 * ALSA USB Audio Driver
4 *
5 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>,
6 * Clemens Ladisch <clemens@ladisch.de>
7 */
8
9/*
10 * The contents of this file are part of the driver's id_table.
11 *
12 * In a perfect world, this file would be empty.
13 */
14
15/*
16 * Use this for devices where other interfaces are standard compliant,
17 * to prevent the quirk being applied to those interfaces. (To work with
18 * hotplugging, bDeviceClass must be set to USB_CLASS_PER_INTERFACE.)
19 */
20#define USB_DEVICE_VENDOR_SPEC(vend, prod) \
21 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | \
22 USB_DEVICE_ID_MATCH_PRODUCT | \
23 USB_DEVICE_ID_MATCH_INT_CLASS, \
24 .idVendor = vend, \
25 .idProduct = prod, \
26 .bInterfaceClass = USB_CLASS_VENDOR_SPEC
27
28/* A standard entry matching with vid/pid and the audio class/subclass */
29#define USB_AUDIO_DEVICE(vend, prod) \
30 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
31 USB_DEVICE_ID_MATCH_INT_CLASS | \
32 USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
33 .idVendor = vend, \
34 .idProduct = prod, \
35 .bInterfaceClass = USB_CLASS_AUDIO, \
36 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
37
38/* HP Thunderbolt Dock Audio Headset */
39{
40 USB_DEVICE(0x03f0, 0x0269),
41 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
42 .vendor_name = "HP",
43 .product_name = "Thunderbolt Dock Audio Headset",
44 .profile_name = "HP-Thunderbolt-Dock-Audio-Headset",
45 .ifnum = QUIRK_NO_INTERFACE
46 }
47},
48/* HP Thunderbolt Dock Audio Module */
49{
50 USB_DEVICE(0x03f0, 0x0567),
51 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
52 .vendor_name = "HP",
53 .product_name = "Thunderbolt Dock Audio Module",
54 .profile_name = "HP-Thunderbolt-Dock-Audio-Module",
55 .ifnum = QUIRK_NO_INTERFACE
56 }
57},
58/* FTDI devices */
59{
60 USB_DEVICE(0x0403, 0xb8d8),
61 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
62 /* .vendor_name = "STARR LABS", */
63 /* .product_name = "Starr Labs MIDI USB device", */
64 .ifnum = 0,
65 .type = QUIRK_MIDI_FTDI
66 }
67},
68
69{
70 /* Creative BT-D1 */
71 USB_DEVICE(0x041e, 0x0005),
72 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
73 .ifnum = 1,
74 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
75 .data = &(const struct audioformat) {
76 .formats = SNDRV_PCM_FMTBIT_S16_LE,
77 .channels = 2,
78 .iface = 1,
79 .altsetting = 1,
80 .altset_idx = 1,
81 .endpoint = 0x03,
82 .ep_attr = USB_ENDPOINT_XFER_ISOC,
83 .attributes = 0,
84 .rates = SNDRV_PCM_RATE_CONTINUOUS,
85 .rate_min = 48000,
86 .rate_max = 48000,
87 }
88 }
89},
90
91/* Creative/E-Mu devices */
92{
93 USB_DEVICE(0x041e, 0x3010),
94 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
95 .vendor_name = "Creative Labs",
96 .product_name = "Sound Blaster MP3+",
97 .ifnum = QUIRK_NO_INTERFACE
98 }
99},
100/* Creative/Toshiba Multimedia Center SB-0500 */
101{
102 USB_DEVICE(0x041e, 0x3048),
103 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
104 .vendor_name = "Toshiba",
105 .product_name = "SB-0500",
106 .ifnum = QUIRK_NO_INTERFACE
107 }
108},
109{
110 /* E-Mu 0202 USB */
111 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
112 .idVendor = 0x041e,
113 .idProduct = 0x3f02,
114 .bInterfaceClass = USB_CLASS_AUDIO,
115},
116{
117 /* E-Mu 0404 USB */
118 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
119 .idVendor = 0x041e,
120 .idProduct = 0x3f04,
121 .bInterfaceClass = USB_CLASS_AUDIO,
122},
123{
124 /* E-Mu Tracker Pre */
125 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
126 .idVendor = 0x041e,
127 .idProduct = 0x3f0a,
128 .bInterfaceClass = USB_CLASS_AUDIO,
129},
130{
131 /* E-Mu 0204 USB */
132 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
133 .idVendor = 0x041e,
134 .idProduct = 0x3f19,
135 .bInterfaceClass = USB_CLASS_AUDIO,
136},
137
138/*
139 * Creative Technology, Ltd Live! Cam Sync HD [VF0770]
140 * The device advertises 8 formats, but only a rate of 48kHz is honored by the
141 * hardware and 24 bits give chopped audio, so only report the one working
142 * combination.
143 */
144{
145 USB_DEVICE(0x041e, 0x4095),
146 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
147 .ifnum = QUIRK_ANY_INTERFACE,
148 .type = QUIRK_COMPOSITE,
149 .data = &(const struct snd_usb_audio_quirk[]) {
150 {
151 .ifnum = 2,
152 .type = QUIRK_AUDIO_STANDARD_MIXER,
153 },
154 {
155 .ifnum = 3,
156 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
157 .data = &(const struct audioformat) {
158 .formats = SNDRV_PCM_FMTBIT_S16_LE,
159 .channels = 2,
160 .fmt_bits = 16,
161 .iface = 3,
162 .altsetting = 4,
163 .altset_idx = 4,
164 .endpoint = 0x82,
165 .ep_attr = 0x05,
166 .rates = SNDRV_PCM_RATE_48000,
167 .rate_min = 48000,
168 .rate_max = 48000,
169 .nr_rates = 1,
170 .rate_table = (unsigned int[]) { 48000 },
171 },
172 },
173 {
174 .ifnum = -1
175 },
176 },
177 },
178},
179
180/*
181 * HP Wireless Audio
182 * When not ignored, causes instability issues for some users, forcing them to
183 * blacklist the entire module.
184 */
185{
186 USB_DEVICE(0x0424, 0xb832),
187 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
188 .vendor_name = "Standard Microsystems Corp.",
189 .product_name = "HP Wireless Audio",
190 .ifnum = QUIRK_ANY_INTERFACE,
191 .type = QUIRK_COMPOSITE,
192 .data = (const struct snd_usb_audio_quirk[]) {
193 /* Mixer */
194 {
195 .ifnum = 0,
196 .type = QUIRK_IGNORE_INTERFACE,
197 },
198 /* Playback */
199 {
200 .ifnum = 1,
201 .type = QUIRK_IGNORE_INTERFACE,
202 },
203 /* Capture */
204 {
205 .ifnum = 2,
206 .type = QUIRK_IGNORE_INTERFACE,
207 },
208 /* HID Device, .ifnum = 3 */
209 {
210 .ifnum = -1,
211 }
212 }
213 }
214},
215
216/*
217 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
218 * class matches do not take effect without an explicit ID match.
219 */
220{
221 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
222 USB_DEVICE_ID_MATCH_INT_CLASS |
223 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
224 .idVendor = 0x046d,
225 .idProduct = 0x0850,
226 .bInterfaceClass = USB_CLASS_AUDIO,
227 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
228},
229{
230 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
231 USB_DEVICE_ID_MATCH_INT_CLASS |
232 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
233 .idVendor = 0x046d,
234 .idProduct = 0x08ae,
235 .bInterfaceClass = USB_CLASS_AUDIO,
236 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
237},
238{
239 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
240 USB_DEVICE_ID_MATCH_INT_CLASS |
241 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
242 .idVendor = 0x046d,
243 .idProduct = 0x08c6,
244 .bInterfaceClass = USB_CLASS_AUDIO,
245 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
246},
247{
248 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
249 USB_DEVICE_ID_MATCH_INT_CLASS |
250 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
251 .idVendor = 0x046d,
252 .idProduct = 0x08f0,
253 .bInterfaceClass = USB_CLASS_AUDIO,
254 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
255},
256{
257 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
258 USB_DEVICE_ID_MATCH_INT_CLASS |
259 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
260 .idVendor = 0x046d,
261 .idProduct = 0x08f5,
262 .bInterfaceClass = USB_CLASS_AUDIO,
263 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
264},
265{
266 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
267 USB_DEVICE_ID_MATCH_INT_CLASS |
268 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
269 .idVendor = 0x046d,
270 .idProduct = 0x08f6,
271 .bInterfaceClass = USB_CLASS_AUDIO,
272 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
273},
274{
275 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
276 USB_DEVICE_ID_MATCH_INT_CLASS |
277 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
278 .idVendor = 0x046d,
279 .idProduct = 0x0990,
280 .bInterfaceClass = USB_CLASS_AUDIO,
281 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
282 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
283 .vendor_name = "Logitech, Inc.",
284 .product_name = "QuickCam Pro 9000",
285 .ifnum = QUIRK_NO_INTERFACE
286 }
287},
288
289/*
290 * Yamaha devices
291 */
292
293#define YAMAHA_DEVICE(id, name) { \
294 USB_DEVICE(0x0499, id), \
295 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
296 .vendor_name = "Yamaha", \
297 .product_name = name, \
298 .ifnum = QUIRK_ANY_INTERFACE, \
299 .type = QUIRK_MIDI_YAMAHA \
300 } \
301}
302#define YAMAHA_INTERFACE(id, intf, name) { \
303 USB_DEVICE_VENDOR_SPEC(0x0499, id), \
304 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
305 .vendor_name = "Yamaha", \
306 .product_name = name, \
307 .ifnum = intf, \
308 .type = QUIRK_MIDI_YAMAHA \
309 } \
310}
311YAMAHA_DEVICE(0x1000, "UX256"),
312YAMAHA_DEVICE(0x1001, "MU1000"),
313YAMAHA_DEVICE(0x1002, "MU2000"),
314YAMAHA_DEVICE(0x1003, "MU500"),
315YAMAHA_INTERFACE(0x1004, 3, "UW500"),
316YAMAHA_DEVICE(0x1005, "MOTIF6"),
317YAMAHA_DEVICE(0x1006, "MOTIF7"),
318YAMAHA_DEVICE(0x1007, "MOTIF8"),
319YAMAHA_DEVICE(0x1008, "UX96"),
320YAMAHA_DEVICE(0x1009, "UX16"),
321YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
322YAMAHA_DEVICE(0x100c, "UC-MX"),
323YAMAHA_DEVICE(0x100d, "UC-KX"),
324YAMAHA_DEVICE(0x100e, "S08"),
325YAMAHA_DEVICE(0x100f, "CLP-150"),
326YAMAHA_DEVICE(0x1010, "CLP-170"),
327YAMAHA_DEVICE(0x1011, "P-250"),
328YAMAHA_DEVICE(0x1012, "TYROS"),
329YAMAHA_DEVICE(0x1013, "PF-500"),
330YAMAHA_DEVICE(0x1014, "S90"),
331YAMAHA_DEVICE(0x1015, "MOTIF-R"),
332YAMAHA_DEVICE(0x1016, "MDP-5"),
333YAMAHA_DEVICE(0x1017, "CVP-204"),
334YAMAHA_DEVICE(0x1018, "CVP-206"),
335YAMAHA_DEVICE(0x1019, "CVP-208"),
336YAMAHA_DEVICE(0x101a, "CVP-210"),
337YAMAHA_DEVICE(0x101b, "PSR-1100"),
338YAMAHA_DEVICE(0x101c, "PSR-2100"),
339YAMAHA_DEVICE(0x101d, "CLP-175"),
340YAMAHA_DEVICE(0x101e, "PSR-K1"),
341YAMAHA_DEVICE(0x101f, "EZ-J24"),
342YAMAHA_DEVICE(0x1020, "EZ-250i"),
343YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
344YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
345YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
346YAMAHA_DEVICE(0x1024, "CVP-301"),
347YAMAHA_DEVICE(0x1025, "CVP-303"),
348YAMAHA_DEVICE(0x1026, "CVP-305"),
349YAMAHA_DEVICE(0x1027, "CVP-307"),
350YAMAHA_DEVICE(0x1028, "CVP-309"),
351YAMAHA_DEVICE(0x1029, "CVP-309GP"),
352YAMAHA_DEVICE(0x102a, "PSR-1500"),
353YAMAHA_DEVICE(0x102b, "PSR-3000"),
354YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
355YAMAHA_DEVICE(0x1030, "PSR-295/293"),
356YAMAHA_DEVICE(0x1031, "DGX-205/203"),
357YAMAHA_DEVICE(0x1032, "DGX-305"),
358YAMAHA_DEVICE(0x1033, "DGX-505"),
359YAMAHA_DEVICE(0x1034, NULL),
360YAMAHA_DEVICE(0x1035, NULL),
361YAMAHA_DEVICE(0x1036, NULL),
362YAMAHA_DEVICE(0x1037, NULL),
363YAMAHA_DEVICE(0x1038, NULL),
364YAMAHA_DEVICE(0x1039, NULL),
365YAMAHA_DEVICE(0x103a, NULL),
366YAMAHA_DEVICE(0x103b, NULL),
367YAMAHA_DEVICE(0x103c, NULL),
368YAMAHA_DEVICE(0x103d, NULL),
369YAMAHA_DEVICE(0x103e, NULL),
370YAMAHA_DEVICE(0x103f, NULL),
371YAMAHA_DEVICE(0x1040, NULL),
372YAMAHA_DEVICE(0x1041, NULL),
373YAMAHA_DEVICE(0x1042, NULL),
374YAMAHA_DEVICE(0x1043, NULL),
375YAMAHA_DEVICE(0x1044, NULL),
376YAMAHA_DEVICE(0x1045, NULL),
377YAMAHA_INTERFACE(0x104e, 0, NULL),
378YAMAHA_DEVICE(0x104f, NULL),
379YAMAHA_DEVICE(0x1050, NULL),
380YAMAHA_DEVICE(0x1051, NULL),
381YAMAHA_DEVICE(0x1052, NULL),
382YAMAHA_INTERFACE(0x1053, 0, NULL),
383YAMAHA_INTERFACE(0x1054, 0, NULL),
384YAMAHA_DEVICE(0x1055, NULL),
385YAMAHA_DEVICE(0x1056, NULL),
386YAMAHA_DEVICE(0x1057, NULL),
387YAMAHA_DEVICE(0x1058, NULL),
388YAMAHA_DEVICE(0x1059, NULL),
389YAMAHA_DEVICE(0x105a, NULL),
390YAMAHA_DEVICE(0x105b, NULL),
391YAMAHA_DEVICE(0x105c, NULL),
392YAMAHA_DEVICE(0x105d, NULL),
393YAMAHA_DEVICE(0x1718, "P-125"),
394{
395 USB_DEVICE(0x0499, 0x1503),
396 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
397 /* .vendor_name = "Yamaha", */
398 /* .product_name = "MOX6/MOX8", */
399 .ifnum = QUIRK_ANY_INTERFACE,
400 .type = QUIRK_COMPOSITE,
401 .data = (const struct snd_usb_audio_quirk[]) {
402 {
403 .ifnum = 1,
404 .type = QUIRK_AUDIO_STANDARD_INTERFACE
405 },
406 {
407 .ifnum = 2,
408 .type = QUIRK_AUDIO_STANDARD_INTERFACE
409 },
410 {
411 .ifnum = 3,
412 .type = QUIRK_MIDI_YAMAHA
413 },
414 {
415 .ifnum = -1
416 }
417 }
418 }
419},
420{
421 USB_DEVICE(0x0499, 0x1507),
422 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
423 /* .vendor_name = "Yamaha", */
424 /* .product_name = "THR10", */
425 .ifnum = QUIRK_ANY_INTERFACE,
426 .type = QUIRK_COMPOSITE,
427 .data = (const struct snd_usb_audio_quirk[]) {
428 {
429 .ifnum = 1,
430 .type = QUIRK_AUDIO_STANDARD_INTERFACE
431 },
432 {
433 .ifnum = 2,
434 .type = QUIRK_AUDIO_STANDARD_INTERFACE
435 },
436 {
437 .ifnum = 3,
438 .type = QUIRK_MIDI_YAMAHA
439 },
440 {
441 .ifnum = -1
442 }
443 }
444 }
445},
446{
447 USB_DEVICE(0x0499, 0x1509),
448 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
449 /* .vendor_name = "Yamaha", */
450 /* .product_name = "Steinberg UR22", */
451 .ifnum = QUIRK_ANY_INTERFACE,
452 .type = QUIRK_COMPOSITE,
453 .data = (const struct snd_usb_audio_quirk[]) {
454 {
455 .ifnum = 1,
456 .type = QUIRK_AUDIO_STANDARD_INTERFACE
457 },
458 {
459 .ifnum = 2,
460 .type = QUIRK_AUDIO_STANDARD_INTERFACE
461 },
462 {
463 .ifnum = 3,
464 .type = QUIRK_MIDI_YAMAHA
465 },
466 {
467 .ifnum = 4,
468 .type = QUIRK_IGNORE_INTERFACE
469 },
470 {
471 .ifnum = -1
472 }
473 }
474 }
475},
476{
477 USB_DEVICE(0x0499, 0x150a),
478 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
479 /* .vendor_name = "Yamaha", */
480 /* .product_name = "THR5A", */
481 .ifnum = QUIRK_ANY_INTERFACE,
482 .type = QUIRK_COMPOSITE,
483 .data = (const struct snd_usb_audio_quirk[]) {
484 {
485 .ifnum = 1,
486 .type = QUIRK_AUDIO_STANDARD_INTERFACE
487 },
488 {
489 .ifnum = 2,
490 .type = QUIRK_AUDIO_STANDARD_INTERFACE
491 },
492 {
493 .ifnum = 3,
494 .type = QUIRK_MIDI_YAMAHA
495 },
496 {
497 .ifnum = -1
498 }
499 }
500 }
501},
502{
503 USB_DEVICE(0x0499, 0x150c),
504 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
505 /* .vendor_name = "Yamaha", */
506 /* .product_name = "THR10C", */
507 .ifnum = QUIRK_ANY_INTERFACE,
508 .type = QUIRK_COMPOSITE,
509 .data = (const struct snd_usb_audio_quirk[]) {
510 {
511 .ifnum = 1,
512 .type = QUIRK_AUDIO_STANDARD_INTERFACE
513 },
514 {
515 .ifnum = 2,
516 .type = QUIRK_AUDIO_STANDARD_INTERFACE
517 },
518 {
519 .ifnum = 3,
520 .type = QUIRK_MIDI_YAMAHA
521 },
522 {
523 .ifnum = -1
524 }
525 }
526 }
527},
528YAMAHA_DEVICE(0x2000, "DGP-7"),
529YAMAHA_DEVICE(0x2001, "DGP-5"),
530YAMAHA_DEVICE(0x2002, NULL),
531YAMAHA_DEVICE(0x2003, NULL),
532YAMAHA_DEVICE(0x5000, "CS1D"),
533YAMAHA_DEVICE(0x5001, "DSP1D"),
534YAMAHA_DEVICE(0x5002, "DME32"),
535YAMAHA_DEVICE(0x5003, "DM2000"),
536YAMAHA_DEVICE(0x5004, "02R96"),
537YAMAHA_DEVICE(0x5005, "ACU16-C"),
538YAMAHA_DEVICE(0x5006, "NHB32-C"),
539YAMAHA_DEVICE(0x5007, "DM1000"),
540YAMAHA_DEVICE(0x5008, "01V96"),
541YAMAHA_DEVICE(0x5009, "SPX2000"),
542YAMAHA_DEVICE(0x500a, "PM5D"),
543YAMAHA_DEVICE(0x500b, "DME64N"),
544YAMAHA_DEVICE(0x500c, "DME24N"),
545YAMAHA_DEVICE(0x500d, NULL),
546YAMAHA_DEVICE(0x500e, NULL),
547YAMAHA_DEVICE(0x500f, NULL),
548YAMAHA_DEVICE(0x7000, "DTX"),
549YAMAHA_DEVICE(0x7010, "UB99"),
550#undef YAMAHA_DEVICE
551#undef YAMAHA_INTERFACE
552/* this catches most recent vendor-specific Yamaha devices */
553{
554 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
555 USB_DEVICE_ID_MATCH_INT_CLASS,
556 .idVendor = 0x0499,
557 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
558 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
559 .ifnum = QUIRK_ANY_INTERFACE,
560 .type = QUIRK_AUTODETECT
561 }
562},
563
564/*
565 * Roland/RolandED/Edirol/BOSS devices
566 */
567{
568 USB_DEVICE(0x0582, 0x0000),
569 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
570 .vendor_name = "Roland",
571 .product_name = "UA-100",
572 .ifnum = QUIRK_ANY_INTERFACE,
573 .type = QUIRK_COMPOSITE,
574 .data = (const struct snd_usb_audio_quirk[]) {
575 {
576 .ifnum = 0,
577 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
578 .data = & (const struct audioformat) {
579 .formats = SNDRV_PCM_FMTBIT_S16_LE,
580 .channels = 4,
581 .iface = 0,
582 .altsetting = 1,
583 .altset_idx = 1,
584 .attributes = 0,
585 .endpoint = 0x01,
586 .ep_attr = 0x09,
587 .rates = SNDRV_PCM_RATE_CONTINUOUS,
588 .rate_min = 44100,
589 .rate_max = 44100,
590 }
591 },
592 {
593 .ifnum = 1,
594 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
595 .data = & (const struct audioformat) {
596 .formats = SNDRV_PCM_FMTBIT_S16_LE,
597 .channels = 2,
598 .iface = 1,
599 .altsetting = 1,
600 .altset_idx = 1,
601 .attributes = UAC_EP_CS_ATTR_FILL_MAX,
602 .endpoint = 0x81,
603 .ep_attr = 0x05,
604 .rates = SNDRV_PCM_RATE_CONTINUOUS,
605 .rate_min = 44100,
606 .rate_max = 44100,
607 }
608 },
609 {
610 .ifnum = 2,
611 .type = QUIRK_MIDI_FIXED_ENDPOINT,
612 .data = & (const struct snd_usb_midi_endpoint_info) {
613 .out_cables = 0x0007,
614 .in_cables = 0x0007
615 }
616 },
617 {
618 .ifnum = -1
619 }
620 }
621 }
622},
623{
624 USB_DEVICE(0x0582, 0x0002),
625 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
626 .vendor_name = "EDIROL",
627 .product_name = "UM-4",
628 .ifnum = QUIRK_ANY_INTERFACE,
629 .type = QUIRK_COMPOSITE,
630 .data = (const struct snd_usb_audio_quirk[]) {
631 {
632 .ifnum = 0,
633 .type = QUIRK_IGNORE_INTERFACE
634 },
635 {
636 .ifnum = 1,
637 .type = QUIRK_IGNORE_INTERFACE
638 },
639 {
640 .ifnum = 2,
641 .type = QUIRK_MIDI_FIXED_ENDPOINT,
642 .data = & (const struct snd_usb_midi_endpoint_info) {
643 .out_cables = 0x000f,
644 .in_cables = 0x000f
645 }
646 },
647 {
648 .ifnum = -1
649 }
650 }
651 }
652},
653{
654 USB_DEVICE(0x0582, 0x0003),
655 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
656 .vendor_name = "Roland",
657 .product_name = "SC-8850",
658 .ifnum = QUIRK_ANY_INTERFACE,
659 .type = QUIRK_COMPOSITE,
660 .data = (const struct snd_usb_audio_quirk[]) {
661 {
662 .ifnum = 0,
663 .type = QUIRK_IGNORE_INTERFACE
664 },
665 {
666 .ifnum = 1,
667 .type = QUIRK_IGNORE_INTERFACE
668 },
669 {
670 .ifnum = 2,
671 .type = QUIRK_MIDI_FIXED_ENDPOINT,
672 .data = & (const struct snd_usb_midi_endpoint_info) {
673 .out_cables = 0x003f,
674 .in_cables = 0x003f
675 }
676 },
677 {
678 .ifnum = -1
679 }
680 }
681 }
682},
683{
684 USB_DEVICE(0x0582, 0x0004),
685 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
686 .vendor_name = "Roland",
687 .product_name = "U-8",
688 .ifnum = QUIRK_ANY_INTERFACE,
689 .type = QUIRK_COMPOSITE,
690 .data = (const struct snd_usb_audio_quirk[]) {
691 {
692 .ifnum = 0,
693 .type = QUIRK_IGNORE_INTERFACE
694 },
695 {
696 .ifnum = 1,
697 .type = QUIRK_IGNORE_INTERFACE
698 },
699 {
700 .ifnum = 2,
701 .type = QUIRK_MIDI_FIXED_ENDPOINT,
702 .data = & (const struct snd_usb_midi_endpoint_info) {
703 .out_cables = 0x0005,
704 .in_cables = 0x0005
705 }
706 },
707 {
708 .ifnum = -1
709 }
710 }
711 }
712},
713{
714 /* Has ID 0x0099 when not in "Advanced Driver" mode.
715 * The UM-2EX has only one input, but we cannot detect this. */
716 USB_DEVICE(0x0582, 0x0005),
717 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
718 .vendor_name = "EDIROL",
719 .product_name = "UM-2",
720 .ifnum = QUIRK_ANY_INTERFACE,
721 .type = QUIRK_COMPOSITE,
722 .data = (const struct snd_usb_audio_quirk[]) {
723 {
724 .ifnum = 0,
725 .type = QUIRK_IGNORE_INTERFACE
726 },
727 {
728 .ifnum = 1,
729 .type = QUIRK_IGNORE_INTERFACE
730 },
731 {
732 .ifnum = 2,
733 .type = QUIRK_MIDI_FIXED_ENDPOINT,
734 .data = & (const struct snd_usb_midi_endpoint_info) {
735 .out_cables = 0x0003,
736 .in_cables = 0x0003
737 }
738 },
739 {
740 .ifnum = -1
741 }
742 }
743 }
744},
745{
746 USB_DEVICE(0x0582, 0x0007),
747 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
748 .vendor_name = "Roland",
749 .product_name = "SC-8820",
750 .ifnum = QUIRK_ANY_INTERFACE,
751 .type = QUIRK_COMPOSITE,
752 .data = (const struct snd_usb_audio_quirk[]) {
753 {
754 .ifnum = 0,
755 .type = QUIRK_IGNORE_INTERFACE
756 },
757 {
758 .ifnum = 1,
759 .type = QUIRK_IGNORE_INTERFACE
760 },
761 {
762 .ifnum = 2,
763 .type = QUIRK_MIDI_FIXED_ENDPOINT,
764 .data = & (const struct snd_usb_midi_endpoint_info) {
765 .out_cables = 0x0013,
766 .in_cables = 0x0013
767 }
768 },
769 {
770 .ifnum = -1
771 }
772 }
773 }
774},
775{
776 USB_DEVICE(0x0582, 0x0008),
777 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
778 .vendor_name = "Roland",
779 .product_name = "PC-300",
780 .ifnum = QUIRK_ANY_INTERFACE,
781 .type = QUIRK_COMPOSITE,
782 .data = (const struct snd_usb_audio_quirk[]) {
783 {
784 .ifnum = 0,
785 .type = QUIRK_IGNORE_INTERFACE
786 },
787 {
788 .ifnum = 1,
789 .type = QUIRK_IGNORE_INTERFACE
790 },
791 {
792 .ifnum = 2,
793 .type = QUIRK_MIDI_FIXED_ENDPOINT,
794 .data = & (const struct snd_usb_midi_endpoint_info) {
795 .out_cables = 0x0001,
796 .in_cables = 0x0001
797 }
798 },
799 {
800 .ifnum = -1
801 }
802 }
803 }
804},
805{
806 /* has ID 0x009d when not in "Advanced Driver" mode */
807 USB_DEVICE(0x0582, 0x0009),
808 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
809 .vendor_name = "EDIROL",
810 .product_name = "UM-1",
811 .ifnum = QUIRK_ANY_INTERFACE,
812 .type = QUIRK_COMPOSITE,
813 .data = (const struct snd_usb_audio_quirk[]) {
814 {
815 .ifnum = 0,
816 .type = QUIRK_IGNORE_INTERFACE
817 },
818 {
819 .ifnum = 1,
820 .type = QUIRK_IGNORE_INTERFACE
821 },
822 {
823 .ifnum = 2,
824 .type = QUIRK_MIDI_FIXED_ENDPOINT,
825 .data = & (const struct snd_usb_midi_endpoint_info) {
826 .out_cables = 0x0001,
827 .in_cables = 0x0001
828 }
829 },
830 {
831 .ifnum = -1
832 }
833 }
834 }
835},
836{
837 USB_DEVICE(0x0582, 0x000b),
838 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
839 .vendor_name = "Roland",
840 .product_name = "SK-500",
841 .ifnum = QUIRK_ANY_INTERFACE,
842 .type = QUIRK_COMPOSITE,
843 .data = (const struct snd_usb_audio_quirk[]) {
844 {
845 .ifnum = 0,
846 .type = QUIRK_IGNORE_INTERFACE
847 },
848 {
849 .ifnum = 1,
850 .type = QUIRK_IGNORE_INTERFACE
851 },
852 {
853 .ifnum = 2,
854 .type = QUIRK_MIDI_FIXED_ENDPOINT,
855 .data = & (const struct snd_usb_midi_endpoint_info) {
856 .out_cables = 0x0013,
857 .in_cables = 0x0013
858 }
859 },
860 {
861 .ifnum = -1
862 }
863 }
864 }
865},
866{
867 /* thanks to Emiliano Grilli <emillo@libero.it>
868 * for helping researching this data */
869 USB_DEVICE(0x0582, 0x000c),
870 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
871 .vendor_name = "Roland",
872 .product_name = "SC-D70",
873 .ifnum = QUIRK_ANY_INTERFACE,
874 .type = QUIRK_COMPOSITE,
875 .data = (const struct snd_usb_audio_quirk[]) {
876 {
877 .ifnum = 0,
878 .type = QUIRK_AUDIO_STANDARD_INTERFACE
879 },
880 {
881 .ifnum = 1,
882 .type = QUIRK_AUDIO_STANDARD_INTERFACE
883 },
884 {
885 .ifnum = 2,
886 .type = QUIRK_MIDI_FIXED_ENDPOINT,
887 .data = & (const struct snd_usb_midi_endpoint_info) {
888 .out_cables = 0x0007,
889 .in_cables = 0x0007
890 }
891 },
892 {
893 .ifnum = -1
894 }
895 }
896 }
897},
898{ /*
899 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
900 * If the advanced mode switch at the back of the unit is off, the
901 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
902 * but offers only 16-bit PCM.
903 * In advanced mode, the UA-5 will output S24_3LE samples (two
904 * channels) at the rate indicated on the front switch, including
905 * the 96kHz sample rate.
906 */
907 USB_DEVICE(0x0582, 0x0010),
908 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
909 .vendor_name = "EDIROL",
910 .product_name = "UA-5",
911 .ifnum = QUIRK_ANY_INTERFACE,
912 .type = QUIRK_COMPOSITE,
913 .data = (const struct snd_usb_audio_quirk[]) {
914 {
915 .ifnum = 1,
916 .type = QUIRK_AUDIO_STANDARD_INTERFACE
917 },
918 {
919 .ifnum = 2,
920 .type = QUIRK_AUDIO_STANDARD_INTERFACE
921 },
922 {
923 .ifnum = -1
924 }
925 }
926 }
927},
928{
929 /* has ID 0x0013 when not in "Advanced Driver" mode */
930 USB_DEVICE(0x0582, 0x0012),
931 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
932 .vendor_name = "Roland",
933 .product_name = "XV-5050",
934 .ifnum = 0,
935 .type = QUIRK_MIDI_FIXED_ENDPOINT,
936 .data = & (const struct snd_usb_midi_endpoint_info) {
937 .out_cables = 0x0001,
938 .in_cables = 0x0001
939 }
940 }
941},
942{
943 /* has ID 0x0015 when not in "Advanced Driver" mode */
944 USB_DEVICE(0x0582, 0x0014),
945 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
946 .vendor_name = "EDIROL",
947 .product_name = "UM-880",
948 .ifnum = 0,
949 .type = QUIRK_MIDI_FIXED_ENDPOINT,
950 .data = & (const struct snd_usb_midi_endpoint_info) {
951 .out_cables = 0x01ff,
952 .in_cables = 0x01ff
953 }
954 }
955},
956{
957 /* has ID 0x0017 when not in "Advanced Driver" mode */
958 USB_DEVICE(0x0582, 0x0016),
959 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
960 .vendor_name = "EDIROL",
961 .product_name = "SD-90",
962 .ifnum = QUIRK_ANY_INTERFACE,
963 .type = QUIRK_COMPOSITE,
964 .data = (const struct snd_usb_audio_quirk[]) {
965 {
966 .ifnum = 0,
967 .type = QUIRK_AUDIO_STANDARD_INTERFACE
968 },
969 {
970 .ifnum = 1,
971 .type = QUIRK_AUDIO_STANDARD_INTERFACE
972 },
973 {
974 .ifnum = 2,
975 .type = QUIRK_MIDI_FIXED_ENDPOINT,
976 .data = & (const struct snd_usb_midi_endpoint_info) {
977 .out_cables = 0x000f,
978 .in_cables = 0x000f
979 }
980 },
981 {
982 .ifnum = -1
983 }
984 }
985 }
986},
987{
988 /* has ID 0x001c when not in "Advanced Driver" mode */
989 USB_DEVICE(0x0582, 0x001b),
990 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
991 .vendor_name = "Roland",
992 .product_name = "MMP-2",
993 .ifnum = QUIRK_ANY_INTERFACE,
994 .type = QUIRK_COMPOSITE,
995 .data = (const struct snd_usb_audio_quirk[]) {
996 {
997 .ifnum = 0,
998 .type = QUIRK_IGNORE_INTERFACE
999 },
1000 {
1001 .ifnum = 1,
1002 .type = QUIRK_IGNORE_INTERFACE
1003 },
1004 {
1005 .ifnum = 2,
1006 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1007 .data = & (const struct snd_usb_midi_endpoint_info) {
1008 .out_cables = 0x0001,
1009 .in_cables = 0x0001
1010 }
1011 },
1012 {
1013 .ifnum = -1
1014 }
1015 }
1016 }
1017},
1018{
1019 /* has ID 0x001e when not in "Advanced Driver" mode */
1020 USB_DEVICE(0x0582, 0x001d),
1021 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1022 .vendor_name = "Roland",
1023 .product_name = "V-SYNTH",
1024 .ifnum = 0,
1025 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1026 .data = & (const struct snd_usb_midi_endpoint_info) {
1027 .out_cables = 0x0001,
1028 .in_cables = 0x0001
1029 }
1030 }
1031},
1032{
1033 /* has ID 0x0024 when not in "Advanced Driver" mode */
1034 USB_DEVICE(0x0582, 0x0023),
1035 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1036 .vendor_name = "EDIROL",
1037 .product_name = "UM-550",
1038 .ifnum = 0,
1039 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1040 .data = & (const struct snd_usb_midi_endpoint_info) {
1041 .out_cables = 0x003f,
1042 .in_cables = 0x003f
1043 }
1044 }
1045},
1046{
1047 /*
1048 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
1049 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
1050 * and no MIDI.
1051 */
1052 USB_DEVICE(0x0582, 0x0025),
1053 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1054 .vendor_name = "EDIROL",
1055 .product_name = "UA-20",
1056 .ifnum = QUIRK_ANY_INTERFACE,
1057 .type = QUIRK_COMPOSITE,
1058 .data = (const struct snd_usb_audio_quirk[]) {
1059 {
1060 .ifnum = 0,
1061 .type = QUIRK_IGNORE_INTERFACE
1062 },
1063 {
1064 .ifnum = 1,
1065 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1066 .data = & (const struct audioformat) {
1067 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
1068 .channels = 2,
1069 .iface = 1,
1070 .altsetting = 1,
1071 .altset_idx = 1,
1072 .attributes = 0,
1073 .endpoint = 0x01,
1074 .ep_attr = 0x01,
1075 .rates = SNDRV_PCM_RATE_CONTINUOUS,
1076 .rate_min = 44100,
1077 .rate_max = 44100,
1078 }
1079 },
1080 {
1081 .ifnum = 2,
1082 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1083 .data = & (const struct audioformat) {
1084 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
1085 .channels = 2,
1086 .iface = 2,
1087 .altsetting = 1,
1088 .altset_idx = 1,
1089 .attributes = 0,
1090 .endpoint = 0x82,
1091 .ep_attr = 0x01,
1092 .rates = SNDRV_PCM_RATE_CONTINUOUS,
1093 .rate_min = 44100,
1094 .rate_max = 44100,
1095 }
1096 },
1097 {
1098 .ifnum = 3,
1099 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1100 .data = & (const struct snd_usb_midi_endpoint_info) {
1101 .out_cables = 0x0001,
1102 .in_cables = 0x0001
1103 }
1104 },
1105 {
1106 .ifnum = -1
1107 }
1108 }
1109 }
1110},
1111{
1112 /* has ID 0x0028 when not in "Advanced Driver" mode */
1113 USB_DEVICE(0x0582, 0x0027),
1114 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1115 .vendor_name = "EDIROL",
1116 .product_name = "SD-20",
1117 .ifnum = 0,
1118 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1119 .data = & (const struct snd_usb_midi_endpoint_info) {
1120 .out_cables = 0x0003,
1121 .in_cables = 0x0007
1122 }
1123 }
1124},
1125{
1126 /* has ID 0x002a when not in "Advanced Driver" mode */
1127 USB_DEVICE(0x0582, 0x0029),
1128 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1129 .vendor_name = "EDIROL",
1130 .product_name = "SD-80",
1131 .ifnum = 0,
1132 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1133 .data = & (const struct snd_usb_midi_endpoint_info) {
1134 .out_cables = 0x000f,
1135 .in_cables = 0x000f
1136 }
1137 }
1138},
1139{ /*
1140 * This quirk is for the "Advanced" modes of the Edirol UA-700.
1141 * If the sample format switch is not in an advanced setting, the
1142 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
1143 * but offers only 16-bit PCM and no MIDI.
1144 */
1145 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
1146 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1147 .vendor_name = "EDIROL",
1148 .product_name = "UA-700",
1149 .ifnum = QUIRK_ANY_INTERFACE,
1150 .type = QUIRK_COMPOSITE,
1151 .data = (const struct snd_usb_audio_quirk[]) {
1152 {
1153 .ifnum = 1,
1154 .type = QUIRK_AUDIO_EDIROL_UAXX
1155 },
1156 {
1157 .ifnum = 2,
1158 .type = QUIRK_AUDIO_EDIROL_UAXX
1159 },
1160 {
1161 .ifnum = 3,
1162 .type = QUIRK_AUDIO_EDIROL_UAXX
1163 },
1164 {
1165 .ifnum = -1
1166 }
1167 }
1168 }
1169},
1170{
1171 /* has ID 0x002e when not in "Advanced Driver" mode */
1172 USB_DEVICE(0x0582, 0x002d),
1173 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1174 .vendor_name = "Roland",
1175 .product_name = "XV-2020",
1176 .ifnum = 0,
1177 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1178 .data = & (const struct snd_usb_midi_endpoint_info) {
1179 .out_cables = 0x0001,
1180 .in_cables = 0x0001
1181 }
1182 }
1183},
1184{
1185 /* has ID 0x0030 when not in "Advanced Driver" mode */
1186 USB_DEVICE(0x0582, 0x002f),
1187 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1188 .vendor_name = "Roland",
1189 .product_name = "VariOS",
1190 .ifnum = 0,
1191 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1192 .data = & (const struct snd_usb_midi_endpoint_info) {
1193 .out_cables = 0x0007,
1194 .in_cables = 0x0007
1195 }
1196 }
1197},
1198{
1199 /* has ID 0x0034 when not in "Advanced Driver" mode */
1200 USB_DEVICE(0x0582, 0x0033),
1201 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1202 .vendor_name = "EDIROL",
1203 .product_name = "PCR",
1204 .ifnum = 0,
1205 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1206 .data = & (const struct snd_usb_midi_endpoint_info) {
1207 .out_cables = 0x0003,
1208 .in_cables = 0x0007
1209 }
1210 }
1211},
1212{
1213 /*
1214 * Has ID 0x0038 when not in "Advanced Driver" mode;
1215 * later revisions use IDs 0x0054 and 0x00a2.
1216 */
1217 USB_DEVICE(0x0582, 0x0037),
1218 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1219 .vendor_name = "Roland",
1220 .product_name = "Digital Piano",
1221 .ifnum = 0,
1222 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1223 .data = & (const struct snd_usb_midi_endpoint_info) {
1224 .out_cables = 0x0001,
1225 .in_cables = 0x0001
1226 }
1227 }
1228},
1229{
1230 /*
1231 * This quirk is for the "Advanced Driver" mode. If off, the GS-10
1232 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1233 * and no MIDI.
1234 */
1235 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1236 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1237 .vendor_name = "BOSS",
1238 .product_name = "GS-10",
1239 .ifnum = QUIRK_ANY_INTERFACE,
1240 .type = QUIRK_COMPOSITE,
1241 .data = & (const struct snd_usb_audio_quirk[]) {
1242 {
1243 .ifnum = 1,
1244 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1245 },
1246 {
1247 .ifnum = 2,
1248 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1249 },
1250 {
1251 .ifnum = 3,
1252 .type = QUIRK_MIDI_STANDARD_INTERFACE
1253 },
1254 {
1255 .ifnum = -1
1256 }
1257 }
1258 }
1259},
1260{
1261 /* has ID 0x0041 when not in "Advanced Driver" mode */
1262 USB_DEVICE(0x0582, 0x0040),
1263 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1264 .vendor_name = "Roland",
1265 .product_name = "GI-20",
1266 .ifnum = 0,
1267 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1268 .data = & (const struct snd_usb_midi_endpoint_info) {
1269 .out_cables = 0x0001,
1270 .in_cables = 0x0001
1271 }
1272 }
1273},
1274{
1275 /* has ID 0x0043 when not in "Advanced Driver" mode */
1276 USB_DEVICE(0x0582, 0x0042),
1277 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1278 .vendor_name = "Roland",
1279 .product_name = "RS-70",
1280 .ifnum = 0,
1281 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1282 .data = & (const struct snd_usb_midi_endpoint_info) {
1283 .out_cables = 0x0001,
1284 .in_cables = 0x0001
1285 }
1286 }
1287},
1288{
1289 /* has ID 0x0049 when not in "Advanced Driver" mode */
1290 USB_DEVICE(0x0582, 0x0047),
1291 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1292 /* .vendor_name = "EDIROL", */
1293 /* .product_name = "UR-80", */
1294 .ifnum = QUIRK_ANY_INTERFACE,
1295 .type = QUIRK_COMPOSITE,
1296 .data = (const struct snd_usb_audio_quirk[]) {
1297 /* in the 96 kHz modes, only interface 1 is there */
1298 {
1299 .ifnum = 1,
1300 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1301 },
1302 {
1303 .ifnum = 2,
1304 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1305 },
1306 {
1307 .ifnum = -1
1308 }
1309 }
1310 }
1311},
1312{
1313 /* has ID 0x004a when not in "Advanced Driver" mode */
1314 USB_DEVICE(0x0582, 0x0048),
1315 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1316 /* .vendor_name = "EDIROL", */
1317 /* .product_name = "UR-80", */
1318 .ifnum = 0,
1319 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1320 .data = & (const struct snd_usb_midi_endpoint_info) {
1321 .out_cables = 0x0003,
1322 .in_cables = 0x0007
1323 }
1324 }
1325},
1326{
1327 /* has ID 0x004e when not in "Advanced Driver" mode */
1328 USB_DEVICE(0x0582, 0x004c),
1329 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1330 .vendor_name = "EDIROL",
1331 .product_name = "PCR-A",
1332 .ifnum = QUIRK_ANY_INTERFACE,
1333 .type = QUIRK_COMPOSITE,
1334 .data = (const struct snd_usb_audio_quirk[]) {
1335 {
1336 .ifnum = 1,
1337 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1338 },
1339 {
1340 .ifnum = 2,
1341 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1342 },
1343 {
1344 .ifnum = -1
1345 }
1346 }
1347 }
1348},
1349{
1350 /* has ID 0x004f when not in "Advanced Driver" mode */
1351 USB_DEVICE(0x0582, 0x004d),
1352 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1353 .vendor_name = "EDIROL",
1354 .product_name = "PCR-A",
1355 .ifnum = 0,
1356 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1357 .data = & (const struct snd_usb_midi_endpoint_info) {
1358 .out_cables = 0x0003,
1359 .in_cables = 0x0007
1360 }
1361 }
1362},
1363{
1364 /*
1365 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1366 * is standard compliant, but has only 16-bit PCM.
1367 */
1368 USB_DEVICE(0x0582, 0x0050),
1369 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1370 .vendor_name = "EDIROL",
1371 .product_name = "UA-3FX",
1372 .ifnum = QUIRK_ANY_INTERFACE,
1373 .type = QUIRK_COMPOSITE,
1374 .data = (const struct snd_usb_audio_quirk[]) {
1375 {
1376 .ifnum = 1,
1377 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1378 },
1379 {
1380 .ifnum = 2,
1381 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1382 },
1383 {
1384 .ifnum = -1
1385 }
1386 }
1387 }
1388},
1389{
1390 USB_DEVICE(0x0582, 0x0052),
1391 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1392 .vendor_name = "EDIROL",
1393 .product_name = "UM-1SX",
1394 .ifnum = 0,
1395 .type = QUIRK_MIDI_STANDARD_INTERFACE
1396 }
1397},
1398{
1399 USB_DEVICE(0x0582, 0x0060),
1400 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1401 .vendor_name = "Roland",
1402 .product_name = "EXR Series",
1403 .ifnum = 0,
1404 .type = QUIRK_MIDI_STANDARD_INTERFACE
1405 }
1406},
1407{
1408 /* has ID 0x0066 when not in "Advanced Driver" mode */
1409 USB_DEVICE(0x0582, 0x0064),
1410 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1411 /* .vendor_name = "EDIROL", */
1412 /* .product_name = "PCR-1", */
1413 .ifnum = QUIRK_ANY_INTERFACE,
1414 .type = QUIRK_COMPOSITE,
1415 .data = (const struct snd_usb_audio_quirk[]) {
1416 {
1417 .ifnum = 1,
1418 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1419 },
1420 {
1421 .ifnum = 2,
1422 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1423 },
1424 {
1425 .ifnum = -1
1426 }
1427 }
1428 }
1429},
1430{
1431 /* has ID 0x0067 when not in "Advanced Driver" mode */
1432 USB_DEVICE(0x0582, 0x0065),
1433 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1434 /* .vendor_name = "EDIROL", */
1435 /* .product_name = "PCR-1", */
1436 .ifnum = 0,
1437 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1438 .data = & (const struct snd_usb_midi_endpoint_info) {
1439 .out_cables = 0x0001,
1440 .in_cables = 0x0003
1441 }
1442 }
1443},
1444{
1445 /* has ID 0x006e when not in "Advanced Driver" mode */
1446 USB_DEVICE(0x0582, 0x006d),
1447 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1448 .vendor_name = "Roland",
1449 .product_name = "FANTOM-X",
1450 .ifnum = 0,
1451 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1452 .data = & (const struct snd_usb_midi_endpoint_info) {
1453 .out_cables = 0x0001,
1454 .in_cables = 0x0001
1455 }
1456 }
1457},
1458{ /*
1459 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1460 * If the switch is not in an advanced setting, the UA-25 has
1461 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1462 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1463 */
1464 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1465 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1466 .vendor_name = "EDIROL",
1467 .product_name = "UA-25",
1468 .ifnum = QUIRK_ANY_INTERFACE,
1469 .type = QUIRK_COMPOSITE,
1470 .data = (const struct snd_usb_audio_quirk[]) {
1471 {
1472 .ifnum = 0,
1473 .type = QUIRK_AUDIO_EDIROL_UAXX
1474 },
1475 {
1476 .ifnum = 1,
1477 .type = QUIRK_AUDIO_EDIROL_UAXX
1478 },
1479 {
1480 .ifnum = 2,
1481 .type = QUIRK_AUDIO_EDIROL_UAXX
1482 },
1483 {
1484 .ifnum = -1
1485 }
1486 }
1487 }
1488},
1489{
1490 /* has ID 0x0076 when not in "Advanced Driver" mode */
1491 USB_DEVICE(0x0582, 0x0075),
1492 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1493 .vendor_name = "BOSS",
1494 .product_name = "DR-880",
1495 .ifnum = 0,
1496 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1497 .data = & (const struct snd_usb_midi_endpoint_info) {
1498 .out_cables = 0x0001,
1499 .in_cables = 0x0001
1500 }
1501 }
1502},
1503{
1504 /* has ID 0x007b when not in "Advanced Driver" mode */
1505 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1506 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1507 .vendor_name = "Roland",
1508 /* "RD" or "RD-700SX"? */
1509 .ifnum = 0,
1510 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1511 .data = & (const struct snd_usb_midi_endpoint_info) {
1512 .out_cables = 0x0003,
1513 .in_cables = 0x0003
1514 }
1515 }
1516},
1517{
1518 /* has ID 0x0081 when not in "Advanced Driver" mode */
1519 USB_DEVICE(0x0582, 0x0080),
1520 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1521 .vendor_name = "Roland",
1522 .product_name = "G-70",
1523 .ifnum = 0,
1524 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1525 .data = & (const struct snd_usb_midi_endpoint_info) {
1526 .out_cables = 0x0001,
1527 .in_cables = 0x0001
1528 }
1529 }
1530},
1531{
1532 /* has ID 0x008c when not in "Advanced Driver" mode */
1533 USB_DEVICE(0x0582, 0x008b),
1534 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1535 .vendor_name = "EDIROL",
1536 .product_name = "PC-50",
1537 .ifnum = 0,
1538 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1539 .data = & (const struct snd_usb_midi_endpoint_info) {
1540 .out_cables = 0x0001,
1541 .in_cables = 0x0001
1542 }
1543 }
1544},
1545{
1546 /*
1547 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1548 * is standard compliant, but has only 16-bit PCM and no MIDI.
1549 */
1550 USB_DEVICE(0x0582, 0x00a3),
1551 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1552 .vendor_name = "EDIROL",
1553 .product_name = "UA-4FX",
1554 .ifnum = QUIRK_ANY_INTERFACE,
1555 .type = QUIRK_COMPOSITE,
1556 .data = (const struct snd_usb_audio_quirk[]) {
1557 {
1558 .ifnum = 0,
1559 .type = QUIRK_AUDIO_EDIROL_UAXX
1560 },
1561 {
1562 .ifnum = 1,
1563 .type = QUIRK_AUDIO_EDIROL_UAXX
1564 },
1565 {
1566 .ifnum = 2,
1567 .type = QUIRK_AUDIO_EDIROL_UAXX
1568 },
1569 {
1570 .ifnum = -1
1571 }
1572 }
1573 }
1574},
1575{
1576 /* Edirol M-16DX */
1577 USB_DEVICE(0x0582, 0x00c4),
1578 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1579 .ifnum = QUIRK_ANY_INTERFACE,
1580 .type = QUIRK_COMPOSITE,
1581 .data = (const struct snd_usb_audio_quirk[]) {
1582 {
1583 .ifnum = 0,
1584 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1585 },
1586 {
1587 .ifnum = 1,
1588 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1589 },
1590 {
1591 .ifnum = 2,
1592 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1593 .data = & (const struct snd_usb_midi_endpoint_info) {
1594 .out_cables = 0x0001,
1595 .in_cables = 0x0001
1596 }
1597 },
1598 {
1599 .ifnum = -1
1600 }
1601 }
1602 }
1603},
1604{
1605 /* Advanced modes of the Edirol UA-25EX.
1606 * For the standard mode, UA-25EX has ID 0582:00e7, which
1607 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1608 */
1609 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1610 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1611 .vendor_name = "EDIROL",
1612 .product_name = "UA-25EX",
1613 .ifnum = QUIRK_ANY_INTERFACE,
1614 .type = QUIRK_COMPOSITE,
1615 .data = (const struct snd_usb_audio_quirk[]) {
1616 {
1617 .ifnum = 0,
1618 .type = QUIRK_AUDIO_EDIROL_UAXX
1619 },
1620 {
1621 .ifnum = 1,
1622 .type = QUIRK_AUDIO_EDIROL_UAXX
1623 },
1624 {
1625 .ifnum = 2,
1626 .type = QUIRK_AUDIO_EDIROL_UAXX
1627 },
1628 {
1629 .ifnum = -1
1630 }
1631 }
1632 }
1633},
1634{
1635 /* Edirol UM-3G */
1636 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1637 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1638 .ifnum = 0,
1639 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1640 .data = & (const struct snd_usb_midi_endpoint_info) {
1641 .out_cables = 0x0007,
1642 .in_cables = 0x0007
1643 }
1644 }
1645},
1646{
1647 /* BOSS ME-25 */
1648 USB_DEVICE(0x0582, 0x0113),
1649 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1650 .ifnum = QUIRK_ANY_INTERFACE,
1651 .type = QUIRK_COMPOSITE,
1652 .data = (const struct snd_usb_audio_quirk[]) {
1653 {
1654 .ifnum = 0,
1655 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1656 },
1657 {
1658 .ifnum = 1,
1659 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1660 },
1661 {
1662 .ifnum = 2,
1663 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1664 .data = & (const struct snd_usb_midi_endpoint_info) {
1665 .out_cables = 0x0001,
1666 .in_cables = 0x0001
1667 }
1668 },
1669 {
1670 .ifnum = -1
1671 }
1672 }
1673 }
1674},
1675{
1676 /* only 44.1 kHz works at the moment */
1677 USB_DEVICE(0x0582, 0x0120),
1678 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1679 /* .vendor_name = "Roland", */
1680 /* .product_name = "OCTO-CAPTURE", */
1681 .ifnum = QUIRK_ANY_INTERFACE,
1682 .type = QUIRK_COMPOSITE,
1683 .data = (const struct snd_usb_audio_quirk[]) {
1684 {
1685 .ifnum = 0,
1686 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1687 .data = & (const struct audioformat) {
1688 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1689 .channels = 10,
1690 .iface = 0,
1691 .altsetting = 1,
1692 .altset_idx = 1,
1693 .endpoint = 0x05,
1694 .ep_attr = 0x05,
1695 .rates = SNDRV_PCM_RATE_44100,
1696 .rate_min = 44100,
1697 .rate_max = 44100,
1698 .nr_rates = 1,
1699 .rate_table = (unsigned int[]) { 44100 }
1700 }
1701 },
1702 {
1703 .ifnum = 1,
1704 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1705 .data = & (const struct audioformat) {
1706 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1707 .channels = 12,
1708 .iface = 1,
1709 .altsetting = 1,
1710 .altset_idx = 1,
1711 .endpoint = 0x85,
1712 .ep_attr = 0x25,
1713 .rates = SNDRV_PCM_RATE_44100,
1714 .rate_min = 44100,
1715 .rate_max = 44100,
1716 .nr_rates = 1,
1717 .rate_table = (unsigned int[]) { 44100 }
1718 }
1719 },
1720 {
1721 .ifnum = 2,
1722 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1723 .data = & (const struct snd_usb_midi_endpoint_info) {
1724 .out_cables = 0x0001,
1725 .in_cables = 0x0001
1726 }
1727 },
1728 {
1729 .ifnum = 3,
1730 .type = QUIRK_IGNORE_INTERFACE
1731 },
1732 {
1733 .ifnum = 4,
1734 .type = QUIRK_IGNORE_INTERFACE
1735 },
1736 {
1737 .ifnum = -1
1738 }
1739 }
1740 }
1741},
1742{
1743 /* only 44.1 kHz works at the moment */
1744 USB_DEVICE(0x0582, 0x012f),
1745 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1746 /* .vendor_name = "Roland", */
1747 /* .product_name = "QUAD-CAPTURE", */
1748 .ifnum = QUIRK_ANY_INTERFACE,
1749 .type = QUIRK_COMPOSITE,
1750 .data = (const struct snd_usb_audio_quirk[]) {
1751 {
1752 .ifnum = 0,
1753 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1754 .data = & (const struct audioformat) {
1755 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1756 .channels = 4,
1757 .iface = 0,
1758 .altsetting = 1,
1759 .altset_idx = 1,
1760 .endpoint = 0x05,
1761 .ep_attr = 0x05,
1762 .rates = SNDRV_PCM_RATE_44100,
1763 .rate_min = 44100,
1764 .rate_max = 44100,
1765 .nr_rates = 1,
1766 .rate_table = (unsigned int[]) { 44100 }
1767 }
1768 },
1769 {
1770 .ifnum = 1,
1771 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1772 .data = & (const struct audioformat) {
1773 .formats = SNDRV_PCM_FMTBIT_S32_LE,
1774 .channels = 6,
1775 .iface = 1,
1776 .altsetting = 1,
1777 .altset_idx = 1,
1778 .endpoint = 0x85,
1779 .ep_attr = 0x25,
1780 .rates = SNDRV_PCM_RATE_44100,
1781 .rate_min = 44100,
1782 .rate_max = 44100,
1783 .nr_rates = 1,
1784 .rate_table = (unsigned int[]) { 44100 }
1785 }
1786 },
1787 {
1788 .ifnum = 2,
1789 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1790 .data = & (const struct snd_usb_midi_endpoint_info) {
1791 .out_cables = 0x0001,
1792 .in_cables = 0x0001
1793 }
1794 },
1795 {
1796 .ifnum = 3,
1797 .type = QUIRK_IGNORE_INTERFACE
1798 },
1799 {
1800 .ifnum = 4,
1801 .type = QUIRK_IGNORE_INTERFACE
1802 },
1803 {
1804 .ifnum = -1
1805 }
1806 }
1807 }
1808},
1809{
1810 USB_DEVICE(0x0582, 0x0159),
1811 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1812 /* .vendor_name = "Roland", */
1813 /* .product_name = "UA-22", */
1814 .ifnum = QUIRK_ANY_INTERFACE,
1815 .type = QUIRK_COMPOSITE,
1816 .data = (const struct snd_usb_audio_quirk[]) {
1817 {
1818 .ifnum = 0,
1819 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1820 },
1821 {
1822 .ifnum = 1,
1823 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1824 },
1825 {
1826 .ifnum = 2,
1827 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1828 .data = & (const struct snd_usb_midi_endpoint_info) {
1829 .out_cables = 0x0001,
1830 .in_cables = 0x0001
1831 }
1832 },
1833 {
1834 .ifnum = -1
1835 }
1836 }
1837 }
1838},
1839/* this catches most recent vendor-specific Roland devices */
1840{
1841 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1842 USB_DEVICE_ID_MATCH_INT_CLASS,
1843 .idVendor = 0x0582,
1844 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1845 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1846 .ifnum = QUIRK_ANY_INTERFACE,
1847 .type = QUIRK_AUTODETECT
1848 }
1849},
1850
1851/* Guillemot devices */
1852{
1853 /*
1854 * This is for the "Windows Edition" where the external MIDI ports are
1855 * the only MIDI ports; the control data is reported through HID
1856 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard
1857 * compliant USB MIDI ports for external MIDI and controls.
1858 */
1859 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1860 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1861 .vendor_name = "Hercules",
1862 .product_name = "DJ Console (WE)",
1863 .ifnum = 4,
1864 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1865 .data = & (const struct snd_usb_midi_endpoint_info) {
1866 .out_cables = 0x0001,
1867 .in_cables = 0x0001
1868 }
1869 }
1870},
1871
1872/* Midiman/M-Audio devices */
1873{
1874 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1875 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1876 .vendor_name = "M-Audio",
1877 .product_name = "MidiSport 2x2",
1878 .ifnum = QUIRK_ANY_INTERFACE,
1879 .type = QUIRK_MIDI_MIDIMAN,
1880 .data = & (const struct snd_usb_midi_endpoint_info) {
1881 .out_cables = 0x0003,
1882 .in_cables = 0x0003
1883 }
1884 }
1885},
1886{
1887 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1888 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1889 .vendor_name = "M-Audio",
1890 .product_name = "MidiSport 1x1",
1891 .ifnum = QUIRK_ANY_INTERFACE,
1892 .type = QUIRK_MIDI_MIDIMAN,
1893 .data = & (const struct snd_usb_midi_endpoint_info) {
1894 .out_cables = 0x0001,
1895 .in_cables = 0x0001
1896 }
1897 }
1898},
1899{
1900 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1901 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1902 .vendor_name = "M-Audio",
1903 .product_name = "Keystation",
1904 .ifnum = QUIRK_ANY_INTERFACE,
1905 .type = QUIRK_MIDI_MIDIMAN,
1906 .data = & (const struct snd_usb_midi_endpoint_info) {
1907 .out_cables = 0x0001,
1908 .in_cables = 0x0001
1909 }
1910 }
1911},
1912{
1913 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1914 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1915 .vendor_name = "M-Audio",
1916 .product_name = "MidiSport 4x4",
1917 .ifnum = QUIRK_ANY_INTERFACE,
1918 .type = QUIRK_MIDI_MIDIMAN,
1919 .data = & (const struct snd_usb_midi_endpoint_info) {
1920 .out_cables = 0x000f,
1921 .in_cables = 0x000f
1922 }
1923 }
1924},
1925{
1926 /*
1927 * For hardware revision 1.05; in the later revisions (1.10 and
1928 * 1.21), 0x1031 is the ID for the device without firmware.
1929 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1930 */
1931 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1932 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1933 .vendor_name = "M-Audio",
1934 .product_name = "MidiSport 8x8",
1935 .ifnum = QUIRK_ANY_INTERFACE,
1936 .type = QUIRK_MIDI_MIDIMAN,
1937 .data = & (const struct snd_usb_midi_endpoint_info) {
1938 .out_cables = 0x01ff,
1939 .in_cables = 0x01ff
1940 }
1941 }
1942},
1943{
1944 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1945 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1946 .vendor_name = "M-Audio",
1947 .product_name = "MidiSport 8x8",
1948 .ifnum = QUIRK_ANY_INTERFACE,
1949 .type = QUIRK_MIDI_MIDIMAN,
1950 .data = & (const struct snd_usb_midi_endpoint_info) {
1951 .out_cables = 0x01ff,
1952 .in_cables = 0x01ff
1953 }
1954 }
1955},
1956{
1957 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1958 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1959 .vendor_name = "M-Audio",
1960 .product_name = "MidiSport 2x4",
1961 .ifnum = QUIRK_ANY_INTERFACE,
1962 .type = QUIRK_MIDI_MIDIMAN,
1963 .data = & (const struct snd_usb_midi_endpoint_info) {
1964 .out_cables = 0x000f,
1965 .in_cables = 0x0003
1966 }
1967 }
1968},
1969{
1970 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1971 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1972 .vendor_name = "M-Audio",
1973 .product_name = "Quattro",
1974 .ifnum = QUIRK_ANY_INTERFACE,
1975 .type = QUIRK_COMPOSITE,
1976 .data = & (const struct snd_usb_audio_quirk[]) {
1977 /*
1978 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1979 * and share endpoints with the other interfaces.
1980 * Ignore them. The other interfaces can do 24 bits,
1981 * but captured samples are big-endian (see usbaudio.c).
1982 */
1983 {
1984 .ifnum = 0,
1985 .type = QUIRK_IGNORE_INTERFACE
1986 },
1987 {
1988 .ifnum = 1,
1989 .type = QUIRK_IGNORE_INTERFACE
1990 },
1991 {
1992 .ifnum = 2,
1993 .type = QUIRK_IGNORE_INTERFACE
1994 },
1995 {
1996 .ifnum = 3,
1997 .type = QUIRK_IGNORE_INTERFACE
1998 },
1999 {
2000 .ifnum = 4,
2001 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2002 },
2003 {
2004 .ifnum = 5,
2005 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2006 },
2007 {
2008 .ifnum = 6,
2009 .type = QUIRK_IGNORE_INTERFACE
2010 },
2011 {
2012 .ifnum = 7,
2013 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2014 },
2015 {
2016 .ifnum = 8,
2017 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2018 },
2019 {
2020 .ifnum = 9,
2021 .type = QUIRK_MIDI_MIDIMAN,
2022 .data = & (const struct snd_usb_midi_endpoint_info) {
2023 .out_cables = 0x0001,
2024 .in_cables = 0x0001
2025 }
2026 },
2027 {
2028 .ifnum = -1
2029 }
2030 }
2031 }
2032},
2033{
2034 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
2035 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2036 .vendor_name = "M-Audio",
2037 .product_name = "AudioPhile",
2038 .ifnum = 6,
2039 .type = QUIRK_MIDI_MIDIMAN,
2040 .data = & (const struct snd_usb_midi_endpoint_info) {
2041 .out_cables = 0x0001,
2042 .in_cables = 0x0001
2043 }
2044 }
2045},
2046{
2047 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
2048 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2049 .vendor_name = "M-Audio",
2050 .product_name = "Ozone",
2051 .ifnum = 3,
2052 .type = QUIRK_MIDI_MIDIMAN,
2053 .data = & (const struct snd_usb_midi_endpoint_info) {
2054 .out_cables = 0x0001,
2055 .in_cables = 0x0001
2056 }
2057 }
2058},
2059{
2060 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
2061 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2062 .vendor_name = "M-Audio",
2063 .product_name = "OmniStudio",
2064 .ifnum = QUIRK_ANY_INTERFACE,
2065 .type = QUIRK_COMPOSITE,
2066 .data = & (const struct snd_usb_audio_quirk[]) {
2067 {
2068 .ifnum = 0,
2069 .type = QUIRK_IGNORE_INTERFACE
2070 },
2071 {
2072 .ifnum = 1,
2073 .type = QUIRK_IGNORE_INTERFACE
2074 },
2075 {
2076 .ifnum = 2,
2077 .type = QUIRK_IGNORE_INTERFACE
2078 },
2079 {
2080 .ifnum = 3,
2081 .type = QUIRK_IGNORE_INTERFACE
2082 },
2083 {
2084 .ifnum = 4,
2085 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2086 },
2087 {
2088 .ifnum = 5,
2089 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2090 },
2091 {
2092 .ifnum = 6,
2093 .type = QUIRK_IGNORE_INTERFACE
2094 },
2095 {
2096 .ifnum = 7,
2097 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2098 },
2099 {
2100 .ifnum = 8,
2101 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2102 },
2103 {
2104 .ifnum = 9,
2105 .type = QUIRK_MIDI_MIDIMAN,
2106 .data = & (const struct snd_usb_midi_endpoint_info) {
2107 .out_cables = 0x0001,
2108 .in_cables = 0x0001
2109 }
2110 },
2111 {
2112 .ifnum = -1
2113 }
2114 }
2115 }
2116},
2117{
2118 USB_DEVICE(0x0763, 0x2019),
2119 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2120 /* .vendor_name = "M-Audio", */
2121 /* .product_name = "Ozone Academic", */
2122 .ifnum = QUIRK_ANY_INTERFACE,
2123 .type = QUIRK_COMPOSITE,
2124 .data = & (const struct snd_usb_audio_quirk[]) {
2125 {
2126 .ifnum = 0,
2127 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2128 },
2129 {
2130 .ifnum = 1,
2131 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2132 },
2133 {
2134 .ifnum = 2,
2135 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2136 },
2137 {
2138 .ifnum = 3,
2139 .type = QUIRK_MIDI_MIDIMAN,
2140 .data = & (const struct snd_usb_midi_endpoint_info) {
2141 .out_cables = 0x0001,
2142 .in_cables = 0x0001
2143 }
2144 },
2145 {
2146 .ifnum = -1
2147 }
2148 }
2149 }
2150},
2151{
2152 /* M-Audio Micro */
2153 USB_DEVICE_VENDOR_SPEC(0x0763, 0x201a),
2154},
2155{
2156 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2157 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2158 /* .vendor_name = "M-Audio", */
2159 /* .product_name = "Fast Track C400", */
2160 .ifnum = QUIRK_ANY_INTERFACE,
2161 .type = QUIRK_COMPOSITE,
2162 .data = &(const struct snd_usb_audio_quirk[]) {
2163 {
2164 .ifnum = 1,
2165 .type = QUIRK_AUDIO_STANDARD_MIXER,
2166 },
2167 /* Playback */
2168 {
2169 .ifnum = 2,
2170 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2171 .data = &(const struct audioformat) {
2172 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2173 .channels = 6,
2174 .iface = 2,
2175 .altsetting = 1,
2176 .altset_idx = 1,
2177 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2178 .endpoint = 0x01,
2179 .ep_attr = 0x09,
2180 .rates = SNDRV_PCM_RATE_44100 |
2181 SNDRV_PCM_RATE_48000 |
2182 SNDRV_PCM_RATE_88200 |
2183 SNDRV_PCM_RATE_96000,
2184 .rate_min = 44100,
2185 .rate_max = 96000,
2186 .nr_rates = 4,
2187 .rate_table = (unsigned int[]) {
2188 44100, 48000, 88200, 96000
2189 },
2190 .clock = 0x80,
2191 }
2192 },
2193 /* Capture */
2194 {
2195 .ifnum = 3,
2196 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2197 .data = &(const struct audioformat) {
2198 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2199 .channels = 4,
2200 .iface = 3,
2201 .altsetting = 1,
2202 .altset_idx = 1,
2203 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2204 .endpoint = 0x81,
2205 .ep_attr = 0x05,
2206 .rates = SNDRV_PCM_RATE_44100 |
2207 SNDRV_PCM_RATE_48000 |
2208 SNDRV_PCM_RATE_88200 |
2209 SNDRV_PCM_RATE_96000,
2210 .rate_min = 44100,
2211 .rate_max = 96000,
2212 .nr_rates = 4,
2213 .rate_table = (unsigned int[]) {
2214 44100, 48000, 88200, 96000
2215 },
2216 .clock = 0x80,
2217 }
2218 },
2219 /* MIDI */
2220 {
2221 .ifnum = -1 /* Interface = 4 */
2222 }
2223 }
2224 }
2225},
2226{
2227 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2228 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2229 /* .vendor_name = "M-Audio", */
2230 /* .product_name = "Fast Track C600", */
2231 .ifnum = QUIRK_ANY_INTERFACE,
2232 .type = QUIRK_COMPOSITE,
2233 .data = &(const struct snd_usb_audio_quirk[]) {
2234 {
2235 .ifnum = 1,
2236 .type = QUIRK_AUDIO_STANDARD_MIXER,
2237 },
2238 /* Playback */
2239 {
2240 .ifnum = 2,
2241 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2242 .data = &(const struct audioformat) {
2243 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2244 .channels = 8,
2245 .iface = 2,
2246 .altsetting = 1,
2247 .altset_idx = 1,
2248 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2249 .endpoint = 0x01,
2250 .ep_attr = 0x09,
2251 .rates = SNDRV_PCM_RATE_44100 |
2252 SNDRV_PCM_RATE_48000 |
2253 SNDRV_PCM_RATE_88200 |
2254 SNDRV_PCM_RATE_96000,
2255 .rate_min = 44100,
2256 .rate_max = 96000,
2257 .nr_rates = 4,
2258 .rate_table = (unsigned int[]) {
2259 44100, 48000, 88200, 96000
2260 },
2261 .clock = 0x80,
2262 }
2263 },
2264 /* Capture */
2265 {
2266 .ifnum = 3,
2267 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2268 .data = &(const struct audioformat) {
2269 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2270 .channels = 6,
2271 .iface = 3,
2272 .altsetting = 1,
2273 .altset_idx = 1,
2274 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2275 .endpoint = 0x81,
2276 .ep_attr = 0x05,
2277 .rates = SNDRV_PCM_RATE_44100 |
2278 SNDRV_PCM_RATE_48000 |
2279 SNDRV_PCM_RATE_88200 |
2280 SNDRV_PCM_RATE_96000,
2281 .rate_min = 44100,
2282 .rate_max = 96000,
2283 .nr_rates = 4,
2284 .rate_table = (unsigned int[]) {
2285 44100, 48000, 88200, 96000
2286 },
2287 .clock = 0x80,
2288 }
2289 },
2290 /* MIDI */
2291 {
2292 .ifnum = -1 /* Interface = 4 */
2293 }
2294 }
2295 }
2296},
2297{
2298 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2299 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2300 /* .vendor_name = "M-Audio", */
2301 /* .product_name = "Fast Track Ultra", */
2302 .ifnum = QUIRK_ANY_INTERFACE,
2303 .type = QUIRK_COMPOSITE,
2304 .data = & (const struct snd_usb_audio_quirk[]) {
2305 {
2306 .ifnum = 0,
2307 .type = QUIRK_AUDIO_STANDARD_MIXER,
2308 },
2309 {
2310 .ifnum = 1,
2311 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2312 .data = & (const struct audioformat) {
2313 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2314 .channels = 8,
2315 .iface = 1,
2316 .altsetting = 1,
2317 .altset_idx = 1,
2318 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2319 .endpoint = 0x01,
2320 .ep_attr = 0x09,
2321 .rates = SNDRV_PCM_RATE_44100 |
2322 SNDRV_PCM_RATE_48000 |
2323 SNDRV_PCM_RATE_88200 |
2324 SNDRV_PCM_RATE_96000,
2325 .rate_min = 44100,
2326 .rate_max = 96000,
2327 .nr_rates = 4,
2328 .rate_table = (unsigned int[]) {
2329 44100, 48000, 88200, 96000
2330 }
2331 }
2332 },
2333 {
2334 .ifnum = 2,
2335 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2336 .data = & (const struct audioformat) {
2337 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2338 .channels = 8,
2339 .iface = 2,
2340 .altsetting = 1,
2341 .altset_idx = 1,
2342 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2343 .endpoint = 0x81,
2344 .ep_attr = 0x05,
2345 .rates = SNDRV_PCM_RATE_44100 |
2346 SNDRV_PCM_RATE_48000 |
2347 SNDRV_PCM_RATE_88200 |
2348 SNDRV_PCM_RATE_96000,
2349 .rate_min = 44100,
2350 .rate_max = 96000,
2351 .nr_rates = 4,
2352 .rate_table = (unsigned int[]) {
2353 44100, 48000, 88200, 96000
2354 }
2355 }
2356 },
2357 /* interface 3 (MIDI) is standard compliant */
2358 {
2359 .ifnum = -1
2360 }
2361 }
2362 }
2363},
2364{
2365 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2366 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2367 /* .vendor_name = "M-Audio", */
2368 /* .product_name = "Fast Track Ultra 8R", */
2369 .ifnum = QUIRK_ANY_INTERFACE,
2370 .type = QUIRK_COMPOSITE,
2371 .data = & (const struct snd_usb_audio_quirk[]) {
2372 {
2373 .ifnum = 0,
2374 .type = QUIRK_AUDIO_STANDARD_MIXER,
2375 },
2376 {
2377 .ifnum = 1,
2378 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2379 .data = & (const struct audioformat) {
2380 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2381 .channels = 8,
2382 .iface = 1,
2383 .altsetting = 1,
2384 .altset_idx = 1,
2385 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2386 .endpoint = 0x01,
2387 .ep_attr = 0x09,
2388 .rates = SNDRV_PCM_RATE_44100 |
2389 SNDRV_PCM_RATE_48000 |
2390 SNDRV_PCM_RATE_88200 |
2391 SNDRV_PCM_RATE_96000,
2392 .rate_min = 44100,
2393 .rate_max = 96000,
2394 .nr_rates = 4,
2395 .rate_table = (unsigned int[]) {
2396 44100, 48000, 88200, 96000
2397 }
2398 }
2399 },
2400 {
2401 .ifnum = 2,
2402 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2403 .data = & (const struct audioformat) {
2404 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2405 .channels = 8,
2406 .iface = 2,
2407 .altsetting = 1,
2408 .altset_idx = 1,
2409 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2410 .endpoint = 0x81,
2411 .ep_attr = 0x05,
2412 .rates = SNDRV_PCM_RATE_44100 |
2413 SNDRV_PCM_RATE_48000 |
2414 SNDRV_PCM_RATE_88200 |
2415 SNDRV_PCM_RATE_96000,
2416 .rate_min = 44100,
2417 .rate_max = 96000,
2418 .nr_rates = 4,
2419 .rate_table = (unsigned int[]) {
2420 44100, 48000, 88200, 96000
2421 }
2422 }
2423 },
2424 /* interface 3 (MIDI) is standard compliant */
2425 {
2426 .ifnum = -1
2427 }
2428 }
2429 }
2430},
2431
2432/* Casio devices */
2433{
2434 USB_DEVICE(0x07cf, 0x6801),
2435 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2436 .vendor_name = "Casio",
2437 .product_name = "PL-40R",
2438 .ifnum = 0,
2439 .type = QUIRK_MIDI_YAMAHA
2440 }
2441},
2442{
2443 /* this ID is used by several devices without a product ID */
2444 USB_DEVICE(0x07cf, 0x6802),
2445 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2446 .vendor_name = "Casio",
2447 .product_name = "Keyboard",
2448 .ifnum = 0,
2449 .type = QUIRK_MIDI_YAMAHA
2450 }
2451},
2452
2453/* Mark of the Unicorn devices */
2454{
2455 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2456 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2457 USB_DEVICE_ID_MATCH_PRODUCT |
2458 USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2459 .idVendor = 0x07fd,
2460 .idProduct = 0x0001,
2461 .bDeviceSubClass = 2,
2462 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2463 .vendor_name = "MOTU",
2464 .product_name = "Fastlane",
2465 .ifnum = QUIRK_ANY_INTERFACE,
2466 .type = QUIRK_COMPOSITE,
2467 .data = & (const struct snd_usb_audio_quirk[]) {
2468 {
2469 .ifnum = 0,
2470 .type = QUIRK_MIDI_RAW_BYTES
2471 },
2472 {
2473 .ifnum = 1,
2474 .type = QUIRK_IGNORE_INTERFACE
2475 },
2476 {
2477 .ifnum = -1
2478 }
2479 }
2480 }
2481},
2482
2483/* Emagic devices */
2484{
2485 USB_DEVICE(0x086a, 0x0001),
2486 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2487 .vendor_name = "Emagic",
2488 .product_name = "Unitor8",
2489 .ifnum = 2,
2490 .type = QUIRK_MIDI_EMAGIC,
2491 .data = & (const struct snd_usb_midi_endpoint_info) {
2492 .out_cables = 0x80ff,
2493 .in_cables = 0x80ff
2494 }
2495 }
2496},
2497{
2498 USB_DEVICE(0x086a, 0x0002),
2499 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2500 .vendor_name = "Emagic",
2501 /* .product_name = "AMT8", */
2502 .ifnum = 2,
2503 .type = QUIRK_MIDI_EMAGIC,
2504 .data = & (const struct snd_usb_midi_endpoint_info) {
2505 .out_cables = 0x80ff,
2506 .in_cables = 0x80ff
2507 }
2508 }
2509},
2510{
2511 USB_DEVICE(0x086a, 0x0003),
2512 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2513 .vendor_name = "Emagic",
2514 /* .product_name = "MT4", */
2515 .ifnum = 2,
2516 .type = QUIRK_MIDI_EMAGIC,
2517 .data = & (const struct snd_usb_midi_endpoint_info) {
2518 .out_cables = 0x800f,
2519 .in_cables = 0x8003
2520 }
2521 }
2522},
2523
2524/* KORG devices */
2525{
2526 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2527 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2528 .vendor_name = "KORG, Inc.",
2529 /* .product_name = "PANDORA PX5D", */
2530 .ifnum = 3,
2531 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2532 }
2533},
2534
2535{
2536 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2537 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2538 .vendor_name = "KORG, Inc.",
2539 /* .product_name = "ToneLab ST", */
2540 .ifnum = 3,
2541 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2542 }
2543},
2544
2545{
2546 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0204),
2547 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2548 .vendor_name = "KORG, Inc.",
2549 /* .product_name = "ToneLab EX", */
2550 .ifnum = 3,
2551 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2552 }
2553},
2554
2555/* AKAI devices */
2556{
2557 USB_DEVICE(0x09e8, 0x0062),
2558 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2559 .vendor_name = "AKAI",
2560 .product_name = "MPD16",
2561 .ifnum = 0,
2562 .type = QUIRK_MIDI_AKAI,
2563 }
2564},
2565
2566{
2567 /* Akai MPC Element */
2568 USB_DEVICE(0x09e8, 0x0021),
2569 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2570 .ifnum = QUIRK_ANY_INTERFACE,
2571 .type = QUIRK_COMPOSITE,
2572 .data = & (const struct snd_usb_audio_quirk[]) {
2573 {
2574 .ifnum = 0,
2575 .type = QUIRK_IGNORE_INTERFACE
2576 },
2577 {
2578 .ifnum = 1,
2579 .type = QUIRK_MIDI_STANDARD_INTERFACE
2580 },
2581 {
2582 .ifnum = -1
2583 }
2584 }
2585 }
2586},
2587
2588/* Steinberg devices */
2589{
2590 /* Steinberg MI2 */
2591 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2592 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2593 .ifnum = QUIRK_ANY_INTERFACE,
2594 .type = QUIRK_COMPOSITE,
2595 .data = & (const struct snd_usb_audio_quirk[]) {
2596 {
2597 .ifnum = 0,
2598 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2599 },
2600 {
2601 .ifnum = 1,
2602 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2603 },
2604 {
2605 .ifnum = 2,
2606 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2607 },
2608 {
2609 .ifnum = 3,
2610 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2611 .data = &(const struct snd_usb_midi_endpoint_info) {
2612 .out_cables = 0x0001,
2613 .in_cables = 0x0001
2614 }
2615 },
2616 {
2617 .ifnum = -1
2618 }
2619 }
2620 }
2621},
2622{
2623 /* Steinberg MI4 */
2624 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2625 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2626 .ifnum = QUIRK_ANY_INTERFACE,
2627 .type = QUIRK_COMPOSITE,
2628 .data = & (const struct snd_usb_audio_quirk[]) {
2629 {
2630 .ifnum = 0,
2631 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2632 },
2633 {
2634 .ifnum = 1,
2635 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2636 },
2637 {
2638 .ifnum = 2,
2639 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2640 },
2641 {
2642 .ifnum = 3,
2643 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2644 .data = &(const struct snd_usb_midi_endpoint_info) {
2645 .out_cables = 0x0001,
2646 .in_cables = 0x0001
2647 }
2648 },
2649 {
2650 .ifnum = -1
2651 }
2652 }
2653 }
2654},
2655
2656/* TerraTec devices */
2657{
2658 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2659 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2660 .vendor_name = "TerraTec",
2661 .product_name = "PHASE 26",
2662 .ifnum = 3,
2663 .type = QUIRK_MIDI_STANDARD_INTERFACE
2664 }
2665},
2666{
2667 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2668 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2669 .vendor_name = "TerraTec",
2670 .product_name = "PHASE 26",
2671 .ifnum = 3,
2672 .type = QUIRK_MIDI_STANDARD_INTERFACE
2673 }
2674},
2675{
2676 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2677 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2678 .vendor_name = "TerraTec",
2679 .product_name = "PHASE 26",
2680 .ifnum = 3,
2681 .type = QUIRK_MIDI_STANDARD_INTERFACE
2682 }
2683},
2684{
2685 USB_DEVICE(0x0ccd, 0x0028),
2686 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2687 .vendor_name = "TerraTec",
2688 .product_name = "Aureon5.1MkII",
2689 .ifnum = QUIRK_NO_INTERFACE
2690 }
2691},
2692{
2693 USB_DEVICE(0x0ccd, 0x0035),
2694 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2695 .vendor_name = "Miditech",
2696 .product_name = "Play'n Roll",
2697 .ifnum = 0,
2698 .type = QUIRK_MIDI_CME
2699 }
2700},
2701
2702/* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2703{
2704 USB_DEVICE(0x103d, 0x0100),
2705 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2706 .vendor_name = "Stanton",
2707 .product_name = "ScratchAmp",
2708 .ifnum = QUIRK_NO_INTERFACE
2709 }
2710},
2711{
2712 USB_DEVICE(0x103d, 0x0101),
2713 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2714 .vendor_name = "Stanton",
2715 .product_name = "ScratchAmp",
2716 .ifnum = QUIRK_NO_INTERFACE
2717 }
2718},
2719
2720/* Novation EMS devices */
2721{
2722 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2723 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2724 .vendor_name = "Novation",
2725 .product_name = "ReMOTE Audio/XStation",
2726 .ifnum = 4,
2727 .type = QUIRK_MIDI_NOVATION
2728 }
2729},
2730{
2731 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2732 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2733 .vendor_name = "Novation",
2734 .product_name = "Speedio",
2735 .ifnum = 3,
2736 .type = QUIRK_MIDI_NOVATION
2737 }
2738},
2739{
2740 USB_DEVICE(0x1235, 0x000a),
2741 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2742 /* .vendor_name = "Novation", */
2743 /* .product_name = "Nocturn", */
2744 .ifnum = 0,
2745 .type = QUIRK_MIDI_RAW_BYTES
2746 }
2747},
2748{
2749 USB_DEVICE(0x1235, 0x000e),
2750 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2751 /* .vendor_name = "Novation", */
2752 /* .product_name = "Launchpad", */
2753 .ifnum = 0,
2754 .type = QUIRK_MIDI_RAW_BYTES
2755 }
2756},
2757{
2758 USB_DEVICE(0x1235, 0x0010),
2759 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2760 .vendor_name = "Focusrite",
2761 .product_name = "Saffire 6 USB",
2762 .ifnum = QUIRK_ANY_INTERFACE,
2763 .type = QUIRK_COMPOSITE,
2764 .data = (const struct snd_usb_audio_quirk[]) {
2765 {
2766 .ifnum = 0,
2767 .type = QUIRK_AUDIO_STANDARD_MIXER,
2768 },
2769 {
2770 .ifnum = 0,
2771 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2772 .data = &(const struct audioformat) {
2773 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2774 .channels = 4,
2775 .iface = 0,
2776 .altsetting = 1,
2777 .altset_idx = 1,
2778 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2779 .endpoint = 0x01,
2780 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2781 .datainterval = 1,
2782 .maxpacksize = 0x024c,
2783 .rates = SNDRV_PCM_RATE_44100 |
2784 SNDRV_PCM_RATE_48000,
2785 .rate_min = 44100,
2786 .rate_max = 48000,
2787 .nr_rates = 2,
2788 .rate_table = (unsigned int[]) {
2789 44100, 48000
2790 }
2791 }
2792 },
2793 {
2794 .ifnum = 0,
2795 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2796 .data = &(const struct audioformat) {
2797 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2798 .channels = 2,
2799 .iface = 0,
2800 .altsetting = 1,
2801 .altset_idx = 1,
2802 .attributes = 0,
2803 .endpoint = 0x82,
2804 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2805 .datainterval = 1,
2806 .maxpacksize = 0x0126,
2807 .rates = SNDRV_PCM_RATE_44100 |
2808 SNDRV_PCM_RATE_48000,
2809 .rate_min = 44100,
2810 .rate_max = 48000,
2811 .nr_rates = 2,
2812 .rate_table = (unsigned int[]) {
2813 44100, 48000
2814 }
2815 }
2816 },
2817 {
2818 .ifnum = 1,
2819 .type = QUIRK_MIDI_RAW_BYTES
2820 },
2821 {
2822 .ifnum = -1
2823 }
2824 }
2825 }
2826},
2827{
2828 USB_DEVICE(0x1235, 0x0018),
2829 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2830 .vendor_name = "Novation",
2831 .product_name = "Twitch",
2832 .ifnum = QUIRK_ANY_INTERFACE,
2833 .type = QUIRK_COMPOSITE,
2834 .data = (const struct snd_usb_audio_quirk[]) {
2835 {
2836 .ifnum = 0,
2837 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2838 .data = & (const struct audioformat) {
2839 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2840 .channels = 4,
2841 .iface = 0,
2842 .altsetting = 1,
2843 .altset_idx = 1,
2844 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2845 .endpoint = 0x01,
2846 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2847 .rates = SNDRV_PCM_RATE_44100 |
2848 SNDRV_PCM_RATE_48000,
2849 .rate_min = 44100,
2850 .rate_max = 48000,
2851 .nr_rates = 2,
2852 .rate_table = (unsigned int[]) {
2853 44100, 48000
2854 }
2855 }
2856 },
2857 {
2858 .ifnum = 1,
2859 .type = QUIRK_MIDI_RAW_BYTES
2860 },
2861 {
2862 .ifnum = -1
2863 }
2864 }
2865 }
2866},
2867{
2868 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2869 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2870 .vendor_name = "Novation",
2871 .product_name = "ReMOTE25",
2872 .ifnum = 0,
2873 .type = QUIRK_MIDI_NOVATION
2874 }
2875},
2876
2877/* Access Music devices */
2878{
2879 /* VirusTI Desktop */
2880 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2881 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2882 .ifnum = QUIRK_ANY_INTERFACE,
2883 .type = QUIRK_COMPOSITE,
2884 .data = &(const struct snd_usb_audio_quirk[]) {
2885 {
2886 .ifnum = 3,
2887 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2888 .data = &(const struct snd_usb_midi_endpoint_info) {
2889 .out_cables = 0x0003,
2890 .in_cables = 0x0003
2891 }
2892 },
2893 {
2894 .ifnum = 4,
2895 .type = QUIRK_IGNORE_INTERFACE
2896 },
2897 {
2898 .ifnum = -1
2899 }
2900 }
2901 }
2902},
2903
2904/* */
2905{
2906 /* aka. Serato Scratch Live DJ Box */
2907 USB_DEVICE(0x13e5, 0x0001),
2908 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2909 .vendor_name = "Rane",
2910 .product_name = "SL-1",
2911 .ifnum = QUIRK_NO_INTERFACE
2912 }
2913},
2914
2915/* Native Instruments MK2 series */
2916{
2917 /* Komplete Audio 6 */
2918 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2919 .idVendor = 0x17cc,
2920 .idProduct = 0x1000,
2921},
2922{
2923 /* Traktor Audio 6 */
2924 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2925 .idVendor = 0x17cc,
2926 .idProduct = 0x1010,
2927},
2928{
2929 /* Traktor Audio 10 */
2930 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2931 .idVendor = 0x17cc,
2932 .idProduct = 0x1020,
2933},
2934
2935/* QinHeng devices */
2936{
2937 USB_DEVICE(0x1a86, 0x752d),
2938 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2939 .vendor_name = "QinHeng",
2940 .product_name = "CH345",
2941 .ifnum = 1,
2942 .type = QUIRK_MIDI_CH345
2943 }
2944},
2945
2946/* KeithMcMillen Stringport */
2947{
2948 USB_DEVICE(0x1f38, 0x0001),
2949 .bInterfaceClass = USB_CLASS_AUDIO,
2950},
2951
2952/* Miditech devices */
2953{
2954 USB_DEVICE(0x4752, 0x0011),
2955 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2956 .vendor_name = "Miditech",
2957 .product_name = "Midistart-2",
2958 .ifnum = 0,
2959 .type = QUIRK_MIDI_CME
2960 }
2961},
2962
2963/* Central Music devices */
2964{
2965 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2966 USB_DEVICE(0x7104, 0x2202),
2967 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2968 .ifnum = 0,
2969 .type = QUIRK_MIDI_CME
2970 }
2971},
2972
2973/*
2974 * Auvitek au0828 devices with audio interface.
2975 * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
2976 * Please notice that some drivers are DVB only, and don't need to be
2977 * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2978 */
2979
2980#define AU0828_DEVICE(vid, pid, vname, pname) { \
2981 .idVendor = vid, \
2982 .idProduct = pid, \
2983 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
2984 USB_DEVICE_ID_MATCH_INT_CLASS | \
2985 USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
2986 .bInterfaceClass = USB_CLASS_AUDIO, \
2987 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, \
2988 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2989 .vendor_name = vname, \
2990 .product_name = pname, \
2991 .ifnum = QUIRK_ANY_INTERFACE, \
2992 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
2993 .shares_media_device = 1, \
2994 } \
2995}
2996
2997AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2998AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2999AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
3000AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
3001AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
3002AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
3003AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
3004AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
3005AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
3006AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
3007AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
3008AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
3009AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
3010AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
3011AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
3012AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
3013AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
3014
3015/* Syntek STK1160 */
3016{
3017 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
3018 USB_DEVICE_ID_MATCH_INT_CLASS |
3019 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3020 .idVendor = 0x05e1,
3021 .idProduct = 0x0408,
3022 .bInterfaceClass = USB_CLASS_AUDIO,
3023 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
3024 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3025 .vendor_name = "Syntek",
3026 .product_name = "STK1160",
3027 .ifnum = QUIRK_ANY_INTERFACE,
3028 .type = QUIRK_AUDIO_ALIGN_TRANSFER
3029 }
3030},
3031
3032/* Digidesign Mbox */
3033{
3034 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
3035 USB_DEVICE(0x0dba, 0x1000),
3036 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3037 .vendor_name = "Digidesign",
3038 .product_name = "MBox",
3039 .ifnum = QUIRK_ANY_INTERFACE,
3040 .type = QUIRK_COMPOSITE,
3041 .data = (const struct snd_usb_audio_quirk[]){
3042 {
3043 .ifnum = 0,
3044 .type = QUIRK_AUDIO_STANDARD_MIXER,
3045 },
3046 {
3047 .ifnum = 1,
3048 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3049 .data = &(const struct audioformat) {
3050 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3051 .channels = 2,
3052 .iface = 1,
3053 .altsetting = 1,
3054 .altset_idx = 1,
3055 .attributes = 0x4,
3056 .endpoint = 0x02,
3057 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3058 USB_ENDPOINT_SYNC_SYNC,
3059 .maxpacksize = 0x130,
3060 .rates = SNDRV_PCM_RATE_48000,
3061 .rate_min = 48000,
3062 .rate_max = 48000,
3063 .nr_rates = 1,
3064 .rate_table = (unsigned int[]) {
3065 48000
3066 }
3067 }
3068 },
3069 {
3070 .ifnum = 1,
3071 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3072 .data = &(const struct audioformat) {
3073 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3074 .channels = 2,
3075 .iface = 1,
3076 .altsetting = 1,
3077 .altset_idx = 1,
3078 .attributes = 0x4,
3079 .endpoint = 0x81,
3080 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3081 USB_ENDPOINT_SYNC_ASYNC,
3082 .maxpacksize = 0x130,
3083 .rates = SNDRV_PCM_RATE_48000,
3084 .rate_min = 48000,
3085 .rate_max = 48000,
3086 .nr_rates = 1,
3087 .rate_table = (unsigned int[]) {
3088 48000
3089 }
3090 }
3091 },
3092 {
3093 .ifnum = -1
3094 }
3095 }
3096 }
3097},
3098
3099/* DIGIDESIGN MBOX 2 */
3100{
3101 USB_DEVICE(0x0dba, 0x3000),
3102 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3103 .vendor_name = "Digidesign",
3104 .product_name = "Mbox 2",
3105 .ifnum = QUIRK_ANY_INTERFACE,
3106 .type = QUIRK_COMPOSITE,
3107 .data = (const struct snd_usb_audio_quirk[]) {
3108 {
3109 .ifnum = 0,
3110 .type = QUIRK_IGNORE_INTERFACE
3111 },
3112 {
3113 .ifnum = 1,
3114 .type = QUIRK_IGNORE_INTERFACE
3115 },
3116 {
3117 .ifnum = 2,
3118 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3119 .data = &(const struct audioformat) {
3120 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3121 .channels = 2,
3122 .iface = 2,
3123 .altsetting = 2,
3124 .altset_idx = 1,
3125 .attributes = 0x00,
3126 .endpoint = 0x03,
3127 .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
3128 .rates = SNDRV_PCM_RATE_48000,
3129 .rate_min = 48000,
3130 .rate_max = 48000,
3131 .nr_rates = 1,
3132 .rate_table = (unsigned int[]) {
3133 48000
3134 }
3135 }
3136 },
3137 {
3138 .ifnum = 3,
3139 .type = QUIRK_IGNORE_INTERFACE
3140 },
3141 {
3142 .ifnum = 4,
3143 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3144 .data = &(const struct audioformat) {
3145 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3146 .channels = 2,
3147 .iface = 4,
3148 .altsetting = 2,
3149 .altset_idx = 1,
3150 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3151 .endpoint = 0x85,
3152 .ep_attr = USB_ENDPOINT_SYNC_SYNC,
3153 .rates = SNDRV_PCM_RATE_48000,
3154 .rate_min = 48000,
3155 .rate_max = 48000,
3156 .nr_rates = 1,
3157 .rate_table = (unsigned int[]) {
3158 48000
3159 }
3160 }
3161 },
3162 {
3163 .ifnum = 5,
3164 .type = QUIRK_IGNORE_INTERFACE
3165 },
3166 {
3167 .ifnum = 6,
3168 .type = QUIRK_MIDI_MIDIMAN,
3169 .data = &(const struct snd_usb_midi_endpoint_info) {
3170 .out_ep = 0x02,
3171 .out_cables = 0x0001,
3172 .in_ep = 0x81,
3173 .in_interval = 0x01,
3174 .in_cables = 0x0001
3175 }
3176 },
3177 {
3178 .ifnum = -1
3179 }
3180 }
3181 }
3182},
3183{
3184 /* Tascam US122 MKII - playback-only support */
3185 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
3186 .idVendor = 0x0644,
3187 .idProduct = 0x8021,
3188 .bInterfaceClass = USB_CLASS_AUDIO,
3189 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3190 .vendor_name = "TASCAM",
3191 .product_name = "US122 MKII",
3192 .ifnum = QUIRK_ANY_INTERFACE,
3193 .type = QUIRK_COMPOSITE,
3194 .data = (const struct snd_usb_audio_quirk[]) {
3195 {
3196 .ifnum = 0,
3197 .type = QUIRK_IGNORE_INTERFACE
3198 },
3199 {
3200 .ifnum = 1,
3201 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3202 .data = &(const struct audioformat) {
3203 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3204 .channels = 2,
3205 .iface = 1,
3206 .altsetting = 1,
3207 .altset_idx = 1,
3208 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3209 .endpoint = 0x02,
3210 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3211 .rates = SNDRV_PCM_RATE_44100 |
3212 SNDRV_PCM_RATE_48000 |
3213 SNDRV_PCM_RATE_88200 |
3214 SNDRV_PCM_RATE_96000,
3215 .rate_min = 44100,
3216 .rate_max = 96000,
3217 .nr_rates = 4,
3218 .rate_table = (unsigned int[]) {
3219 44100, 48000, 88200, 96000
3220 }
3221 }
3222 },
3223 {
3224 .ifnum = -1
3225 }
3226 }
3227 }
3228},
3229
3230/* Microsoft XboxLive Headset/Xbox Communicator */
3231{
3232 USB_DEVICE(0x045e, 0x0283),
3233 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3234 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3235 .vendor_name = "Microsoft",
3236 .product_name = "XboxLive Headset/Xbox Communicator",
3237 .ifnum = QUIRK_ANY_INTERFACE,
3238 .type = QUIRK_COMPOSITE,
3239 .data = &(const struct snd_usb_audio_quirk[]) {
3240 {
3241 /* playback */
3242 .ifnum = 0,
3243 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3244 .data = &(const struct audioformat) {
3245 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3246 .channels = 1,
3247 .iface = 0,
3248 .altsetting = 0,
3249 .altset_idx = 0,
3250 .attributes = 0,
3251 .endpoint = 0x04,
3252 .ep_attr = 0x05,
3253 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3254 .rate_min = 22050,
3255 .rate_max = 22050
3256 }
3257 },
3258 {
3259 /* capture */
3260 .ifnum = 1,
3261 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3262 .data = &(const struct audioformat) {
3263 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3264 .channels = 1,
3265 .iface = 1,
3266 .altsetting = 0,
3267 .altset_idx = 0,
3268 .attributes = 0,
3269 .endpoint = 0x85,
3270 .ep_attr = 0x05,
3271 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3272 .rate_min = 16000,
3273 .rate_max = 16000
3274 }
3275 },
3276 {
3277 .ifnum = -1
3278 }
3279 }
3280 }
3281},
3282
3283/* Reloop Play */
3284{
3285 USB_DEVICE(0x200c, 0x100b),
3286 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3287 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3288 .ifnum = QUIRK_ANY_INTERFACE,
3289 .type = QUIRK_COMPOSITE,
3290 .data = &(const struct snd_usb_audio_quirk[]) {
3291 {
3292 .ifnum = 0,
3293 .type = QUIRK_AUDIO_STANDARD_MIXER,
3294 },
3295 {
3296 .ifnum = 1,
3297 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3298 .data = &(const struct audioformat) {
3299 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3300 .channels = 4,
3301 .iface = 1,
3302 .altsetting = 1,
3303 .altset_idx = 1,
3304 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3305 .endpoint = 0x01,
3306 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3307 .rates = SNDRV_PCM_RATE_44100 |
3308 SNDRV_PCM_RATE_48000,
3309 .rate_min = 44100,
3310 .rate_max = 48000,
3311 .nr_rates = 2,
3312 .rate_table = (unsigned int[]) {
3313 44100, 48000
3314 }
3315 }
3316 },
3317 {
3318 .ifnum = -1
3319 }
3320 }
3321 }
3322},
3323
3324{
3325 /*
3326 * ZOOM R16/24 in audio interface mode.
3327 * Playback requires an extra four byte LE length indicator
3328 * at the start of each isochronous packet. This quirk is
3329 * enabled in create_standard_audio_quirk().
3330 */
3331 USB_DEVICE(0x1686, 0x00dd),
3332 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3333 .ifnum = QUIRK_ANY_INTERFACE,
3334 .type = QUIRK_COMPOSITE,
3335 .data = (const struct snd_usb_audio_quirk[]) {
3336 {
3337 /* Playback */
3338 .ifnum = 1,
3339 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3340 },
3341 {
3342 /* Capture */
3343 .ifnum = 2,
3344 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3345 },
3346 {
3347 /* Midi */
3348 .ifnum = 3,
3349 .type = QUIRK_MIDI_STANDARD_INTERFACE
3350 },
3351 {
3352 .ifnum = -1
3353 },
3354 }
3355 }
3356},
3357
3358{
3359 /*
3360 * Some USB MIDI devices don't have an audio control interface,
3361 * so we have to grab MIDI streaming interfaces here.
3362 */
3363 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3364 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3365 .bInterfaceClass = USB_CLASS_AUDIO,
3366 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3367 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3368 .ifnum = QUIRK_ANY_INTERFACE,
3369 .type = QUIRK_MIDI_STANDARD_INTERFACE
3370 }
3371},
3372
3373{
3374 /*
3375 * The original product_name is "USB Sound Device", however this name
3376 * is also used by the CM106 based cards, so make it unique.
3377 */
3378 USB_DEVICE(0x0d8c, 0x0103),
3379 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3380 .product_name = "Audio Advantage MicroII",
3381 .ifnum = QUIRK_NO_INTERFACE
3382 }
3383},
3384
3385/* disabled due to regression for other devices;
3386 * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3387 */
3388#if 0
3389{
3390 /*
3391 * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3392 * ID, but it looks like the product ID actually is only for Nura.
3393 * The capture interface does not work at all (even on Windows),
3394 * and only the 48 kHz sample rate works for the playback interface.
3395 */
3396 USB_DEVICE(0x0a12, 0x1243),
3397 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3398 .ifnum = QUIRK_ANY_INTERFACE,
3399 .type = QUIRK_COMPOSITE,
3400 .data = (const struct snd_usb_audio_quirk[]) {
3401 {
3402 .ifnum = 0,
3403 .type = QUIRK_AUDIO_STANDARD_MIXER,
3404 },
3405 /* Capture */
3406 {
3407 .ifnum = 1,
3408 .type = QUIRK_IGNORE_INTERFACE,
3409 },
3410 /* Playback */
3411 {
3412 .ifnum = 2,
3413 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3414 .data = &(const struct audioformat) {
3415 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3416 .channels = 2,
3417 .iface = 2,
3418 .altsetting = 1,
3419 .altset_idx = 1,
3420 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3421 UAC_EP_CS_ATTR_SAMPLE_RATE,
3422 .endpoint = 0x03,
3423 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3424 .rates = SNDRV_PCM_RATE_48000,
3425 .rate_min = 48000,
3426 .rate_max = 48000,
3427 .nr_rates = 1,
3428 .rate_table = (unsigned int[]) {
3429 48000
3430 }
3431 }
3432 },
3433 {
3434 .ifnum = -1
3435 },
3436 }
3437 }
3438},
3439#endif /* disabled */
3440
3441{
3442 /*
3443 * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3444 * even though it advertises more. The capture interface doesn't work
3445 * even on windows.
3446 */
3447 USB_DEVICE(0x19b5, 0x0021),
3448 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3449 .ifnum = QUIRK_ANY_INTERFACE,
3450 .type = QUIRK_COMPOSITE,
3451 .data = (const struct snd_usb_audio_quirk[]) {
3452 {
3453 .ifnum = 0,
3454 .type = QUIRK_AUDIO_STANDARD_MIXER,
3455 },
3456 /* Playback */
3457 {
3458 .ifnum = 1,
3459 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3460 .data = &(const struct audioformat) {
3461 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3462 .channels = 2,
3463 .iface = 1,
3464 .altsetting = 1,
3465 .altset_idx = 1,
3466 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3467 UAC_EP_CS_ATTR_SAMPLE_RATE,
3468 .endpoint = 0x03,
3469 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3470 .rates = SNDRV_PCM_RATE_48000,
3471 .rate_min = 48000,
3472 .rate_max = 48000,
3473 .nr_rates = 1,
3474 .rate_table = (unsigned int[]) {
3475 48000
3476 }
3477 }
3478 },
3479 {
3480 .ifnum = -1
3481 },
3482 }
3483 }
3484},
3485/* Dell WD15 Dock */
3486{
3487 USB_DEVICE(0x0bda, 0x4014),
3488 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3489 .vendor_name = "Dell",
3490 .product_name = "WD15 Dock",
3491 .profile_name = "Dell-WD15-Dock",
3492 .ifnum = QUIRK_NO_INTERFACE
3493 }
3494},
3495/* Dell WD19 Dock */
3496{
3497 USB_DEVICE(0x0bda, 0x402e),
3498 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3499 .vendor_name = "Dell",
3500 .product_name = "WD19 Dock",
3501 .profile_name = "Dell-WD15-Dock",
3502 .ifnum = QUIRK_ANY_INTERFACE,
3503 .type = QUIRK_SETUP_FMT_AFTER_RESUME
3504 }
3505},
3506/* MOTU Microbook II */
3507{
3508 USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004),
3509 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3510 .vendor_name = "MOTU",
3511 .product_name = "MicroBookII",
3512 .ifnum = QUIRK_ANY_INTERFACE,
3513 .type = QUIRK_COMPOSITE,
3514 .data = (const struct snd_usb_audio_quirk[]) {
3515 {
3516 .ifnum = 0,
3517 .type = QUIRK_AUDIO_STANDARD_MIXER,
3518 },
3519 {
3520 .ifnum = 0,
3521 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3522 .data = &(const struct audioformat) {
3523 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3524 .channels = 6,
3525 .iface = 0,
3526 .altsetting = 1,
3527 .altset_idx = 1,
3528 .attributes = 0,
3529 .endpoint = 0x84,
3530 .rates = SNDRV_PCM_RATE_96000,
3531 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3532 USB_ENDPOINT_SYNC_ASYNC,
3533 .rate_min = 96000,
3534 .rate_max = 96000,
3535 .nr_rates = 1,
3536 .maxpacksize = 0x00d8,
3537 .rate_table = (unsigned int[]) {
3538 96000
3539 }
3540 }
3541 },
3542 {
3543 .ifnum = 0,
3544 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3545 .data = &(const struct audioformat) {
3546 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3547 .channels = 8,
3548 .iface = 0,
3549 .altsetting = 1,
3550 .altset_idx = 1,
3551 .attributes = 0,
3552 .endpoint = 0x03,
3553 .rates = SNDRV_PCM_RATE_96000,
3554 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3555 USB_ENDPOINT_SYNC_ASYNC,
3556 .rate_min = 96000,
3557 .rate_max = 96000,
3558 .nr_rates = 1,
3559 .maxpacksize = 0x0120,
3560 .rate_table = (unsigned int[]) {
3561 96000
3562 }
3563 }
3564 },
3565 {
3566 .ifnum = -1
3567 }
3568 }
3569 }
3570},
3571{
3572 /*
3573 * PIONEER DJ DDJ-SX3
3574 * PCM is 12 channels out, 10 channels in @ 44.1 fixed
3575 * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
3576 * The feedback for the output is the input.
3577 */
3578 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
3579 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3580 .ifnum = QUIRK_ANY_INTERFACE,
3581 .type = QUIRK_COMPOSITE,
3582 .data = (const struct snd_usb_audio_quirk[]) {
3583 {
3584 .ifnum = 0,
3585 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3586 .data = &(const struct audioformat) {
3587 .formats = SNDRV_PCM_FMTBIT_S32_LE,
3588 .channels = 12,
3589 .iface = 0,
3590 .altsetting = 1,
3591 .altset_idx = 1,
3592 .endpoint = 0x05,
3593 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3594 USB_ENDPOINT_SYNC_ASYNC,
3595 .rates = SNDRV_PCM_RATE_44100,
3596 .rate_min = 44100,
3597 .rate_max = 44100,
3598 .nr_rates = 1,
3599 .rate_table = (unsigned int[]) { 44100 }
3600 }
3601 },
3602 {
3603 .ifnum = 0,
3604 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3605 .data = &(const struct audioformat) {
3606 .formats = SNDRV_PCM_FMTBIT_S32_LE,
3607 .channels = 10,
3608 .iface = 0,
3609 .altsetting = 1,
3610 .altset_idx = 1,
3611 .endpoint = 0x86,
3612 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3613 USB_ENDPOINT_SYNC_ASYNC|
3614 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3615 .rates = SNDRV_PCM_RATE_44100,
3616 .rate_min = 44100,
3617 .rate_max = 44100,
3618 .nr_rates = 1,
3619 .rate_table = (unsigned int[]) { 44100 }
3620 }
3621 },
3622 {
3623 .ifnum = -1
3624 }
3625 }
3626 }
3627},
3628{
3629 /*
3630 * Pioneer DJ DJM-250MK2
3631 * PCM is 8 channels out @ 48 fixed (endpoints 0x01).
3632 * The output from computer to the mixer is usable.
3633 *
3634 * The input (phono or line to computer) is not working.
3635 * It should be at endpoint 0x82 and probably also 8 channels,
3636 * but it seems that it works only with Pioneer proprietary software.
3637 * Even on officially supported OS, the Audacity was unable to record
3638 * and Mixxx to recognize the control vinyls.
3639 */
3640 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3641 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3642 .ifnum = QUIRK_ANY_INTERFACE,
3643 .type = QUIRK_COMPOSITE,
3644 .data = (const struct snd_usb_audio_quirk[]) {
3645 {
3646 .ifnum = 0,
3647 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3648 .data = &(const struct audioformat) {
3649 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3650 .channels = 8, // outputs
3651 .iface = 0,
3652 .altsetting = 1,
3653 .altset_idx = 1,
3654 .endpoint = 0x01,
3655 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3656 USB_ENDPOINT_SYNC_ASYNC,
3657 .rates = SNDRV_PCM_RATE_48000,
3658 .rate_min = 48000,
3659 .rate_max = 48000,
3660 .nr_rates = 1,
3661 .rate_table = (unsigned int[]) { 48000 }
3662 }
3663 },
3664 {
3665 .ifnum = -1
3666 }
3667 }
3668 }
3669},
3670{
3671 /*
3672 * PIONEER DJ DDJ-RB
3673 * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3674 * The feedback for the output is the dummy input.
3675 */
3676 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3677 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3678 .ifnum = QUIRK_ANY_INTERFACE,
3679 .type = QUIRK_COMPOSITE,
3680 .data = (const struct snd_usb_audio_quirk[]) {
3681 {
3682 .ifnum = 0,
3683 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3684 .data = &(const struct audioformat) {
3685 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3686 .channels = 4,
3687 .iface = 0,
3688 .altsetting = 1,
3689 .altset_idx = 1,
3690 .endpoint = 0x01,
3691 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3692 USB_ENDPOINT_SYNC_ASYNC,
3693 .rates = SNDRV_PCM_RATE_44100,
3694 .rate_min = 44100,
3695 .rate_max = 44100,
3696 .nr_rates = 1,
3697 .rate_table = (unsigned int[]) { 44100 }
3698 }
3699 },
3700 {
3701 .ifnum = 0,
3702 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3703 .data = &(const struct audioformat) {
3704 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3705 .channels = 2,
3706 .iface = 0,
3707 .altsetting = 1,
3708 .altset_idx = 1,
3709 .endpoint = 0x82,
3710 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3711 USB_ENDPOINT_SYNC_ASYNC|
3712 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3713 .rates = SNDRV_PCM_RATE_44100,
3714 .rate_min = 44100,
3715 .rate_max = 44100,
3716 .nr_rates = 1,
3717 .rate_table = (unsigned int[]) { 44100 }
3718 }
3719 },
3720 {
3721 .ifnum = -1
3722 }
3723 }
3724 }
3725},
3726
3727#define ALC1220_VB_DESKTOP(vend, prod) { \
3728 USB_DEVICE(vend, prod), \
3729 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
3730 .vendor_name = "Realtek", \
3731 .product_name = "ALC1220-VB-DT", \
3732 .profile_name = "Realtek-ALC1220-VB-Desktop", \
3733 .ifnum = QUIRK_NO_INTERFACE \
3734 } \
3735}
3736ALC1220_VB_DESKTOP(0x0414, 0xa002), /* Gigabyte TRX40 Aorus Pro WiFi */
3737ALC1220_VB_DESKTOP(0x0db0, 0x0d64), /* MSI TRX40 Creator */
3738ALC1220_VB_DESKTOP(0x0db0, 0x543d), /* MSI TRX40 */
3739ALC1220_VB_DESKTOP(0x26ce, 0x0a01), /* Asrock TRX40 Creator */
3740#undef ALC1220_VB_DESKTOP
3741
3742/* Two entries for Gigabyte TRX40 Aorus Master:
3743 * TRX40 Aorus Master has two USB-audio devices, one for the front headphone
3744 * with ESS SABRE9218 DAC chip, while another for the rest I/O (the rear
3745 * panel and the front mic) with Realtek ALC1220-VB.
3746 * Here we provide two distinct names for making UCM profiles easier.
3747 */
3748{
3749 USB_DEVICE(0x0414, 0xa000),
3750 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3751 .vendor_name = "Gigabyte",
3752 .product_name = "Aorus Master Front Headphone",
3753 .profile_name = "Gigabyte-Aorus-Master-Front-Headphone",
3754 .ifnum = QUIRK_NO_INTERFACE
3755 }
3756},
3757{
3758 USB_DEVICE(0x0414, 0xa001),
3759 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3760 .vendor_name = "Gigabyte",
3761 .product_name = "Aorus Master Main Audio",
3762 .profile_name = "Gigabyte-Aorus-Master-Main-Audio",
3763 .ifnum = QUIRK_NO_INTERFACE
3764 }
3765},
3766
3767/*
3768 * MacroSilicon MS2100/MS2106 based AV capture cards
3769 *
3770 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3771 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if
3772 * they pretend to be 96kHz mono as a workaround for stereo being broken
3773 * by that...
3774 *
3775 * They also have an issue with initial stream alignment that causes the
3776 * channels to be swapped and out of phase, which is dealt with in quirks.c.
3777 */
3778{
3779 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
3780 USB_DEVICE_ID_MATCH_INT_CLASS |
3781 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3782 .idVendor = 0x534d,
3783 .idProduct = 0x0021,
3784 .bInterfaceClass = USB_CLASS_AUDIO,
3785 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
3786 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3787 .vendor_name = "MacroSilicon",
3788 .product_name = "MS210x",
3789 .ifnum = QUIRK_ANY_INTERFACE,
3790 .type = QUIRK_COMPOSITE,
3791 .data = &(const struct snd_usb_audio_quirk[]) {
3792 {
3793 .ifnum = 2,
3794 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
3795 },
3796 {
3797 .ifnum = 2,
3798 .type = QUIRK_AUDIO_STANDARD_MIXER,
3799 },
3800 {
3801 .ifnum = 3,
3802 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3803 .data = &(const struct audioformat) {
3804 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3805 .channels = 2,
3806 .iface = 3,
3807 .altsetting = 1,
3808 .altset_idx = 1,
3809 .attributes = 0,
3810 .endpoint = 0x82,
3811 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3812 USB_ENDPOINT_SYNC_ASYNC,
3813 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3814 .rate_min = 48000,
3815 .rate_max = 48000,
3816 }
3817 },
3818 {
3819 .ifnum = -1
3820 }
3821 }
3822 }
3823},
3824
3825/*
3826 * MacroSilicon MS2109 based HDMI capture cards
3827 *
3828 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3829 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if
3830 * they pretend to be 96kHz mono as a workaround for stereo being broken
3831 * by that...
3832 *
3833 * They also have an issue with initial stream alignment that causes the
3834 * channels to be swapped and out of phase, which is dealt with in quirks.c.
3835 */
3836{
3837 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
3838 USB_DEVICE_ID_MATCH_INT_CLASS |
3839 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3840 .idVendor = 0x534d,
3841 .idProduct = 0x2109,
3842 .bInterfaceClass = USB_CLASS_AUDIO,
3843 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
3844 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3845 .vendor_name = "MacroSilicon",
3846 .product_name = "MS2109",
3847 .ifnum = QUIRK_ANY_INTERFACE,
3848 .type = QUIRK_COMPOSITE,
3849 .data = &(const struct snd_usb_audio_quirk[]) {
3850 {
3851 .ifnum = 2,
3852 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
3853 },
3854 {
3855 .ifnum = 2,
3856 .type = QUIRK_AUDIO_STANDARD_MIXER,
3857 },
3858 {
3859 .ifnum = 3,
3860 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3861 .data = &(const struct audioformat) {
3862 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3863 .channels = 2,
3864 .iface = 3,
3865 .altsetting = 1,
3866 .altset_idx = 1,
3867 .attributes = 0,
3868 .endpoint = 0x82,
3869 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3870 USB_ENDPOINT_SYNC_ASYNC,
3871 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3872 .rate_min = 48000,
3873 .rate_max = 48000,
3874 }
3875 },
3876 {
3877 .ifnum = -1
3878 }
3879 }
3880 }
3881},
3882{
3883 /*
3884 * Sennheiser GSP670
3885 * Change order of interfaces loaded
3886 */
3887 USB_DEVICE(0x1395, 0x0300),
3888 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3889 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3890 .ifnum = QUIRK_ANY_INTERFACE,
3891 .type = QUIRK_COMPOSITE,
3892 .data = &(const struct snd_usb_audio_quirk[]) {
3893 // Communication
3894 {
3895 .ifnum = 3,
3896 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3897 },
3898 // Recording
3899 {
3900 .ifnum = 4,
3901 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3902 },
3903 // Main
3904 {
3905 .ifnum = 1,
3906 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3907 },
3908 {
3909 .ifnum = -1
3910 }
3911 }
3912 }
3913},
3914{
3915 /* Advanced modes of the Mythware XA001AU.
3916 * For the standard mode, Mythware XA001AU has ID ffad:a001
3917 */
3918 USB_DEVICE_VENDOR_SPEC(0xffad, 0xa001),
3919 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3920 .vendor_name = "Mythware",
3921 .product_name = "XA001AU",
3922 .ifnum = QUIRK_ANY_INTERFACE,
3923 .type = QUIRK_COMPOSITE,
3924 .data = (const struct snd_usb_audio_quirk[]) {
3925 {
3926 .ifnum = 0,
3927 .type = QUIRK_IGNORE_INTERFACE,
3928 },
3929 {
3930 .ifnum = 1,
3931 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3932 },
3933 {
3934 .ifnum = 2,
3935 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3936 },
3937 {
3938 .ifnum = -1
3939 }
3940 }
3941 }
3942},
3943
3944#undef USB_DEVICE_VENDOR_SPEC