?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: rtl8192u: remove redundant assignment to pointer crypt
[linux/fpc-iii.git] / sound / usb / quirks-table.h
blobe918ce34602723137b90f0f608b42be213c909c1
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 /*
2761 * Focusrite Scarlett Solo 2nd generation
2762 * Reports that playback should use Synch: Synchronous
2763 * while still providing a feedback endpoint. Synchronous causes
2764 * snapping on some sample rates.
2765 * Force it to use Synch: Asynchronous.
2766 */
2767 USB_DEVICE(0x1235, 0x8205),
2768 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2769 .ifnum = QUIRK_ANY_INTERFACE,
2770 .type = QUIRK_COMPOSITE,
2771 .data = (const struct snd_usb_audio_quirk[]) {
2772 {
2773 .ifnum = 1,
2774 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2775 .data = & (const struct audioformat) {
2776 .formats = SNDRV_PCM_FMTBIT_S32_LE,
2777 .channels = 2,
2778 .iface = 1,
2779 .altsetting = 1,
2780 .altset_idx = 1,
2781 .attributes = 0,
2782 .endpoint = 0x01,
2783 .ep_attr = USB_ENDPOINT_XFER_ISOC |
2784 USB_ENDPOINT_SYNC_ASYNC,
2785 .protocol = UAC_VERSION_2,
2786 .rates = SNDRV_PCM_RATE_44100 |
2787 SNDRV_PCM_RATE_48000 |
2788 SNDRV_PCM_RATE_88200 |
2789 SNDRV_PCM_RATE_96000 |
2790 SNDRV_PCM_RATE_176400 |
2791 SNDRV_PCM_RATE_192000,
2792 .rate_min = 44100,
2793 .rate_max = 192000,
2794 .nr_rates = 6,
2795 .rate_table = (unsigned int[]) {
2796 44100, 48000, 88200,
2797 96000, 176400, 192000
2798 },
2799 .clock = 41
2800 }
2801 },
2802 {
2803 .ifnum = 2,
2804 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2805 .data = & (const struct audioformat) {
2806 .formats = SNDRV_PCM_FMTBIT_S32_LE,
2807 .channels = 2,
2808 .iface = 2,
2809 .altsetting = 1,
2810 .altset_idx = 1,
2811 .attributes = 0,
2812 .endpoint = 0x82,
2813 .ep_attr = USB_ENDPOINT_XFER_ISOC |
2814 USB_ENDPOINT_SYNC_ASYNC |
2815 USB_ENDPOINT_USAGE_IMPLICIT_FB,
2816 .protocol = UAC_VERSION_2,
2817 .rates = SNDRV_PCM_RATE_44100 |
2818 SNDRV_PCM_RATE_48000 |
2819 SNDRV_PCM_RATE_88200 |
2820 SNDRV_PCM_RATE_96000 |
2821 SNDRV_PCM_RATE_176400 |
2822 SNDRV_PCM_RATE_192000,
2823 .rate_min = 44100,
2824 .rate_max = 192000,
2825 .nr_rates = 6,
2826 .rate_table = (unsigned int[]) {
2827 44100, 48000, 88200,
2828 96000, 176400, 192000
2829 },
2830 .clock = 41
2831 }
2832 },
2833 {
2834 .ifnum = 3,
2835 .type = QUIRK_IGNORE_INTERFACE
2836 },
2837 {
2838 .ifnum = -1
2839 }
2840 }
2841 }
2842 },
2843
2844 /* Access Music devices */
2845 {
2846 /* VirusTI Desktop */
2847 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2848 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2849 .ifnum = QUIRK_ANY_INTERFACE,
2850 .type = QUIRK_COMPOSITE,
2851 .data = &(const struct snd_usb_audio_quirk[]) {
2852 {
2853 .ifnum = 3,
2854 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2855 .data = &(const struct snd_usb_midi_endpoint_info) {
2856 .out_cables = 0x0003,
2857 .in_cables = 0x0003
2858 }
2859 },
2860 {
2861 .ifnum = 4,
2862 .type = QUIRK_IGNORE_INTERFACE
2863 },
2864 {
2865 .ifnum = -1
2866 }
2867 }
2868 }
2869 },
2870
2871 /* */
2872 {
2873 /* aka. Serato Scratch Live DJ Box */
2874 USB_DEVICE(0x13e5, 0x0001),
2875 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2876 .vendor_name = "Rane",
2877 .product_name = "SL-1",
2878 .ifnum = QUIRK_NO_INTERFACE
2879 }
2880 },
2881
2882 /* Native Instruments MK2 series */
2883 {
2884 /* Komplete Audio 6 */
2885 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2886 .idVendor = 0x17cc,
2887 .idProduct = 0x1000,
2888 },
2889 {
2890 /* Traktor Audio 6 */
2891 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2892 .idVendor = 0x17cc,
2893 .idProduct = 0x1010,
2894 },
2895 {
2896 /* Traktor Audio 10 */
2897 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2898 .idVendor = 0x17cc,
2899 .idProduct = 0x1020,
2900 },
2901
2902 /* QinHeng devices */
2903 {
2904 USB_DEVICE(0x1a86, 0x752d),
2905 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2906 .vendor_name = "QinHeng",
2907 .product_name = "CH345",
2908 .ifnum = 1,
2909 .type = QUIRK_MIDI_CH345
2910 }
2911 },
2912
2913 /* KeithMcMillen Stringport */
2914 {
2915 USB_DEVICE(0x1f38, 0x0001),
2916 .bInterfaceClass = USB_CLASS_AUDIO,
2917 },
2918
2919 /* Miditech devices */
2920 {
2921 USB_DEVICE(0x4752, 0x0011),
2922 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2923 .vendor_name = "Miditech",
2924 .product_name = "Midistart-2",
2925 .ifnum = 0,
2926 .type = QUIRK_MIDI_CME
2927 }
2928 },
2929
2930 /* Central Music devices */
2931 {
2932 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2933 USB_DEVICE(0x7104, 0x2202),
2934 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2935 .ifnum = 0,
2936 .type = QUIRK_MIDI_CME
2937 }
2938 },
2939
2940 /*
2941 * Auvitek au0828 devices with audio interface.
2942 * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
2943 * Please notice that some drivers are DVB only, and don't need to be
2944 * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2945 */
2946
2947 #define AU0828_DEVICE(vid, pid, vname, pname) { \
2948 .idVendor = vid, \
2949 .idProduct = pid, \
2950 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
2951 USB_DEVICE_ID_MATCH_INT_CLASS | \
2952 USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
2953 .bInterfaceClass = USB_CLASS_AUDIO, \
2954 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, \
2955 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2956 .vendor_name = vname, \
2957 .product_name = pname, \
2958 .ifnum = QUIRK_ANY_INTERFACE, \
2959 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
2960 .shares_media_device = 1, \
2961 } \
2962 }
2963
2964 AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2965 AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2966 AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
2967 AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
2968 AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
2969 AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
2970 AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
2971 AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
2972 AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
2973 AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
2974 AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
2975 AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
2976 AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
2977 AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
2978 AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
2979 AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
2980 AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
2981
2982 /* Syntek STK1160 */
2983 {
2984 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2985 USB_DEVICE_ID_MATCH_INT_CLASS |
2986 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2987 .idVendor = 0x05e1,
2988 .idProduct = 0x0408,
2989 .bInterfaceClass = USB_CLASS_AUDIO,
2990 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2991 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2992 .vendor_name = "Syntek",
2993 .product_name = "STK1160",
2994 .ifnum = QUIRK_ANY_INTERFACE,
2995 .type = QUIRK_AUDIO_ALIGN_TRANSFER
2996 }
2997 },
2998
2999 /* Digidesign Mbox */
3000 {
3001 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
3002 USB_DEVICE(0x0dba, 0x1000),
3003 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3004 .vendor_name = "Digidesign",
3005 .product_name = "MBox",
3006 .ifnum = QUIRK_ANY_INTERFACE,
3007 .type = QUIRK_COMPOSITE,
3008 .data = (const struct snd_usb_audio_quirk[]){
3009 {
3010 .ifnum = 0,
3011 .type = QUIRK_AUDIO_STANDARD_MIXER,
3012 },
3013 {
3014 .ifnum = 1,
3015 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3016 .data = &(const struct audioformat) {
3017 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3018 .channels = 2,
3019 .iface = 1,
3020 .altsetting = 1,
3021 .altset_idx = 1,
3022 .attributes = 0x4,
3023 .endpoint = 0x02,
3024 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3025 USB_ENDPOINT_SYNC_SYNC,
3026 .maxpacksize = 0x130,
3027 .rates = SNDRV_PCM_RATE_48000,
3028 .rate_min = 48000,
3029 .rate_max = 48000,
3030 .nr_rates = 1,
3031 .rate_table = (unsigned int[]) {
3032 48000
3033 }
3034 }
3035 },
3036 {
3037 .ifnum = 1,
3038 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3039 .data = &(const struct audioformat) {
3040 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3041 .channels = 2,
3042 .iface = 1,
3043 .altsetting = 1,
3044 .altset_idx = 1,
3045 .attributes = 0x4,
3046 .endpoint = 0x81,
3047 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3048 USB_ENDPOINT_SYNC_ASYNC,
3049 .maxpacksize = 0x130,
3050 .rates = SNDRV_PCM_RATE_48000,
3051 .rate_min = 48000,
3052 .rate_max = 48000,
3053 .nr_rates = 1,
3054 .rate_table = (unsigned int[]) {
3055 48000
3056 }
3057 }
3058 },
3059 {
3060 .ifnum = -1
3061 }
3062 }
3063 }
3064 },
3065
3066 /* DIGIDESIGN MBOX 2 */
3067 {
3068 USB_DEVICE(0x0dba, 0x3000),
3069 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3070 .vendor_name = "Digidesign",
3071 .product_name = "Mbox 2",
3072 .ifnum = QUIRK_ANY_INTERFACE,
3073 .type = QUIRK_COMPOSITE,
3074 .data = (const struct snd_usb_audio_quirk[]) {
3075 {
3076 .ifnum = 0,
3077 .type = QUIRK_IGNORE_INTERFACE
3078 },
3079 {
3080 .ifnum = 1,
3081 .type = QUIRK_IGNORE_INTERFACE
3082 },
3083 {
3084 .ifnum = 2,
3085 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3086 .data = &(const struct audioformat) {
3087 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3088 .channels = 2,
3089 .iface = 2,
3090 .altsetting = 2,
3091 .altset_idx = 1,
3092 .attributes = 0x00,
3093 .endpoint = 0x03,
3094 .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
3095 .rates = SNDRV_PCM_RATE_48000,
3096 .rate_min = 48000,
3097 .rate_max = 48000,
3098 .nr_rates = 1,
3099 .rate_table = (unsigned int[]) {
3100 48000
3101 }
3102 }
3103 },
3104 {
3105 .ifnum = 3,
3106 .type = QUIRK_IGNORE_INTERFACE
3107 },
3108 {
3109 .ifnum = 4,
3110 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3111 .data = &(const struct audioformat) {
3112 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3113 .channels = 2,
3114 .iface = 4,
3115 .altsetting = 2,
3116 .altset_idx = 1,
3117 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3118 .endpoint = 0x85,
3119 .ep_attr = USB_ENDPOINT_SYNC_SYNC,
3120 .rates = SNDRV_PCM_RATE_48000,
3121 .rate_min = 48000,
3122 .rate_max = 48000,
3123 .nr_rates = 1,
3124 .rate_table = (unsigned int[]) {
3125 48000
3126 }
3127 }
3128 },
3129 {
3130 .ifnum = 5,
3131 .type = QUIRK_IGNORE_INTERFACE
3132 },
3133 {
3134 .ifnum = 6,
3135 .type = QUIRK_MIDI_MIDIMAN,
3136 .data = &(const struct snd_usb_midi_endpoint_info) {
3137 .out_ep = 0x02,
3138 .out_cables = 0x0001,
3139 .in_ep = 0x81,
3140 .in_interval = 0x01,
3141 .in_cables = 0x0001
3142 }
3143 },
3144 {
3145 .ifnum = -1
3146 }
3147 }
3148 }
3149 },
3150 {
3151 /* Tascam US122 MKII - playback-only support */
3152 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
3153 .idVendor = 0x0644,
3154 .idProduct = 0x8021,
3155 .bInterfaceClass = USB_CLASS_AUDIO,
3156 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3157 .vendor_name = "TASCAM",
3158 .product_name = "US122 MKII",
3159 .ifnum = QUIRK_ANY_INTERFACE,
3160 .type = QUIRK_COMPOSITE,
3161 .data = (const struct snd_usb_audio_quirk[]) {
3162 {
3163 .ifnum = 0,
3164 .type = QUIRK_IGNORE_INTERFACE
3165 },
3166 {
3167 .ifnum = 1,
3168 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3169 .data = &(const struct audioformat) {
3170 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3171 .channels = 2,
3172 .iface = 1,
3173 .altsetting = 1,
3174 .altset_idx = 1,
3175 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3176 .endpoint = 0x02,
3177 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3178 .rates = SNDRV_PCM_RATE_44100 |
3179 SNDRV_PCM_RATE_48000 |
3180 SNDRV_PCM_RATE_88200 |
3181 SNDRV_PCM_RATE_96000,
3182 .rate_min = 44100,
3183 .rate_max = 96000,
3184 .nr_rates = 4,
3185 .rate_table = (unsigned int[]) {
3186 44100, 48000, 88200, 96000
3187 }
3188 }
3189 },
3190 {
3191 .ifnum = -1
3192 }
3193 }
3194 }
3195 },
3196
3197 /* Microsoft XboxLive Headset/Xbox Communicator */
3198 {
3199 USB_DEVICE(0x045e, 0x0283),
3200 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3201 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3202 .vendor_name = "Microsoft",
3203 .product_name = "XboxLive Headset/Xbox Communicator",
3204 .ifnum = QUIRK_ANY_INTERFACE,
3205 .type = QUIRK_COMPOSITE,
3206 .data = &(const struct snd_usb_audio_quirk[]) {
3207 {
3208 /* playback */
3209 .ifnum = 0,
3210 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3211 .data = &(const struct audioformat) {
3212 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3213 .channels = 1,
3214 .iface = 0,
3215 .altsetting = 0,
3216 .altset_idx = 0,
3217 .attributes = 0,
3218 .endpoint = 0x04,
3219 .ep_attr = 0x05,
3220 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3221 .rate_min = 22050,
3222 .rate_max = 22050
3223 }
3224 },
3225 {
3226 /* capture */
3227 .ifnum = 1,
3228 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3229 .data = &(const struct audioformat) {
3230 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3231 .channels = 1,
3232 .iface = 1,
3233 .altsetting = 0,
3234 .altset_idx = 0,
3235 .attributes = 0,
3236 .endpoint = 0x85,
3237 .ep_attr = 0x05,
3238 .rates = SNDRV_PCM_RATE_CONTINUOUS,
3239 .rate_min = 16000,
3240 .rate_max = 16000
3241 }
3242 },
3243 {
3244 .ifnum = -1
3245 }
3246 }
3247 }
3248 },
3249
3250 /* Reloop Play */
3251 {
3252 USB_DEVICE(0x200c, 0x100b),
3253 .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3254 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3255 .ifnum = QUIRK_ANY_INTERFACE,
3256 .type = QUIRK_COMPOSITE,
3257 .data = &(const struct snd_usb_audio_quirk[]) {
3258 {
3259 .ifnum = 0,
3260 .type = QUIRK_AUDIO_STANDARD_MIXER,
3261 },
3262 {
3263 .ifnum = 1,
3264 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3265 .data = &(const struct audioformat) {
3266 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3267 .channels = 4,
3268 .iface = 1,
3269 .altsetting = 1,
3270 .altset_idx = 1,
3271 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3272 .endpoint = 0x01,
3273 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3274 .rates = SNDRV_PCM_RATE_44100 |
3275 SNDRV_PCM_RATE_48000,
3276 .rate_min = 44100,
3277 .rate_max = 48000,
3278 .nr_rates = 2,
3279 .rate_table = (unsigned int[]) {
3280 44100, 48000
3281 }
3282 }
3283 },
3284 {
3285 .ifnum = -1
3286 }
3287 }
3288 }
3289 },
3290
3291 {
3292 /*
3293 * ZOOM R16/24 in audio interface mode.
3294 * Playback requires an extra four byte LE length indicator
3295 * at the start of each isochronous packet. This quirk is
3296 * enabled in create_standard_audio_quirk().
3297 */
3298 USB_DEVICE(0x1686, 0x00dd),
3299 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3300 .ifnum = QUIRK_ANY_INTERFACE,
3301 .type = QUIRK_COMPOSITE,
3302 .data = (const struct snd_usb_audio_quirk[]) {
3303 {
3304 /* Playback */
3305 .ifnum = 1,
3306 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3307 },
3308 {
3309 /* Capture */
3310 .ifnum = 2,
3311 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3312 },
3313 {
3314 /* Midi */
3315 .ifnum = 3,
3316 .type = QUIRK_MIDI_STANDARD_INTERFACE
3317 },
3318 {
3319 .ifnum = -1
3320 },
3321 }
3322 }
3323 },
3324
3325 {
3326 /*
3327 * Some USB MIDI devices don't have an audio control interface,
3328 * so we have to grab MIDI streaming interfaces here.
3329 */
3330 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3331 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3332 .bInterfaceClass = USB_CLASS_AUDIO,
3333 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3334 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3335 .ifnum = QUIRK_ANY_INTERFACE,
3336 .type = QUIRK_MIDI_STANDARD_INTERFACE
3337 }
3338 },
3339
3340 {
3341 /*
3342 * The original product_name is "USB Sound Device", however this name
3343 * is also used by the CM106 based cards, so make it unique.
3344 */
3345 USB_DEVICE(0x0d8c, 0x0103),
3346 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3347 .product_name = "Audio Advantage MicroII",
3348 .ifnum = QUIRK_NO_INTERFACE
3349 }
3350 },
3351
3352 /* disabled due to regression for other devices;
3353 * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3354 */
3355 #if 0
3356 {
3357 /*
3358 * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3359 * ID, but it looks like the product ID actually is only for Nura.
3360 * The capture interface does not work at all (even on Windows),
3361 * and only the 48 kHz sample rate works for the playback interface.
3362 */
3363 USB_DEVICE(0x0a12, 0x1243),
3364 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3365 .ifnum = QUIRK_ANY_INTERFACE,
3366 .type = QUIRK_COMPOSITE,
3367 .data = (const struct snd_usb_audio_quirk[]) {
3368 {
3369 .ifnum = 0,
3370 .type = QUIRK_AUDIO_STANDARD_MIXER,
3371 },
3372 /* Capture */
3373 {
3374 .ifnum = 1,
3375 .type = QUIRK_IGNORE_INTERFACE,
3376 },
3377 /* Playback */
3378 {
3379 .ifnum = 2,
3380 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3381 .data = &(const struct audioformat) {
3382 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3383 .channels = 2,
3384 .iface = 2,
3385 .altsetting = 1,
3386 .altset_idx = 1,
3387 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3388 UAC_EP_CS_ATTR_SAMPLE_RATE,
3389 .endpoint = 0x03,
3390 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3391 .rates = SNDRV_PCM_RATE_48000,
3392 .rate_min = 48000,
3393 .rate_max = 48000,
3394 .nr_rates = 1,
3395 .rate_table = (unsigned int[]) {
3396 48000
3397 }
3398 }
3399 },
3400 {
3401 .ifnum = -1
3402 },
3403 }
3404 }
3405 },
3406 #endif /* disabled */
3407
3408 {
3409 /*
3410 * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3411 * even though it advertises more. The capture interface doesn't work
3412 * even on windows.
3413 */
3414 USB_DEVICE(0x19b5, 0x0021),
3415 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3416 .ifnum = QUIRK_ANY_INTERFACE,
3417 .type = QUIRK_COMPOSITE,
3418 .data = (const struct snd_usb_audio_quirk[]) {
3419 {
3420 .ifnum = 0,
3421 .type = QUIRK_AUDIO_STANDARD_MIXER,
3422 },
3423 /* Playback */
3424 {
3425 .ifnum = 1,
3426 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3427 .data = &(const struct audioformat) {
3428 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3429 .channels = 2,
3430 .iface = 1,
3431 .altsetting = 1,
3432 .altset_idx = 1,
3433 .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3434 UAC_EP_CS_ATTR_SAMPLE_RATE,
3435 .endpoint = 0x03,
3436 .ep_attr = USB_ENDPOINT_XFER_ISOC,
3437 .rates = SNDRV_PCM_RATE_48000,
3438 .rate_min = 48000,
3439 .rate_max = 48000,
3440 .nr_rates = 1,
3441 .rate_table = (unsigned int[]) {
3442 48000
3443 }
3444 }
3445 },
3446 {
3447 .ifnum = -1
3448 },
3449 }
3450 }
3451 },
3452 /* Dell WD15 Dock */
3453 {
3454 USB_DEVICE(0x0bda, 0x4014),
3455 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3456 .vendor_name = "Dell",
3457 .product_name = "WD15 Dock",
3458 .profile_name = "Dell-WD15-Dock",
3459 .ifnum = QUIRK_NO_INTERFACE
3460 }
3461 },
3462 /* Dell WD19 Dock */
3463 {
3464 USB_DEVICE(0x0bda, 0x402e),
3465 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3466 .vendor_name = "Dell",
3467 .product_name = "WD19 Dock",
3468 .profile_name = "Dell-WD15-Dock",
3469 .ifnum = QUIRK_NO_INTERFACE
3470 }
3471 },
3472 /* MOTU Microbook II */
3473 {
3474 USB_DEVICE(0x07fd, 0x0004),
3475 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3476 .vendor_name = "MOTU",
3477 .product_name = "MicroBookII",
3478 .ifnum = QUIRK_ANY_INTERFACE,
3479 .type = QUIRK_COMPOSITE,
3480 .data = (const struct snd_usb_audio_quirk[]) {
3481 {
3482 .ifnum = 0,
3483 .type = QUIRK_AUDIO_STANDARD_MIXER,
3484 },
3485 {
3486 .ifnum = 0,
3487 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3488 .data = &(const struct audioformat) {
3489 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3490 .channels = 6,
3491 .iface = 0,
3492 .altsetting = 1,
3493 .altset_idx = 1,
3494 .attributes = 0,
3495 .endpoint = 0x84,
3496 .rates = SNDRV_PCM_RATE_96000,
3497 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3498 USB_ENDPOINT_SYNC_ASYNC,
3499 .rate_min = 96000,
3500 .rate_max = 96000,
3501 .nr_rates = 1,
3502 .maxpacksize = 0x00d8,
3503 .rate_table = (unsigned int[]) {
3504 96000
3505 }
3506 }
3507 },
3508 {
3509 .ifnum = 0,
3510 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3511 .data = &(const struct audioformat) {
3512 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3513 .channels = 8,
3514 .iface = 0,
3515 .altsetting = 1,
3516 .altset_idx = 1,
3517 .attributes = 0,
3518 .endpoint = 0x03,
3519 .rates = SNDRV_PCM_RATE_96000,
3520 .ep_attr = USB_ENDPOINT_XFER_ISOC |
3521 USB_ENDPOINT_SYNC_ASYNC,
3522 .rate_min = 96000,
3523 .rate_max = 96000,
3524 .nr_rates = 1,
3525 .maxpacksize = 0x0120,
3526 .rate_table = (unsigned int[]) {
3527 96000
3528 }
3529 }
3530 },
3531 {
3532 .ifnum = -1
3533 }
3534 }
3535 }
3536 },
3537
3538 #undef USB_DEVICE_VENDOR_SPEC
Linux with added FPC-III support