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