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