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