TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / hafnium / third_party / linux / 157378f43faad830e4aa3815bde5fa9f9a9f5be6 / . / sound / usb / quirks-table.h
blob: aabd3a10ec5b46981f0edd2e3996e79779bea655 [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{
2032 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2033 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2034 /* .vendor_name = "M-Audio", */
2035 /* .product_name = "Fast Track C400", */
2036 .ifnum = QUIRK_ANY_INTERFACE,
2037 .type = QUIRK_COMPOSITE,
2038 .data = &(const struct snd_usb_audio_quirk[]) {
2039 {
2040 .ifnum = 1,
2041 .type = QUIRK_AUDIO_STANDARD_MIXER,
2042 },
2043 /* Playback */
2044 {
2045 .ifnum = 2,
2046 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2047 .data = &(const struct audioformat) {
2048 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2049 .channels = 6,
2050 .iface = 2,
2051 .altsetting = 1,
2052 .altset_idx = 1,
2053 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2054 .endpoint = 0x01,
2055 .ep_attr = 0x09,
2056 .rates = SNDRV_PCM_RATE_44100 |
2057 SNDRV_PCM_RATE_48000 |
2058 SNDRV_PCM_RATE_88200 |
2059 SNDRV_PCM_RATE_96000,
2060 .rate_min = 44100,
2061 .rate_max = 96000,
2062 .nr_rates = 4,
2063 .rate_table = (unsigned int[]) {
2064 44100, 48000, 88200, 96000
2065 },
2066 .clock = 0x80,
2067 }
2068 },
2069 /* Capture */
2070 {
2071 .ifnum = 3,
2072 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2073 .data = &(const struct audioformat) {
2074 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2075 .channels = 4,
2076 .iface = 3,
2077 .altsetting = 1,
2078 .altset_idx = 1,
2079 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2080 .endpoint = 0x81,
2081 .ep_attr = 0x05,
2082 .rates = SNDRV_PCM_RATE_44100 |
2083 SNDRV_PCM_RATE_48000 |
2084 SNDRV_PCM_RATE_88200 |
2085 SNDRV_PCM_RATE_96000,
2086 .rate_min = 44100,
2087 .rate_max = 96000,
2088 .nr_rates = 4,
2089 .rate_table = (unsigned int[]) {
2090 44100, 48000, 88200, 96000
2091 },
2092 .clock = 0x80,
2093 }
2094 },
2095 /* MIDI */
2096 {
2097 .ifnum = -1 /* Interface = 4 */
2098 }
2099 }
2100 }
2101},
2102{
2103 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2104 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2105 /* .vendor_name = "M-Audio", */
2106 /* .product_name = "Fast Track C600", */
2107 .ifnum = QUIRK_ANY_INTERFACE,
2108 .type = QUIRK_COMPOSITE,
2109 .data = &(const struct snd_usb_audio_quirk[]) {
2110 {
2111 .ifnum = 1,
2112 .type = QUIRK_AUDIO_STANDARD_MIXER,
2113 },
2114 /* Playback */
2115 {
2116 .ifnum = 2,
2117 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2118 .data = &(const struct audioformat) {
2119 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2120 .channels = 8,
2121 .iface = 2,
2122 .altsetting = 1,
2123 .altset_idx = 1,
2124 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2125 .endpoint = 0x01,
2126 .ep_attr = 0x09,
2127 .rates = SNDRV_PCM_RATE_44100 |
2128 SNDRV_PCM_RATE_48000 |
2129 SNDRV_PCM_RATE_88200 |
2130 SNDRV_PCM_RATE_96000,
2131 .rate_min = 44100,
2132 .rate_max = 96000,
2133 .nr_rates = 4,
2134 .rate_table = (unsigned int[]) {
2135 44100, 48000, 88200, 96000
2136 },
2137 .clock = 0x80,
2138 }
2139 },
2140 /* Capture */
2141 {
2142 .ifnum = 3,
2143 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2144 .data = &(const struct audioformat) {
2145 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2146 .channels = 6,
2147 .iface = 3,
2148 .altsetting = 1,
2149 .altset_idx = 1,
2150 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2151 .endpoint = 0x81,
2152 .ep_attr = 0x05,
2153 .rates = SNDRV_PCM_RATE_44100 |
2154 SNDRV_PCM_RATE_48000 |
2155 SNDRV_PCM_RATE_88200 |
2156 SNDRV_PCM_RATE_96000,
2157 .rate_min = 44100,
2158 .rate_max = 96000,
2159 .nr_rates = 4,
2160 .rate_table = (unsigned int[]) {
2161 44100, 48000, 88200, 96000
2162 },
2163 .clock = 0x80,
2164 }
2165 },
2166 /* MIDI */
2167 {
2168 .ifnum = -1 /* Interface = 4 */
2169 }
2170 }
2171 }
2172},
2173{
2174 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2175 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2176 /* .vendor_name = "M-Audio", */
2177 /* .product_name = "Fast Track Ultra", */
2178 .ifnum = QUIRK_ANY_INTERFACE,
2179 .type = QUIRK_COMPOSITE,
2180 .data = & (const struct snd_usb_audio_quirk[]) {
2181 {
2182 .ifnum = 0,
2183 .type = QUIRK_AUDIO_STANDARD_MIXER,
2184 },
2185 {
2186 .ifnum = 1,
2187 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2188 .data = & (const struct audioformat) {
2189 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2190 .channels = 8,
2191 .iface = 1,
2192 .altsetting = 1,
2193 .altset_idx = 1,
2194 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2195 .endpoint = 0x01,
2196 .ep_attr = 0x09,
2197 .rates = SNDRV_PCM_RATE_44100 |
2198 SNDRV_PCM_RATE_48000 |
2199 SNDRV_PCM_RATE_88200 |
2200 SNDRV_PCM_RATE_96000,
2201 .rate_min = 44100,
2202 .rate_max = 96000,
2203 .nr_rates = 4,
2204 .rate_table = (unsigned int[]) {
2205 44100, 48000, 88200, 96000
2206 }
2207 }
2208 },
2209 {
2210 .ifnum = 2,
2211 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2212 .data = & (const struct audioformat) {
2213 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2214 .channels = 8,
2215 .iface = 2,
2216 .altsetting = 1,
2217 .altset_idx = 1,
2218 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2219 .endpoint = 0x81,
2220 .ep_attr = 0x05,
2221 .rates = SNDRV_PCM_RATE_44100 |
2222 SNDRV_PCM_RATE_48000 |
2223 SNDRV_PCM_RATE_88200 |
2224 SNDRV_PCM_RATE_96000,
2225 .rate_min = 44100,
2226 .rate_max = 96000,
2227 .nr_rates = 4,
2228 .rate_table = (unsigned int[]) {
2229 44100, 48000, 88200, 96000
2230 }
2231 }
2232 },
2233 /* interface 3 (MIDI) is standard compliant */
2234 {
2235 .ifnum = -1
2236 }
2237 }
2238 }
2239},
2240{
2241 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2242 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2243 /* .vendor_name = "M-Audio", */
2244 /* .product_name = "Fast Track Ultra 8R", */
2245 .ifnum = QUIRK_ANY_INTERFACE,
2246 .type = QUIRK_COMPOSITE,
2247 .data = & (const struct snd_usb_audio_quirk[]) {
2248 {
2249 .ifnum = 0,
2250 .type = QUIRK_AUDIO_STANDARD_MIXER,
2251 },
2252 {
2253 .ifnum = 1,
2254 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2255 .data = & (const struct audioformat) {
2256 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2257 .channels = 8,
2258 .iface = 1,
2259 .altsetting = 1,
2260 .altset_idx = 1,
2261 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2262 .endpoint = 0x01,
2263 .ep_attr = 0x09,
2264 .rates = SNDRV_PCM_RATE_44100 |
2265 SNDRV_PCM_RATE_48000 |
2266 SNDRV_PCM_RATE_88200 |
2267 SNDRV_PCM_RATE_96000,
2268 .rate_min = 44100,
2269 .rate_max = 96000,
2270 .nr_rates = 4,
2271 .rate_table = (unsigned int[]) {
2272 44100, 48000, 88200, 96000
2273 }
2274 }
2275 },
2276 {
2277 .ifnum = 2,
2278 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2279 .data = & (const struct audioformat) {
2280 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2281 .channels = 8,
2282 .iface = 2,
2283 .altsetting = 1,
2284 .altset_idx = 1,
2285 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2286 .endpoint = 0x81,
2287 .ep_attr = 0x05,
2288 .rates = SNDRV_PCM_RATE_44100 |
2289 SNDRV_PCM_RATE_48000 |
2290 SNDRV_PCM_RATE_88200 |
2291 SNDRV_PCM_RATE_96000,
2292 .rate_min = 44100,
2293 .rate_max = 96000,
2294 .nr_rates = 4,
2295 .rate_table = (unsigned int[]) {
2296 44100, 48000, 88200, 96000
2297 }
2298 }
2299 },
2300 /* interface 3 (MIDI) is standard compliant */
2301 {
2302 .ifnum = -1
2303 }
2304 }
2305 }
2306},
2307
2308/* Casio devices */
2309{
2310 USB_DEVICE(0x07cf, 0x6801),
2311 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2312 .vendor_name = "Casio",
2313 .product_name = "PL-40R",
2314 .ifnum = 0,
2315 .type = QUIRK_MIDI_YAMAHA
2316 }
2317},
2318{
2319 /* this ID is used by several devices without a product ID */
2320 USB_DEVICE(0x07cf, 0x6802),
2321 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2322 .vendor_name = "Casio",
2323 .product_name = "Keyboard",
2324 .ifnum = 0,
2325 .type = QUIRK_MIDI_YAMAHA
2326 }
2327},
2328
2329/* Mark of the Unicorn devices */
2330{
2331 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2332 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2333 USB_DEVICE_ID_MATCH_PRODUCT |
2334 USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2335 .idVendor = 0x07fd,
2336 .idProduct = 0x0001,
2337 .bDeviceSubClass = 2,
2338 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2339 .vendor_name = "MOTU",
2340 .product_name = "Fastlane",
2341 .ifnum = QUIRK_ANY_INTERFACE,
2342 .type = QUIRK_COMPOSITE,
2343 .data = & (const struct snd_usb_audio_quirk[]) {
2344 {
2345 .ifnum = 0,
2346 .type = QUIRK_MIDI_RAW_BYTES
2347 },
2348 {
2349 .ifnum = 1,
2350 .type = QUIRK_IGNORE_INTERFACE
2351 },
2352 {
2353 .ifnum = -1
2354 }
2355 }
2356 }
2357},
2358
2359/* Emagic devices */
2360{
2361 USB_DEVICE(0x086a, 0x0001),
2362 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2363 .vendor_name = "Emagic",
David Brazdil0f672f62019-12-10 10:32:29 +0000[diff] [blame]2364 .product_name = "Unitor8",
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2365 .ifnum = 2,
2366 .type = QUIRK_MIDI_EMAGIC,
2367 .data = & (const struct snd_usb_midi_endpoint_info) {
2368 .out_cables = 0x80ff,
2369 .in_cables = 0x80ff
2370 }
2371 }
2372},
2373{
2374 USB_DEVICE(0x086a, 0x0002),
2375 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2376 .vendor_name = "Emagic",
2377 /* .product_name = "AMT8", */
2378 .ifnum = 2,
2379 .type = QUIRK_MIDI_EMAGIC,
2380 .data = & (const struct snd_usb_midi_endpoint_info) {
2381 .out_cables = 0x80ff,
2382 .in_cables = 0x80ff
2383 }
2384 }
2385},
2386{
2387 USB_DEVICE(0x086a, 0x0003),
2388 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2389 .vendor_name = "Emagic",
2390 /* .product_name = "MT4", */
2391 .ifnum = 2,
2392 .type = QUIRK_MIDI_EMAGIC,
2393 .data = & (const struct snd_usb_midi_endpoint_info) {
2394 .out_cables = 0x800f,
2395 .in_cables = 0x8003
2396 }
2397 }
2398},
2399
2400/* KORG devices */
2401{
2402 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2403 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2404 .vendor_name = "KORG, Inc.",
2405 /* .product_name = "PANDORA PX5D", */
2406 .ifnum = 3,
2407 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2408 }
2409},
2410
2411{
2412 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2413 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2414 .vendor_name = "KORG, Inc.",
2415 /* .product_name = "ToneLab ST", */
2416 .ifnum = 3,
2417 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2418 }
2419},
2420
Olivier Deprez0e641232021-09-23 10:07:05 +0200[diff] [blame]2421{
2422 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0204),
2423 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2424 .vendor_name = "KORG, Inc.",
2425 /* .product_name = "ToneLab EX", */
2426 .ifnum = 3,
2427 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2428 }
2429},
2430
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2431/* AKAI devices */
2432{
2433 USB_DEVICE(0x09e8, 0x0062),
2434 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2435 .vendor_name = "AKAI",
2436 .product_name = "MPD16",
2437 .ifnum = 0,
2438 .type = QUIRK_MIDI_AKAI,
2439 }
2440},
2441
2442{
2443 /* Akai MPC Element */
2444 USB_DEVICE(0x09e8, 0x0021),
2445 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2446 .ifnum = QUIRK_ANY_INTERFACE,
2447 .type = QUIRK_COMPOSITE,
2448 .data = & (const struct snd_usb_audio_quirk[]) {
2449 {
2450 .ifnum = 0,
2451 .type = QUIRK_IGNORE_INTERFACE
2452 },
2453 {
2454 .ifnum = 1,
2455 .type = QUIRK_MIDI_STANDARD_INTERFACE
2456 },
2457 {
2458 .ifnum = -1
2459 }
2460 }
2461 }
2462},
2463
2464/* Steinberg devices */
2465{
2466 /* Steinberg MI2 */
2467 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2468 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2469 .ifnum = QUIRK_ANY_INTERFACE,
2470 .type = QUIRK_COMPOSITE,
2471 .data = & (const struct snd_usb_audio_quirk[]) {
2472 {
2473 .ifnum = 0,
2474 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2475 },
2476 {
2477 .ifnum = 1,
2478 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2479 },
2480 {
2481 .ifnum = 2,
2482 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2483 },
2484 {
2485 .ifnum = 3,
2486 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2487 .data = &(const struct snd_usb_midi_endpoint_info) {
2488 .out_cables = 0x0001,
2489 .in_cables = 0x0001
2490 }
2491 },
2492 {
2493 .ifnum = -1
2494 }
2495 }
2496 }
2497},
2498{
2499 /* Steinberg MI4 */
2500 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2501 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2502 .ifnum = QUIRK_ANY_INTERFACE,
2503 .type = QUIRK_COMPOSITE,
2504 .data = & (const struct snd_usb_audio_quirk[]) {
2505 {
2506 .ifnum = 0,
2507 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2508 },
2509 {
2510 .ifnum = 1,
2511 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2512 },
2513 {
2514 .ifnum = 2,
2515 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2516 },
2517 {
2518 .ifnum = 3,
2519 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2520 .data = &(const struct snd_usb_midi_endpoint_info) {
2521 .out_cables = 0x0001,
2522 .in_cables = 0x0001
2523 }
2524 },
2525 {
2526 .ifnum = -1
2527 }
2528 }
2529 }
2530},
2531
2532/* TerraTec devices */
2533{
2534 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2535 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2536 .vendor_name = "TerraTec",
2537 .product_name = "PHASE 26",
2538 .ifnum = 3,
2539 .type = QUIRK_MIDI_STANDARD_INTERFACE
2540 }
2541},
2542{
2543 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2544 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2545 .vendor_name = "TerraTec",
2546 .product_name = "PHASE 26",
2547 .ifnum = 3,
2548 .type = QUIRK_MIDI_STANDARD_INTERFACE
2549 }
2550},
2551{
2552 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2553 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2554 .vendor_name = "TerraTec",
2555 .product_name = "PHASE 26",
2556 .ifnum = 3,
2557 .type = QUIRK_MIDI_STANDARD_INTERFACE
2558 }
2559},
2560{
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2561 USB_DEVICE(0x0ccd, 0x0035),
2562 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2563 .vendor_name = "Miditech",
2564 .product_name = "Play'n Roll",
2565 .ifnum = 0,
2566 .type = QUIRK_MIDI_CME
2567 }
2568},
2569
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2570/* Novation EMS devices */
2571{
2572 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2573 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2574 .vendor_name = "Novation",
2575 .product_name = "ReMOTE Audio/XStation",
2576 .ifnum = 4,
2577 .type = QUIRK_MIDI_NOVATION
2578 }
2579},
2580{
2581 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2582 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2583 .vendor_name = "Novation",
2584 .product_name = "Speedio",
2585 .ifnum = 3,
2586 .type = QUIRK_MIDI_NOVATION
2587 }
2588},
2589{
2590 USB_DEVICE(0x1235, 0x000a),
2591 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2592 /* .vendor_name = "Novation", */
2593 /* .product_name = "Nocturn", */
2594 .ifnum = 0,
2595 .type = QUIRK_MIDI_RAW_BYTES
2596 }
2597},
2598{
2599 USB_DEVICE(0x1235, 0x000e),
2600 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2601 /* .vendor_name = "Novation", */
2602 /* .product_name = "Launchpad", */
2603 .ifnum = 0,
2604 .type = QUIRK_MIDI_RAW_BYTES
2605 }
2606},
2607{
2608 USB_DEVICE(0x1235, 0x0010),
2609 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2610 .vendor_name = "Focusrite",
2611 .product_name = "Saffire 6 USB",
2612 .ifnum = QUIRK_ANY_INTERFACE,
2613 .type = QUIRK_COMPOSITE,
2614 .data = (const struct snd_usb_audio_quirk[]) {
2615 {
2616 .ifnum = 0,
Olivier Deprez0e641232021-09-23 10:07:05 +0200[diff] [blame]2617 .type = QUIRK_AUDIO_STANDARD_MIXER,
2618 },
2619 {
2620 .ifnum = 0,
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2621 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2622 .data = &(const struct audioformat) {
2623 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2624 .channels = 4,
2625 .iface = 0,
2626 .altsetting = 1,
2627 .altset_idx = 1,
2628 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2629 .endpoint = 0x01,
2630 .ep_attr = USB_ENDPOINT_XFER_ISOC,
Olivier Deprez0e641232021-09-23 10:07:05 +0200[diff] [blame]2631 .datainterval = 1,
2632 .maxpacksize = 0x024c,
2633 .rates = SNDRV_PCM_RATE_44100 |
2634 SNDRV_PCM_RATE_48000,
2635 .rate_min = 44100,
2636 .rate_max = 48000,
2637 .nr_rates = 2,
2638 .rate_table = (unsigned int[]) {
2639 44100, 48000
2640 }
2641 }
2642 },
2643 {
2644 .ifnum = 0,
2645 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2646 .data = &(const struct audioformat) {
2647 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2648 .channels = 2,
2649 .iface = 0,
2650 .altsetting = 1,
2651 .altset_idx = 1,
2652 .attributes = 0,
2653 .endpoint = 0x82,
2654 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2655 .datainterval = 1,
2656 .maxpacksize = 0x0126,
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2657 .rates = SNDRV_PCM_RATE_44100 |
2658 SNDRV_PCM_RATE_48000,
2659 .rate_min = 44100,
2660 .rate_max = 48000,
2661 .nr_rates = 2,
2662 .rate_table = (unsigned int[]) {
2663 44100, 48000
2664 }
2665 }
2666 },
2667 {
2668 .ifnum = 1,
2669 .type = QUIRK_MIDI_RAW_BYTES
2670 },
2671 {
2672 .ifnum = -1
2673 }
2674 }
2675 }
2676},
2677{
2678 USB_DEVICE(0x1235, 0x0018),
2679 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2680 .vendor_name = "Novation",
2681 .product_name = "Twitch",
2682 .ifnum = QUIRK_ANY_INTERFACE,
2683 .type = QUIRK_COMPOSITE,
2684 .data = (const struct snd_usb_audio_quirk[]) {
2685 {
2686 .ifnum = 0,
2687 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2688 .data = & (const struct audioformat) {
2689 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2690 .channels = 4,
2691 .iface = 0,
2692 .altsetting = 1,
2693 .altset_idx = 1,
2694 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2695 .endpoint = 0x01,
2696 .ep_attr = USB_ENDPOINT_XFER_ISOC,
2697 .rates = SNDRV_PCM_RATE_44100 |
2698 SNDRV_PCM_RATE_48000,
2699 .rate_min = 44100,
2700 .rate_max = 48000,
2701 .nr_rates = 2,
2702 .rate_table = (unsigned int[]) {
2703 44100, 48000
2704 }
2705 }
2706 },
2707 {
2708 .ifnum = 1,
2709 .type = QUIRK_MIDI_RAW_BYTES
2710 },
2711 {
2712 .ifnum = -1
2713 }
2714 }
2715 }
2716},
2717{
2718 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2719 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2720 .vendor_name = "Novation",
2721 .product_name = "ReMOTE25",
2722 .ifnum = 0,
2723 .type = QUIRK_MIDI_NOVATION
2724 }
2725},
2726
2727/* Access Music devices */
2728{
2729 /* VirusTI Desktop */
2730 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2731 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2732 .ifnum = QUIRK_ANY_INTERFACE,
2733 .type = QUIRK_COMPOSITE,
2734 .data = &(const struct snd_usb_audio_quirk[]) {
2735 {
2736 .ifnum = 3,
2737 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2738 .data = &(const struct snd_usb_midi_endpoint_info) {
2739 .out_cables = 0x0003,
2740 .in_cables = 0x0003
2741 }
2742 },
2743 {
2744 .ifnum = 4,
2745 .type = QUIRK_IGNORE_INTERFACE
2746 },
2747 {
2748 .ifnum = -1
2749 }
2750 }
2751 }
2752},
2753
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]2754/* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2755{
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]2756 USB_DEVICE(0x17aa, 0x1046),
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2757 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]2758 .ifnum = QUIRK_ANY_INTERFACE,
2759 .type = QUIRK_SETUP_DISABLE_AUTOSUSPEND
2760 }
2761},
2762/* Lenovo ThinkStation P620 Internal Speaker + Front Headset */
2763{
2764 USB_DEVICE(0x17aa, 0x104d),
2765 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2766 .ifnum = QUIRK_ANY_INTERFACE,
2767 .type = QUIRK_SETUP_DISABLE_AUTOSUSPEND
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2768 }
2769},
2770
2771/* Native Instruments MK2 series */
2772{
2773 /* Komplete Audio 6 */
2774 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2775 .idVendor = 0x17cc,
2776 .idProduct = 0x1000,
2777},
2778{
2779 /* Traktor Audio 6 */
2780 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2781 .idVendor = 0x17cc,
2782 .idProduct = 0x1010,
2783},
2784{
2785 /* Traktor Audio 10 */
2786 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2787 .idVendor = 0x17cc,
2788 .idProduct = 0x1020,
2789},
2790
2791/* QinHeng devices */
2792{
2793 USB_DEVICE(0x1a86, 0x752d),
2794 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2795 .vendor_name = "QinHeng",
2796 .product_name = "CH345",
2797 .ifnum = 1,
2798 .type = QUIRK_MIDI_CH345
2799 }
2800},
2801
2802/* KeithMcMillen Stringport */
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]2803{ USB_DEVICE(0x1f38, 0x0001) }, /* FIXME: should be more restrictive matching */
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2804
2805/* Miditech devices */
2806{
2807 USB_DEVICE(0x4752, 0x0011),
2808 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2809 .vendor_name = "Miditech",
2810 .product_name = "Midistart-2",
2811 .ifnum = 0,
2812 .type = QUIRK_MIDI_CME
2813 }
2814},
2815
2816/* Central Music devices */
2817{
2818 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2819 USB_DEVICE(0x7104, 0x2202),
2820 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2821 .ifnum = 0,
2822 .type = QUIRK_MIDI_CME
2823 }
2824},
2825
2826/*
2827 * Auvitek au0828 devices with audio interface.
2828 * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
2829 * Please notice that some drivers are DVB only, and don't need to be
2830 * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2831 */
2832
2833#define AU0828_DEVICE(vid, pid, vname, pname) { \
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]2834 USB_AUDIO_DEVICE(vid, pid), \
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2835 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2836 .vendor_name = vname, \
2837 .product_name = pname, \
2838 .ifnum = QUIRK_ANY_INTERFACE, \
2839 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
David Brazdil0f672f62019-12-10 10:32:29 +0000[diff] [blame]2840 .shares_media_device = 1, \
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2841 } \
2842}
2843
2844AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2845AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2846AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
2847AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
2848AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
2849AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
2850AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
2851AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
2852AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
2853AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
2854AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
2855AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
2856AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
2857AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
2858AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
2859AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
2860AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
2861
2862/* Syntek STK1160 */
2863{
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]2864 USB_AUDIO_DEVICE(0x05e1, 0x0408),
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]2865 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2866 .vendor_name = "Syntek",
2867 .product_name = "STK1160",
2868 .ifnum = QUIRK_ANY_INTERFACE,
2869 .type = QUIRK_AUDIO_ALIGN_TRANSFER
2870 }
2871},
2872
2873/* Digidesign Mbox */
2874{
2875 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2876 USB_DEVICE(0x0dba, 0x1000),
2877 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2878 .vendor_name = "Digidesign",
2879 .product_name = "MBox",
2880 .ifnum = QUIRK_ANY_INTERFACE,
2881 .type = QUIRK_COMPOSITE,
2882 .data = (const struct snd_usb_audio_quirk[]){
2883 {
2884 .ifnum = 0,
2885 .type = QUIRK_AUDIO_STANDARD_MIXER,
2886 },
2887 {
2888 .ifnum = 1,
2889 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2890 .data = &(const struct audioformat) {
2891 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2892 .channels = 2,
2893 .iface = 1,
2894 .altsetting = 1,
2895 .altset_idx = 1,
2896 .attributes = 0x4,
2897 .endpoint = 0x02,
2898 .ep_attr = USB_ENDPOINT_XFER_ISOC |
2899 USB_ENDPOINT_SYNC_SYNC,
2900 .maxpacksize = 0x130,
2901 .rates = SNDRV_PCM_RATE_48000,
2902 .rate_min = 48000,
2903 .rate_max = 48000,
2904 .nr_rates = 1,
2905 .rate_table = (unsigned int[]) {
2906 48000
2907 }
2908 }
2909 },
2910 {
2911 .ifnum = 1,
2912 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2913 .data = &(const struct audioformat) {
2914 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2915 .channels = 2,
2916 .iface = 1,
2917 .altsetting = 1,
2918 .altset_idx = 1,
2919 .attributes = 0x4,
2920 .endpoint = 0x81,
2921 .ep_attr = USB_ENDPOINT_XFER_ISOC |
2922 USB_ENDPOINT_SYNC_ASYNC,
2923 .maxpacksize = 0x130,
2924 .rates = SNDRV_PCM_RATE_48000,
2925 .rate_min = 48000,
2926 .rate_max = 48000,
2927 .nr_rates = 1,
2928 .rate_table = (unsigned int[]) {
2929 48000
2930 }
2931 }
2932 },
2933 {
2934 .ifnum = -1
2935 }
2936 }
2937 }
2938},
2939
2940/* DIGIDESIGN MBOX 2 */
2941{
2942 USB_DEVICE(0x0dba, 0x3000),
2943 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2944 .vendor_name = "Digidesign",
2945 .product_name = "Mbox 2",
2946 .ifnum = QUIRK_ANY_INTERFACE,
2947 .type = QUIRK_COMPOSITE,
2948 .data = (const struct snd_usb_audio_quirk[]) {
2949 {
2950 .ifnum = 0,
2951 .type = QUIRK_IGNORE_INTERFACE
2952 },
2953 {
2954 .ifnum = 1,
2955 .type = QUIRK_IGNORE_INTERFACE
2956 },
2957 {
2958 .ifnum = 2,
2959 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2960 .data = &(const struct audioformat) {
2961 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2962 .channels = 2,
2963 .iface = 2,
2964 .altsetting = 2,
2965 .altset_idx = 1,
2966 .attributes = 0x00,
2967 .endpoint = 0x03,
2968 .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
2969 .rates = SNDRV_PCM_RATE_48000,
2970 .rate_min = 48000,
2971 .rate_max = 48000,
2972 .nr_rates = 1,
2973 .rate_table = (unsigned int[]) {
2974 48000
2975 }
2976 }
2977 },
2978 {
2979 .ifnum = 3,
2980 .type = QUIRK_IGNORE_INTERFACE
2981 },
2982 {
2983 .ifnum = 4,
2984 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2985 .data = &(const struct audioformat) {
2986 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2987 .channels = 2,
2988 .iface = 4,
2989 .altsetting = 2,
2990 .altset_idx = 1,
2991 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2992 .endpoint = 0x85,
2993 .ep_attr = USB_ENDPOINT_SYNC_SYNC,
2994 .rates = SNDRV_PCM_RATE_48000,
2995 .rate_min = 48000,
2996 .rate_max = 48000,
2997 .nr_rates = 1,
2998 .rate_table = (unsigned int[]) {
2999 48000
3000 }
3001 }
3002 },
3003 {
3004 .ifnum = 5,
3005 .type = QUIRK_IGNORE_INTERFACE
3006 },
3007 {
3008 .ifnum = 6,
3009 .type = QUIRK_MIDI_MIDIMAN,
3010 .data = &(const struct snd_usb_midi_endpoint_info) {
3011 .out_ep = 0x02,
3012 .out_cables = 0x0001,
3013 .in_ep = 0x81,
3014 .in_interval = 0x01,
3015 .in_cables = 0x0001
3016 }
3017 },
3018 {
3019 .ifnum = -1
3020 }
3021 }
3022 }
3023},
3024{
3025 /* Tascam US122 MKII - playback-only support */
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]3026 USB_DEVICE_VENDOR_SPEC(0x0644, 0x8021),
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]3027 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3028 .vendor_name = "TASCAM",
3029 .product_name = "US122 MKII",
3030 .ifnum = QUIRK_ANY_INTERFACE,
3031 .type = QUIRK_COMPOSITE,
3032 .data = (const struct snd_usb_audio_quirk[]) {
3033 {
3034 .ifnum = 0,
3035 .type = QUIRK_IGNORE_INTERFACE
3036 },
3037 {
3038 .ifnum = 1,
3039 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3040 .data = &(const struct audioformat) {
3041 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3042 .channels = 2,
3043 .iface = 1,
3044 .altsetting = 1,
3045 .altset_idx = 1,
3046 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3047 .endpoint = 0x02,
3048 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3049 .rates = SNDRV_PCM_RATE_44100 |
3050 SNDRV_PCM_RATE_48000 |
3051 SNDRV_PCM_RATE_88200 |
3052 SNDRV_PCM_RATE_96000,
3053 .rate_min = 44100,
3054 .rate_max = 96000,
3055 .nr_rates = 4,
3056 .rate_table = (unsigned int[]) {
3057 44100, 48000, 88200, 96000
3058 }
3059 }
3060 },
3061 {
3062 .ifnum = -1
3063 }
3064 }
3065 }
3066},
3067
3068/* Microsoft XboxLive Headset/Xbox Communicator */
3069{
3070 USB_DEVICE(0x045e, 0x0283),
3071 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3072 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3073 .vendor_name = "Microsoft",
3074 .product_name = "XboxLive Headset/Xbox Communicator",
3075 .ifnum = QUIRK_ANY_INTERFACE,
3076 .type = QUIRK_COMPOSITE,
3077 .data = &(const struct snd_usb_audio_quirk[]) {
3078 {
3079 /* playback */
3080 .ifnum = 0,
3081 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3082 .data = &(const struct audioformat) {
3083 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3084 .channels = 1,
3085 .iface = 0,
3086 .altsetting = 0,
3087 .altset_idx = 0,
3088 .attributes = 0,
3089 .endpoint = 0x04,
3090 .ep_attr = 0x05,
3091 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3092 .rate_min = 22050,
3093 .rate_max = 22050
3094 }
3095 },
3096 {
3097 /* capture */
3098 .ifnum = 1,
3099 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3100 .data = &(const struct audioformat) {
3101 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3102 .channels = 1,
3103 .iface = 1,
3104 .altsetting = 0,
3105 .altset_idx = 0,
3106 .attributes = 0,
3107 .endpoint = 0x85,
3108 .ep_attr = 0x05,
3109 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3110 .rate_min = 16000,
3111 .rate_max = 16000
3112 }
3113 },
3114 {
3115 .ifnum = -1
3116 }
3117 }
3118 }
3119},
3120
3121/* Reloop Play */
3122{
3123 USB_DEVICE(0x200c, 0x100b),
3124 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3125 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3126 .ifnum = QUIRK_ANY_INTERFACE,
3127 .type = QUIRK_COMPOSITE,
3128 .data = &(const struct snd_usb_audio_quirk[]) {
3129 {
3130 .ifnum = 0,
3131 .type = QUIRK_AUDIO_STANDARD_MIXER,
3132 },
3133 {
3134 .ifnum = 1,
3135 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3136 .data = &(const struct audioformat) {
3137 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3138 .channels = 4,
3139 .iface = 1,
3140 .altsetting = 1,
3141 .altset_idx = 1,
3142 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3143 .endpoint = 0x01,
3144 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3145 .rates = SNDRV_PCM_RATE_44100 |
3146 SNDRV_PCM_RATE_48000,
3147 .rate_min = 44100,
3148 .rate_max = 48000,
3149 .nr_rates = 2,
3150 .rate_table = (unsigned int[]) {
3151 44100, 48000
3152 }
3153 }
3154 },
3155 {
3156 .ifnum = -1
3157 }
3158 }
3159 }
3160},
3161
3162{
3163 /*
3164 * ZOOM R16/24 in audio interface mode.
3165 * Playback requires an extra four byte LE length indicator
3166 * at the start of each isochronous packet. This quirk is
3167 * enabled in create_standard_audio_quirk().
3168 */
3169 USB_DEVICE(0x1686, 0x00dd),
3170 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3171 .ifnum = QUIRK_ANY_INTERFACE,
3172 .type = QUIRK_COMPOSITE,
3173 .data = (const struct snd_usb_audio_quirk[]) {
3174 {
3175 /* Playback */
3176 .ifnum = 1,
3177 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3178 },
3179 {
3180 /* Capture */
3181 .ifnum = 2,
3182 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3183 },
3184 {
3185 /* Midi */
3186 .ifnum = 3,
3187 .type = QUIRK_MIDI_STANDARD_INTERFACE
3188 },
3189 {
3190 .ifnum = -1
3191 },
3192 }
3193 }
3194},
3195
3196{
3197 /*
3198 * Some USB MIDI devices don't have an audio control interface,
3199 * so we have to grab MIDI streaming interfaces here.
3200 */
3201 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3202 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3203 .bInterfaceClass = USB_CLASS_AUDIO,
3204 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3205 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3206 .ifnum = QUIRK_ANY_INTERFACE,
3207 .type = QUIRK_MIDI_STANDARD_INTERFACE
3208 }
3209},
3210
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]3211/* disabled due to regression for other devices;
3212 * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3213 */
3214#if 0
3215{
3216 /*
3217 * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3218 * ID, but it looks like the product ID actually is only for Nura.
3219 * The capture interface does not work at all (even on Windows),
3220 * and only the 48 kHz sample rate works for the playback interface.
3221 */
3222 USB_DEVICE(0x0a12, 0x1243),
3223 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3224 .ifnum = QUIRK_ANY_INTERFACE,
3225 .type = QUIRK_COMPOSITE,
3226 .data = (const struct snd_usb_audio_quirk[]) {
3227 {
3228 .ifnum = 0,
3229 .type = QUIRK_AUDIO_STANDARD_MIXER,
3230 },
3231 /* Capture */
3232 {
3233 .ifnum = 1,
3234 .type = QUIRK_IGNORE_INTERFACE,
3235 },
3236 /* Playback */
3237 {
3238 .ifnum = 2,
3239 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3240 .data = &(const struct audioformat) {
3241 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3242 .channels = 2,
3243 .iface = 2,
3244 .altsetting = 1,
3245 .altset_idx = 1,
3246 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3247 UAC_EP_CS_ATTR_SAMPLE_RATE,
3248 .endpoint = 0x03,
3249 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3250 .rates = SNDRV_PCM_RATE_48000,
3251 .rate_min = 48000,
3252 .rate_max = 48000,
3253 .nr_rates = 1,
3254 .rate_table = (unsigned int[]) {
3255 48000
3256 }
3257 }
3258 },
David Brazdil0f672f62019-12-10 10:32:29 +0000[diff] [blame]3259 {
3260 .ifnum = -1
3261 },
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]3262 }
3263 }
3264},
3265#endif /* disabled */
3266
3267{
3268 /*
3269 * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3270 * even though it advertises more. The capture interface doesn't work
3271 * even on windows.
3272 */
3273 USB_DEVICE(0x19b5, 0x0021),
3274 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3275 .ifnum = QUIRK_ANY_INTERFACE,
3276 .type = QUIRK_COMPOSITE,
3277 .data = (const struct snd_usb_audio_quirk[]) {
3278 {
3279 .ifnum = 0,
3280 .type = QUIRK_AUDIO_STANDARD_MIXER,
3281 },
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]3282 /* Playback */
3283 {
David Brazdil0f672f62019-12-10 10:32:29 +0000[diff] [blame]3284 .ifnum = 1,
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]3285 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3286 .data = &(const struct audioformat) {
3287 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3288 .channels = 2,
David Brazdil0f672f62019-12-10 10:32:29 +0000[diff] [blame]3289 .iface = 1,
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]3290 .altsetting = 1,
3291 .altset_idx = 1,
3292 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3293 UAC_EP_CS_ATTR_SAMPLE_RATE,
3294 .endpoint = 0x03,
3295 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3296 .rates = SNDRV_PCM_RATE_48000,
3297 .rate_min = 48000,
3298 .rate_max = 48000,
3299 .nr_rates = 1,
3300 .rate_table = (unsigned int[]) {
3301 48000
3302 }
3303 }
3304 },
David Brazdil0f672f62019-12-10 10:32:29 +0000[diff] [blame]3305 {
3306 .ifnum = -1
3307 },
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]3308 }
3309 }
3310},
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]3311/* Dell WD19 Dock */
3312{
3313 USB_DEVICE(0x0bda, 0x402e),
3314 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
Olivier Deprez0e641232021-09-23 10:07:05 +0200[diff] [blame]3315 .ifnum = QUIRK_ANY_INTERFACE,
3316 .type = QUIRK_SETUP_FMT_AFTER_RESUME
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]3317 }
3318},
David Brazdil0f672f62019-12-10 10:32:29 +0000[diff] [blame]3319/* MOTU Microbook II */
3320{
Olivier Deprez0e641232021-09-23 10:07:05 +0200[diff] [blame]3321 USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004),
David Brazdil0f672f62019-12-10 10:32:29 +0000[diff] [blame]3322 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3323 .vendor_name = "MOTU",
3324 .product_name = "MicroBookII",
3325 .ifnum = QUIRK_ANY_INTERFACE,
3326 .type = QUIRK_COMPOSITE,
3327 .data = (const struct snd_usb_audio_quirk[]) {
3328 {
3329 .ifnum = 0,
3330 .type = QUIRK_AUDIO_STANDARD_MIXER,
3331 },
3332 {
3333 .ifnum = 0,
3334 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3335 .data = &(const struct audioformat) {
3336 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3337 .channels = 6,
3338 .iface = 0,
3339 .altsetting = 1,
3340 .altset_idx = 1,
3341 .attributes = 0,
3342 .endpoint = 0x84,
3343 .rates = SNDRV_PCM_RATE_96000,
3344 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3345 USB_ENDPOINT_SYNC_ASYNC,
3346 .rate_min = 96000,
3347 .rate_max = 96000,
3348 .nr_rates = 1,
3349 .maxpacksize = 0x00d8,
3350 .rate_table = (unsigned int[]) {
3351 96000
3352 }
3353 }
3354 },
3355 {
3356 .ifnum = 0,
3357 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3358 .data = &(const struct audioformat) {
3359 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3360 .channels = 8,
3361 .iface = 0,
3362 .altsetting = 1,
3363 .altset_idx = 1,
3364 .attributes = 0,
3365 .endpoint = 0x03,
3366 .rates = SNDRV_PCM_RATE_96000,
3367 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3368 USB_ENDPOINT_SYNC_ASYNC,
3369 .rate_min = 96000,
3370 .rate_max = 96000,
3371 .nr_rates = 1,
3372 .maxpacksize = 0x0120,
3373 .rate_table = (unsigned int[]) {
3374 96000
3375 }
3376 }
3377 },
3378 {
3379 .ifnum = -1
3380 }
3381 }
3382 }
3383},
3384{
3385 /*
3386 * PIONEER DJ DDJ-SX3
3387 * PCM is 12 channels out, 10 channels in @ 44.1 fixed
3388 * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
3389 * The feedback for the output is the input.
3390 */
3391 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
3392 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3393 .ifnum = QUIRK_ANY_INTERFACE,
3394 .type = QUIRK_COMPOSITE,
3395 .data = (const struct snd_usb_audio_quirk[]) {
3396 {
3397 .ifnum = 0,
3398 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3399 .data = &(const struct audioformat) {
3400 .formats = SNDRV_PCM_FMTBIT_S32_LE,
3401 .channels = 12,
3402 .iface = 0,
3403 .altsetting = 1,
3404 .altset_idx = 1,
3405 .endpoint = 0x05,
3406 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3407 USB_ENDPOINT_SYNC_ASYNC,
3408 .rates = SNDRV_PCM_RATE_44100,
3409 .rate_min = 44100,
3410 .rate_max = 44100,
3411 .nr_rates = 1,
3412 .rate_table = (unsigned int[]) { 44100 }
3413 }
3414 },
3415 {
3416 .ifnum = 0,
3417 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3418 .data = &(const struct audioformat) {
3419 .formats = SNDRV_PCM_FMTBIT_S32_LE,
3420 .channels = 10,
3421 .iface = 0,
3422 .altsetting = 1,
3423 .altset_idx = 1,
3424 .endpoint = 0x86,
3425 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3426 USB_ENDPOINT_SYNC_ASYNC|
3427 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3428 .rates = SNDRV_PCM_RATE_44100,
3429 .rate_min = 44100,
3430 .rate_max = 44100,
3431 .nr_rates = 1,
3432 .rate_table = (unsigned int[]) { 44100 }
3433 }
3434 },
3435 {
3436 .ifnum = -1
3437 }
3438 }
3439 }
3440},
Olivier Deprez0e641232021-09-23 10:07:05 +0200[diff] [blame]3441{
3442 /*
3443 * Pioneer DJ DJM-250MK2
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]3444 * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
3445 * and 8 channels in @ 48 fixed (endpoint 0x82).
Olivier Deprez0e641232021-09-23 10:07:05 +0200[diff] [blame]3446 *
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]3447 * Both playback and recording is working, even simultaneously.
3448 *
3449 * Playback channels could be mapped to:
3450 * - CH1
3451 * - CH2
3452 * - AUX
3453 *
3454 * Recording channels could be mapped to:
3455 * - Post CH1 Fader
3456 * - Post CH2 Fader
3457 * - Cross Fader A
3458 * - Cross Fader B
3459 * - MIC
3460 * - AUX
3461 * - REC OUT
3462 *
3463 * There is remaining problem with recording directly from PHONO/LINE.
3464 * If we map a channel to:
3465 * - CH1 Control Tone PHONO
3466 * - CH1 Control Tone LINE
3467 * - CH2 Control Tone PHONO
3468 * - CH2 Control Tone LINE
3469 * it is silent.
3470 * There is no signal even on other operating systems with official drivers.
3471 * The signal appears only when a supported application is started.
3472 * This needs to be investigated yet...
3473 * (there is quite a lot communication on the USB in both directions)
3474 *
3475 * In current version this mixer could be used for playback
3476 * and for recording from vinyls (through Post CH* Fader)
3477 * but not for DVS (Digital Vinyl Systems) like in Mixxx.
Olivier Deprez0e641232021-09-23 10:07:05 +0200[diff] [blame]3478 */
3479 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3480 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3481 .ifnum = QUIRK_ANY_INTERFACE,
3482 .type = QUIRK_COMPOSITE,
3483 .data = (const struct snd_usb_audio_quirk[]) {
3484 {
3485 .ifnum = 0,
3486 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3487 .data = &(const struct audioformat) {
3488 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3489 .channels = 8, // outputs
3490 .iface = 0,
3491 .altsetting = 1,
3492 .altset_idx = 1,
3493 .endpoint = 0x01,
3494 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3495 USB_ENDPOINT_SYNC_ASYNC,
3496 .rates = SNDRV_PCM_RATE_48000,
3497 .rate_min = 48000,
3498 .rate_max = 48000,
3499 .nr_rates = 1,
3500 .rate_table = (unsigned int[]) { 48000 }
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]3501 }
3502 },
3503 {
3504 .ifnum = 0,
3505 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3506 .data = &(const struct audioformat) {
3507 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3508 .channels = 8, // inputs
3509 .iface = 0,
3510 .altsetting = 1,
3511 .altset_idx = 1,
3512 .endpoint = 0x82,
3513 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3514 USB_ENDPOINT_SYNC_ASYNC|
3515 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3516 .rates = SNDRV_PCM_RATE_48000,
3517 .rate_min = 48000,
3518 .rate_max = 48000,
3519 .nr_rates = 1,
3520 .rate_table = (unsigned int[]) { 48000 }
Olivier Deprez0e641232021-09-23 10:07:05 +0200[diff] [blame]3521 }
3522 },
3523 {
3524 .ifnum = -1
3525 }
3526 }
3527 }
3528},
3529{
3530 /*
3531 * PIONEER DJ DDJ-RB
3532 * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3533 * The feedback for the output is the dummy input.
3534 */
3535 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3536 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3537 .ifnum = QUIRK_ANY_INTERFACE,
3538 .type = QUIRK_COMPOSITE,
3539 .data = (const struct snd_usb_audio_quirk[]) {
3540 {
3541 .ifnum = 0,
3542 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3543 .data = &(const struct audioformat) {
3544 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3545 .channels = 4,
3546 .iface = 0,
3547 .altsetting = 1,
3548 .altset_idx = 1,
3549 .endpoint = 0x01,
3550 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3551 USB_ENDPOINT_SYNC_ASYNC,
3552 .rates = SNDRV_PCM_RATE_44100,
3553 .rate_min = 44100,
3554 .rate_max = 44100,
3555 .nr_rates = 1,
3556 .rate_table = (unsigned int[]) { 44100 }
3557 }
3558 },
3559 {
3560 .ifnum = 0,
3561 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3562 .data = &(const struct audioformat) {
3563 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3564 .channels = 2,
3565 .iface = 0,
3566 .altsetting = 1,
3567 .altset_idx = 1,
3568 .endpoint = 0x82,
3569 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3570 USB_ENDPOINT_SYNC_ASYNC|
3571 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3572 .rates = SNDRV_PCM_RATE_44100,
3573 .rate_min = 44100,
3574 .rate_max = 44100,
3575 .nr_rates = 1,
3576 .rate_table = (unsigned int[]) { 44100 }
3577 }
3578 },
3579 {
3580 .ifnum = -1
3581 }
3582 }
3583 }
3584},
3585
Olivier Deprez0e641232021-09-23 10:07:05 +0200[diff] [blame]3586{
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]3587 /*
3588 * Pioneer DJ DJM-900NXS2
3589 * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE
3590 */
3591 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a),
3592 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3593 .ifnum = QUIRK_ANY_INTERFACE,
3594 .type = QUIRK_COMPOSITE,
3595 .data = (const struct snd_usb_audio_quirk[]) {
3596 {
3597 .ifnum = 0,
3598 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3599 .data = &(const struct audioformat) {
3600 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3601 .channels = 10,
3602 .iface = 0,
3603 .altsetting = 1,
3604 .altset_idx = 1,
3605 .endpoint = 0x01,
3606 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3607 USB_ENDPOINT_SYNC_ASYNC,
3608 .rates = SNDRV_PCM_RATE_44100|
3609 SNDRV_PCM_RATE_48000|
3610 SNDRV_PCM_RATE_96000,
3611 .rate_min = 44100,
3612 .rate_max = 96000,
3613 .nr_rates = 3,
3614 .rate_table = (unsigned int[]) {
3615 44100, 48000, 96000
3616 }
3617 }
3618 },
3619 {
3620 .ifnum = 0,
3621 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3622 .data = &(const struct audioformat) {
3623 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3624 .channels = 12,
3625 .iface = 0,
3626 .altsetting = 1,
3627 .altset_idx = 1,
3628 .endpoint = 0x82,
3629 .ep_attr = USB_ENDPOINT_XFER_ISOC|
3630 USB_ENDPOINT_SYNC_ASYNC|
3631 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3632 .rates = SNDRV_PCM_RATE_44100|
3633 SNDRV_PCM_RATE_48000|
3634 SNDRV_PCM_RATE_96000,
3635 .rate_min = 44100,
3636 .rate_max = 96000,
3637 .nr_rates = 3,
3638 .rate_table = (unsigned int[]) {
3639 44100, 48000, 96000
3640 }
3641 }
3642 },
3643 {
3644 .ifnum = -1
3645 }
3646 }
Olivier Deprez0e641232021-09-23 10:07:05 +0200[diff] [blame]3647 }
3648},
3649
3650/*
3651 * MacroSilicon MS2109 based HDMI capture cards
3652 *
3653 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3654 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if
3655 * they pretend to be 96kHz mono as a workaround for stereo being broken
3656 * by that...
3657 *
3658 * They also have an issue with initial stream alignment that causes the
3659 * channels to be swapped and out of phase, which is dealt with in quirks.c.
3660 */
3661{
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]3662 USB_AUDIO_DEVICE(0x534d, 0x2109),
Olivier Deprez0e641232021-09-23 10:07:05 +0200[diff] [blame]3663 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3664 .vendor_name = "MacroSilicon",
3665 .product_name = "MS2109",
3666 .ifnum = QUIRK_ANY_INTERFACE,
3667 .type = QUIRK_COMPOSITE,
3668 .data = &(const struct snd_usb_audio_quirk[]) {
3669 {
3670 .ifnum = 2,
3671 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
3672 },
3673 {
3674 .ifnum = 2,
3675 .type = QUIRK_AUDIO_STANDARD_MIXER,
3676 },
3677 {
3678 .ifnum = 3,
3679 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3680 .data = &(const struct audioformat) {
3681 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3682 .channels = 2,
3683 .iface = 3,
3684 .altsetting = 1,
3685 .altset_idx = 1,
3686 .attributes = 0,
3687 .endpoint = 0x82,
3688 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3689 USB_ENDPOINT_SYNC_ASYNC,
3690 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3691 .rate_min = 48000,
3692 .rate_max = 48000,
3693 }
3694 },
3695 {
3696 .ifnum = -1
3697 }
3698 }
3699 }
3700},
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]3701{
3702 /*
3703 * Sennheiser GSP670
3704 * Change order of interfaces loaded
3705 */
3706 USB_DEVICE(0x1395, 0x0300),
3707 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3708 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3709 .ifnum = QUIRK_ANY_INTERFACE,
3710 .type = QUIRK_COMPOSITE,
3711 .data = &(const struct snd_usb_audio_quirk[]) {
3712 // Communication
3713 {
3714 .ifnum = 3,
3715 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3716 },
3717 // Recording
3718 {
3719 .ifnum = 4,
3720 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3721 },
3722 // Main
3723 {
3724 .ifnum = 1,
3725 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3726 },
3727 {
3728 .ifnum = -1
3729 }
3730 }
3731 }
3732},
Andrew Scullb4b6d4a2019-01-02 15:54:55 +0000[diff] [blame]3733
3734#undef USB_DEVICE_VENDOR_SPEC
Olivier Deprez157378f2022-04-04 15:47:50 +0200[diff] [blame^]3735#undef USB_AUDIO_DEVICE