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