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