summaryrefslogtreecommitdiffstats
path: root/sound/usb/usbquirks.h
diff options
context:
space:
mode:
authorDaniel Mack <daniel@caiaq.de>2010-03-04 13:46:13 -0500
committerTakashi Iwai <tiwai@suse.de>2010-03-05 02:17:14 -0500
commite5779998bf8b70e48a6cc208c8b61b33bd6117ea (patch)
tree512568f0fc4b81eac8019522c10df5b81483bcca /sound/usb/usbquirks.h
parent3e1aebef6fb55e35668d2d7cf608cf03f30c904f (diff)
ALSA: usb-audio: refactor code
Clean up the usb audio driver by factoring out a lot of functions to separate files. Code for procfs, quirks, urbs, format parsers etc all got a new home now. Moved almost all special quirk handling to quirks.c and introduced new generic functions to handle them, so the exceptions do not pollute the whole driver. Renamed usbaudio.c to card.c because this is what it actually does now. Renamed usbmidi.c to midi.c for namespace clarity. Removed more things from usbaudio.h. The non-standard drivers were adopted accordingly. Signed-off-by: Daniel Mack <daniel@caiaq.de> Cc: Clemens Ladisch <clemens@ladisch.de> Signed-off-by: Takashi Iwai <tiwai@suse.de>
Diffstat (limited to 'sound/usb/usbquirks.h')
-rw-r--r--sound/usb/usbquirks.h2248
1 files changed, 0 insertions, 2248 deletions
diff --git a/sound/usb/usbquirks.h b/sound/usb/usbquirks.h
deleted file mode 100644
index 2b426c1fd0e8..000000000000
--- a/sound/usb/usbquirks.h
+++ /dev/null
@@ -1,2248 +0,0 @@
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/* Creative/Toshiba Multimedia Center SB-0500 */
43{
44 USB_DEVICE(0x041e, 0x3048),
45 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
46 .vendor_name = "Toshiba",
47 .product_name = "SB-0500",
48 .ifnum = QUIRK_NO_INTERFACE
49 }
50},
51
52/* Creative/E-Mu devices */
53{
54 USB_DEVICE(0x041e, 0x3010),
55 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
56 .vendor_name = "Creative Labs",
57 .product_name = "Sound Blaster MP3+",
58 .ifnum = QUIRK_NO_INTERFACE
59 }
60},
61{
62 /* E-Mu 0202 USB */
63 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
64 .idVendor = 0x041e,
65 .idProduct = 0x3f02,
66 .bInterfaceClass = USB_CLASS_AUDIO,
67},
68{
69 /* E-Mu 0404 USB */
70 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
71 .idVendor = 0x041e,
72 .idProduct = 0x3f04,
73 .bInterfaceClass = USB_CLASS_AUDIO,
74},
75{
76 /* E-Mu Tracker Pre */
77 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
78 .idVendor = 0x041e,
79 .idProduct = 0x3f0a,
80 .bInterfaceClass = USB_CLASS_AUDIO,
81},
82
83/*
84 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
85 * class matches do not take effect without an explicit ID match.
86 */
87{
88 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
89 USB_DEVICE_ID_MATCH_INT_CLASS |
90 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
91 .idVendor = 0x046d,
92 .idProduct = 0x0850,
93 .bInterfaceClass = USB_CLASS_AUDIO,
94 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
95},
96{
97 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
98 USB_DEVICE_ID_MATCH_INT_CLASS |
99 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
100 .idVendor = 0x046d,
101 .idProduct = 0x08ae,
102 .bInterfaceClass = USB_CLASS_AUDIO,
103 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
104},
105{
106 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
107 USB_DEVICE_ID_MATCH_INT_CLASS |
108 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
109 .idVendor = 0x046d,
110 .idProduct = 0x08c6,
111 .bInterfaceClass = USB_CLASS_AUDIO,
112 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
113},
114{
115 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
116 USB_DEVICE_ID_MATCH_INT_CLASS |
117 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
118 .idVendor = 0x046d,
119 .idProduct = 0x08f0,
120 .bInterfaceClass = USB_CLASS_AUDIO,
121 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
122},
123{
124 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
125 USB_DEVICE_ID_MATCH_INT_CLASS |
126 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
127 .idVendor = 0x046d,
128 .idProduct = 0x08f5,
129 .bInterfaceClass = USB_CLASS_AUDIO,
130 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
131},
132{
133 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
134 USB_DEVICE_ID_MATCH_INT_CLASS |
135 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
136 .idVendor = 0x046d,
137 .idProduct = 0x08f6,
138 .bInterfaceClass = USB_CLASS_AUDIO,
139 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
140},
141{
142 USB_DEVICE(0x046d, 0x0990),
143 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
144 .vendor_name = "Logitech, Inc.",
145 .product_name = "QuickCam Pro 9000",
146 .ifnum = QUIRK_NO_INTERFACE
147 }
148},
149
150/*
151 * Yamaha devices
152 */
153
154#define YAMAHA_DEVICE(id, name) { \
155 USB_DEVICE(0x0499, id), \
156 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
157 .vendor_name = "Yamaha", \
158 .product_name = name, \
159 .ifnum = QUIRK_ANY_INTERFACE, \
160 .type = QUIRK_MIDI_YAMAHA \
161 } \
162}
163#define YAMAHA_INTERFACE(id, intf, name) { \
164 USB_DEVICE_VENDOR_SPEC(0x0499, id), \
165 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
166 .vendor_name = "Yamaha", \
167 .product_name = name, \
168 .ifnum = intf, \
169 .type = QUIRK_MIDI_YAMAHA \
170 } \
171}
172YAMAHA_DEVICE(0x1000, "UX256"),
173YAMAHA_DEVICE(0x1001, "MU1000"),
174YAMAHA_DEVICE(0x1002, "MU2000"),
175YAMAHA_DEVICE(0x1003, "MU500"),
176YAMAHA_INTERFACE(0x1004, 3, "UW500"),
177YAMAHA_DEVICE(0x1005, "MOTIF6"),
178YAMAHA_DEVICE(0x1006, "MOTIF7"),
179YAMAHA_DEVICE(0x1007, "MOTIF8"),
180YAMAHA_DEVICE(0x1008, "UX96"),
181YAMAHA_DEVICE(0x1009, "UX16"),
182YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
183YAMAHA_DEVICE(0x100c, "UC-MX"),
184YAMAHA_DEVICE(0x100d, "UC-KX"),
185YAMAHA_DEVICE(0x100e, "S08"),
186YAMAHA_DEVICE(0x100f, "CLP-150"),
187YAMAHA_DEVICE(0x1010, "CLP-170"),
188YAMAHA_DEVICE(0x1011, "P-250"),
189YAMAHA_DEVICE(0x1012, "TYROS"),
190YAMAHA_DEVICE(0x1013, "PF-500"),
191YAMAHA_DEVICE(0x1014, "S90"),
192YAMAHA_DEVICE(0x1015, "MOTIF-R"),
193YAMAHA_DEVICE(0x1016, "MDP-5"),
194YAMAHA_DEVICE(0x1017, "CVP-204"),
195YAMAHA_DEVICE(0x1018, "CVP-206"),
196YAMAHA_DEVICE(0x1019, "CVP-208"),
197YAMAHA_DEVICE(0x101a, "CVP-210"),
198YAMAHA_DEVICE(0x101b, "PSR-1100"),
199YAMAHA_DEVICE(0x101c, "PSR-2100"),
200YAMAHA_DEVICE(0x101d, "CLP-175"),
201YAMAHA_DEVICE(0x101e, "PSR-K1"),
202YAMAHA_DEVICE(0x101f, "EZ-J24"),
203YAMAHA_DEVICE(0x1020, "EZ-250i"),
204YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
205YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
206YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
207YAMAHA_DEVICE(0x1024, "CVP-301"),
208YAMAHA_DEVICE(0x1025, "CVP-303"),
209YAMAHA_DEVICE(0x1026, "CVP-305"),
210YAMAHA_DEVICE(0x1027, "CVP-307"),
211YAMAHA_DEVICE(0x1028, "CVP-309"),
212YAMAHA_DEVICE(0x1029, "CVP-309GP"),
213YAMAHA_DEVICE(0x102a, "PSR-1500"),
214YAMAHA_DEVICE(0x102b, "PSR-3000"),
215YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
216YAMAHA_DEVICE(0x1030, "PSR-295/293"),
217YAMAHA_DEVICE(0x1031, "DGX-205/203"),
218YAMAHA_DEVICE(0x1032, "DGX-305"),
219YAMAHA_DEVICE(0x1033, "DGX-505"),
220YAMAHA_DEVICE(0x1034, NULL),
221YAMAHA_DEVICE(0x1035, NULL),
222YAMAHA_DEVICE(0x1036, NULL),
223YAMAHA_DEVICE(0x1037, NULL),
224YAMAHA_DEVICE(0x1038, NULL),
225YAMAHA_DEVICE(0x1039, NULL),
226YAMAHA_DEVICE(0x103a, NULL),
227YAMAHA_DEVICE(0x103b, NULL),
228YAMAHA_DEVICE(0x103c, NULL),
229YAMAHA_DEVICE(0x103d, NULL),
230YAMAHA_DEVICE(0x103e, NULL),
231YAMAHA_DEVICE(0x103f, NULL),
232YAMAHA_DEVICE(0x1040, NULL),
233YAMAHA_DEVICE(0x1041, NULL),
234YAMAHA_DEVICE(0x1042, NULL),
235YAMAHA_DEVICE(0x1043, NULL),
236YAMAHA_DEVICE(0x1044, NULL),
237YAMAHA_DEVICE(0x1045, NULL),
238YAMAHA_INTERFACE(0x104e, 0, NULL),
239YAMAHA_DEVICE(0x104f, NULL),
240YAMAHA_DEVICE(0x1050, NULL),
241YAMAHA_DEVICE(0x1051, NULL),
242YAMAHA_DEVICE(0x1052, NULL),
243YAMAHA_DEVICE(0x2000, "DGP-7"),
244YAMAHA_DEVICE(0x2001, "DGP-5"),
245YAMAHA_DEVICE(0x2002, NULL),
246YAMAHA_DEVICE(0x5000, "CS1D"),
247YAMAHA_DEVICE(0x5001, "DSP1D"),
248YAMAHA_DEVICE(0x5002, "DME32"),
249YAMAHA_DEVICE(0x5003, "DM2000"),
250YAMAHA_DEVICE(0x5004, "02R96"),
251YAMAHA_DEVICE(0x5005, "ACU16-C"),
252YAMAHA_DEVICE(0x5006, "NHB32-C"),
253YAMAHA_DEVICE(0x5007, "DM1000"),
254YAMAHA_DEVICE(0x5008, "01V96"),
255YAMAHA_DEVICE(0x5009, "SPX2000"),
256YAMAHA_DEVICE(0x500a, "PM5D"),
257YAMAHA_DEVICE(0x500b, "DME64N"),
258YAMAHA_DEVICE(0x500c, "DME24N"),
259YAMAHA_DEVICE(0x500d, NULL),
260YAMAHA_DEVICE(0x500e, NULL),
261YAMAHA_DEVICE(0x500f, NULL),
262YAMAHA_DEVICE(0x7000, "DTX"),
263YAMAHA_DEVICE(0x7010, "UB99"),
264#undef YAMAHA_DEVICE
265#undef YAMAHA_INTERFACE
266
267/*
268 * Roland/RolandED/Edirol/BOSS devices
269 */
270{
271 USB_DEVICE(0x0582, 0x0000),
272 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
273 .vendor_name = "Roland",
274 .product_name = "UA-100",
275 .ifnum = QUIRK_ANY_INTERFACE,
276 .type = QUIRK_COMPOSITE,
277 .data = (const struct snd_usb_audio_quirk[]) {
278 {
279 .ifnum = 0,
280 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
281 .data = & (const struct audioformat) {
282 .format = SNDRV_PCM_FORMAT_S16_LE,
283 .channels = 4,
284 .iface = 0,
285 .altsetting = 1,
286 .altset_idx = 1,
287 .attributes = 0,
288 .endpoint = 0x01,
289 .ep_attr = 0x09,
290 .rates = SNDRV_PCM_RATE_CONTINUOUS,
291 .rate_min = 44100,
292 .rate_max = 44100,
293 }
294 },
295 {
296 .ifnum = 1,
297 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
298 .data = & (const struct audioformat) {
299 .format = SNDRV_PCM_FORMAT_S16_LE,
300 .channels = 2,
301 .iface = 1,
302 .altsetting = 1,
303 .altset_idx = 1,
304 .attributes = UAC_EP_CS_ATTR_FILL_MAX,
305 .endpoint = 0x81,
306 .ep_attr = 0x05,
307 .rates = SNDRV_PCM_RATE_CONTINUOUS,
308 .rate_min = 44100,
309 .rate_max = 44100,
310 }
311 },
312 {
313 .ifnum = 2,
314 .type = QUIRK_MIDI_FIXED_ENDPOINT,
315 .data = & (const struct snd_usb_midi_endpoint_info) {
316 .out_cables = 0x0007,
317 .in_cables = 0x0007
318 }
319 },
320 {
321 .ifnum = -1
322 }
323 }
324 }
325},
326{
327 USB_DEVICE(0x0582, 0x0002),
328 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
329 .vendor_name = "EDIROL",
330 .product_name = "UM-4",
331 .ifnum = QUIRK_ANY_INTERFACE,
332 .type = QUIRK_COMPOSITE,
333 .data = (const struct snd_usb_audio_quirk[]) {
334 {
335 .ifnum = 0,
336 .type = QUIRK_IGNORE_INTERFACE
337 },
338 {
339 .ifnum = 1,
340 .type = QUIRK_IGNORE_INTERFACE
341 },
342 {
343 .ifnum = 2,
344 .type = QUIRK_MIDI_FIXED_ENDPOINT,
345 .data = & (const struct snd_usb_midi_endpoint_info) {
346 .out_cables = 0x000f,
347 .in_cables = 0x000f
348 }
349 },
350 {
351 .ifnum = -1
352 }
353 }
354 }
355},
356{
357 USB_DEVICE(0x0582, 0x0003),
358 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
359 .vendor_name = "Roland",
360 .product_name = "SC-8850",
361 .ifnum = QUIRK_ANY_INTERFACE,
362 .type = QUIRK_COMPOSITE,
363 .data = (const struct snd_usb_audio_quirk[]) {
364 {
365 .ifnum = 0,
366 .type = QUIRK_IGNORE_INTERFACE
367 },
368 {
369 .ifnum = 1,
370 .type = QUIRK_IGNORE_INTERFACE
371 },
372 {
373 .ifnum = 2,
374 .type = QUIRK_MIDI_FIXED_ENDPOINT,
375 .data = & (const struct snd_usb_midi_endpoint_info) {
376 .out_cables = 0x003f,
377 .in_cables = 0x003f
378 }
379 },
380 {
381 .ifnum = -1
382 }
383 }
384 }
385},
386{
387 USB_DEVICE(0x0582, 0x0004),
388 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
389 .vendor_name = "Roland",
390 .product_name = "U-8",
391 .ifnum = QUIRK_ANY_INTERFACE,
392 .type = QUIRK_COMPOSITE,
393 .data = (const struct snd_usb_audio_quirk[]) {
394 {
395 .ifnum = 0,
396 .type = QUIRK_IGNORE_INTERFACE
397 },
398 {
399 .ifnum = 1,
400 .type = QUIRK_IGNORE_INTERFACE
401 },
402 {
403 .ifnum = 2,
404 .type = QUIRK_MIDI_FIXED_ENDPOINT,
405 .data = & (const struct snd_usb_midi_endpoint_info) {
406 .out_cables = 0x0005,
407 .in_cables = 0x0005
408 }
409 },
410 {
411 .ifnum = -1
412 }
413 }
414 }
415},
416{
417 /* Has ID 0x0099 when not in "Advanced Driver" mode.
418 * The UM-2EX has only one input, but we cannot detect this. */
419 USB_DEVICE(0x0582, 0x0005),
420 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
421 .vendor_name = "EDIROL",
422 .product_name = "UM-2",
423 .ifnum = QUIRK_ANY_INTERFACE,
424 .type = QUIRK_COMPOSITE,
425 .data = (const struct snd_usb_audio_quirk[]) {
426 {
427 .ifnum = 0,
428 .type = QUIRK_IGNORE_INTERFACE
429 },
430 {
431 .ifnum = 1,
432 .type = QUIRK_IGNORE_INTERFACE
433 },
434 {
435 .ifnum = 2,
436 .type = QUIRK_MIDI_FIXED_ENDPOINT,
437 .data = & (const struct snd_usb_midi_endpoint_info) {
438 .out_cables = 0x0003,
439 .in_cables = 0x0003
440 }
441 },
442 {
443 .ifnum = -1
444 }
445 }
446 }
447},
448{
449 USB_DEVICE(0x0582, 0x0007),
450 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
451 .vendor_name = "Roland",
452 .product_name = "SC-8820",
453 .ifnum = QUIRK_ANY_INTERFACE,
454 .type = QUIRK_COMPOSITE,
455 .data = (const struct snd_usb_audio_quirk[]) {
456 {
457 .ifnum = 0,
458 .type = QUIRK_IGNORE_INTERFACE
459 },
460 {
461 .ifnum = 1,
462 .type = QUIRK_IGNORE_INTERFACE
463 },
464 {
465 .ifnum = 2,
466 .type = QUIRK_MIDI_FIXED_ENDPOINT,
467 .data = & (const struct snd_usb_midi_endpoint_info) {
468 .out_cables = 0x0013,
469 .in_cables = 0x0013
470 }
471 },
472 {
473 .ifnum = -1
474 }
475 }
476 }
477},
478{
479 USB_DEVICE(0x0582, 0x0008),
480 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
481 .vendor_name = "Roland",
482 .product_name = "PC-300",
483 .ifnum = QUIRK_ANY_INTERFACE,
484 .type = QUIRK_COMPOSITE,
485 .data = (const struct snd_usb_audio_quirk[]) {
486 {
487 .ifnum = 0,
488 .type = QUIRK_IGNORE_INTERFACE
489 },
490 {
491 .ifnum = 1,
492 .type = QUIRK_IGNORE_INTERFACE
493 },
494 {
495 .ifnum = 2,
496 .type = QUIRK_MIDI_FIXED_ENDPOINT,
497 .data = & (const struct snd_usb_midi_endpoint_info) {
498 .out_cables = 0x0001,
499 .in_cables = 0x0001
500 }
501 },
502 {
503 .ifnum = -1
504 }
505 }
506 }
507},
508{
509 /* has ID 0x009d when not in "Advanced Driver" mode */
510 USB_DEVICE(0x0582, 0x0009),
511 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
512 .vendor_name = "EDIROL",
513 .product_name = "UM-1",
514 .ifnum = QUIRK_ANY_INTERFACE,
515 .type = QUIRK_COMPOSITE,
516 .data = (const struct snd_usb_audio_quirk[]) {
517 {
518 .ifnum = 0,
519 .type = QUIRK_IGNORE_INTERFACE
520 },
521 {
522 .ifnum = 1,
523 .type = QUIRK_IGNORE_INTERFACE
524 },
525 {
526 .ifnum = 2,
527 .type = QUIRK_MIDI_FIXED_ENDPOINT,
528 .data = & (const struct snd_usb_midi_endpoint_info) {
529 .out_cables = 0x0001,
530 .in_cables = 0x0001
531 }
532 },
533 {
534 .ifnum = -1
535 }
536 }
537 }
538},
539{
540 USB_DEVICE(0x0582, 0x000b),
541 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
542 .vendor_name = "Roland",
543 .product_name = "SK-500",
544 .ifnum = QUIRK_ANY_INTERFACE,
545 .type = QUIRK_COMPOSITE,
546 .data = (const struct snd_usb_audio_quirk[]) {
547 {
548 .ifnum = 0,
549 .type = QUIRK_IGNORE_INTERFACE
550 },
551 {
552 .ifnum = 1,
553 .type = QUIRK_IGNORE_INTERFACE
554 },
555 {
556 .ifnum = 2,
557 .type = QUIRK_MIDI_FIXED_ENDPOINT,
558 .data = & (const struct snd_usb_midi_endpoint_info) {
559 .out_cables = 0x0013,
560 .in_cables = 0x0013
561 }
562 },
563 {
564 .ifnum = -1
565 }
566 }
567 }
568},
569{
570 /* thanks to Emiliano Grilli <emillo@libero.it>
571 * for helping researching this data */
572 USB_DEVICE(0x0582, 0x000c),
573 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
574 .vendor_name = "Roland",
575 .product_name = "SC-D70",
576 .ifnum = QUIRK_ANY_INTERFACE,
577 .type = QUIRK_COMPOSITE,
578 .data = (const struct snd_usb_audio_quirk[]) {
579 {
580 .ifnum = 0,
581 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
582 .data = & (const struct audioformat) {
583 .format = SNDRV_PCM_FORMAT_S24_3LE,
584 .channels = 2,
585 .iface = 0,
586 .altsetting = 1,
587 .altset_idx = 1,
588 .attributes = 0,
589 .endpoint = 0x01,
590 .ep_attr = 0x01,
591 .rates = SNDRV_PCM_RATE_CONTINUOUS,
592 .rate_min = 44100,
593 .rate_max = 44100,
594 }
595 },
596 {
597 .ifnum = 1,
598 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
599 .data = & (const struct audioformat) {
600 .format = SNDRV_PCM_FORMAT_S24_3LE,
601 .channels = 2,
602 .iface = 1,
603 .altsetting = 1,
604 .altset_idx = 1,
605 .attributes = 0,
606 .endpoint = 0x81,
607 .ep_attr = 0x01,
608 .rates = SNDRV_PCM_RATE_CONTINUOUS,
609 .rate_min = 44100,
610 .rate_max = 44100,
611 }
612 },
613 {
614 .ifnum = 2,
615 .type = QUIRK_MIDI_FIXED_ENDPOINT,
616 .data = & (const struct snd_usb_midi_endpoint_info) {
617 .out_cables = 0x0007,
618 .in_cables = 0x0007
619 }
620 },
621 {
622 .ifnum = -1
623 }
624 }
625 }
626},
627{ /*
628 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
629 * If the advanced mode switch at the back of the unit is off, the
630 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
631 * but offers only 16-bit PCM.
632 * In advanced mode, the UA-5 will output S24_3LE samples (two
633 * channels) at the rate indicated on the front switch, including
634 * the 96kHz sample rate.
635 */
636 USB_DEVICE(0x0582, 0x0010),
637 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
638 .vendor_name = "EDIROL",
639 .product_name = "UA-5",
640 .ifnum = QUIRK_ANY_INTERFACE,
641 .type = QUIRK_COMPOSITE,
642 .data = (const struct snd_usb_audio_quirk[]) {
643 {
644 .ifnum = 1,
645 .type = QUIRK_AUDIO_STANDARD_INTERFACE
646 },
647 {
648 .ifnum = 2,
649 .type = QUIRK_AUDIO_STANDARD_INTERFACE
650 },
651 {
652 .ifnum = -1
653 }
654 }
655 }
656},
657{
658 /* has ID 0x0013 when not in "Advanced Driver" mode */
659 USB_DEVICE(0x0582, 0x0012),
660 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
661 .vendor_name = "Roland",
662 .product_name = "XV-5050",
663 .ifnum = 0,
664 .type = QUIRK_MIDI_FIXED_ENDPOINT,
665 .data = & (const struct snd_usb_midi_endpoint_info) {
666 .out_cables = 0x0001,
667 .in_cables = 0x0001
668 }
669 }
670},
671{
672 /* has ID 0x0015 when not in "Advanced Driver" mode */
673 USB_DEVICE(0x0582, 0x0014),
674 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
675 .vendor_name = "EDIROL",
676 .product_name = "UM-880",
677 .ifnum = 0,
678 .type = QUIRK_MIDI_FIXED_ENDPOINT,
679 .data = & (const struct snd_usb_midi_endpoint_info) {
680 .out_cables = 0x01ff,
681 .in_cables = 0x01ff
682 }
683 }
684},
685{
686 /* has ID 0x0017 when not in "Advanced Driver" mode */
687 USB_DEVICE(0x0582, 0x0016),
688 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
689 .vendor_name = "EDIROL",
690 .product_name = "SD-90",
691 .ifnum = QUIRK_ANY_INTERFACE,
692 .type = QUIRK_COMPOSITE,
693 .data = (const struct snd_usb_audio_quirk[]) {
694 {
695 .ifnum = 0,
696 .type = QUIRK_IGNORE_INTERFACE
697 },
698 {
699 .ifnum = 1,
700 .type = QUIRK_IGNORE_INTERFACE
701 },
702 {
703 .ifnum = 2,
704 .type = QUIRK_MIDI_FIXED_ENDPOINT,
705 .data = & (const struct snd_usb_midi_endpoint_info) {
706 .out_cables = 0x000f,
707 .in_cables = 0x000f
708 }
709 },
710 {
711 .ifnum = -1
712 }
713 }
714 }
715},
716{
717 /* has ID 0x001c when not in "Advanced Driver" mode */
718 USB_DEVICE(0x0582, 0x001b),
719 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
720 .vendor_name = "Roland",
721 .product_name = "MMP-2",
722 .ifnum = QUIRK_ANY_INTERFACE,
723 .type = QUIRK_COMPOSITE,
724 .data = (const struct snd_usb_audio_quirk[]) {
725 {
726 .ifnum = 0,
727 .type = QUIRK_IGNORE_INTERFACE
728 },
729 {
730 .ifnum = 1,
731 .type = QUIRK_IGNORE_INTERFACE
732 },
733 {
734 .ifnum = 2,
735 .type = QUIRK_MIDI_FIXED_ENDPOINT,
736 .data = & (const struct snd_usb_midi_endpoint_info) {
737 .out_cables = 0x0001,
738 .in_cables = 0x0001
739 }
740 },
741 {
742 .ifnum = -1
743 }
744 }
745 }
746},
747{
748 /* has ID 0x001e when not in "Advanced Driver" mode */
749 USB_DEVICE(0x0582, 0x001d),
750 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
751 .vendor_name = "Roland",
752 .product_name = "V-SYNTH",
753 .ifnum = 0,
754 .type = QUIRK_MIDI_FIXED_ENDPOINT,
755 .data = & (const struct snd_usb_midi_endpoint_info) {
756 .out_cables = 0x0001,
757 .in_cables = 0x0001
758 }
759 }
760},
761{
762 /* has ID 0x0024 when not in "Advanced Driver" mode */
763 USB_DEVICE(0x0582, 0x0023),
764 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
765 .vendor_name = "EDIROL",
766 .product_name = "UM-550",
767 .ifnum = 0,
768 .type = QUIRK_MIDI_FIXED_ENDPOINT,
769 .data = & (const struct snd_usb_midi_endpoint_info) {
770 .out_cables = 0x003f,
771 .in_cables = 0x003f
772 }
773 }
774},
775{
776 /*
777 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
778 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
779 * and no MIDI.
780 */
781 USB_DEVICE(0x0582, 0x0025),
782 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
783 .vendor_name = "EDIROL",
784 .product_name = "UA-20",
785 .ifnum = QUIRK_ANY_INTERFACE,
786 .type = QUIRK_COMPOSITE,
787 .data = (const struct snd_usb_audio_quirk[]) {
788 {
789 .ifnum = 0,
790 .type = QUIRK_IGNORE_INTERFACE
791 },
792 {
793 .ifnum = 1,
794 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
795 .data = & (const struct audioformat) {
796 .format = SNDRV_PCM_FORMAT_S24_3LE,
797 .channels = 2,
798 .iface = 1,
799 .altsetting = 1,
800 .altset_idx = 1,
801 .attributes = 0,
802 .endpoint = 0x01,
803 .ep_attr = 0x01,
804 .rates = SNDRV_PCM_RATE_CONTINUOUS,
805 .rate_min = 44100,
806 .rate_max = 44100,
807 }
808 },
809 {
810 .ifnum = 2,
811 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
812 .data = & (const struct audioformat) {
813 .format = SNDRV_PCM_FORMAT_S24_3LE,
814 .channels = 2,
815 .iface = 2,
816 .altsetting = 1,
817 .altset_idx = 1,
818 .attributes = 0,
819 .endpoint = 0x82,
820 .ep_attr = 0x01,
821 .rates = SNDRV_PCM_RATE_CONTINUOUS,
822 .rate_min = 44100,
823 .rate_max = 44100,
824 }
825 },
826 {
827 .ifnum = 3,
828 .type = QUIRK_MIDI_FIXED_ENDPOINT,
829 .data = & (const struct snd_usb_midi_endpoint_info) {
830 .out_cables = 0x0001,
831 .in_cables = 0x0001
832 }
833 },
834 {
835 .ifnum = -1
836 }
837 }
838 }
839},
840{
841 /* has ID 0x0028 when not in "Advanced Driver" mode */
842 USB_DEVICE(0x0582, 0x0027),
843 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
844 .vendor_name = "EDIROL",
845 .product_name = "SD-20",
846 .ifnum = 0,
847 .type = QUIRK_MIDI_FIXED_ENDPOINT,
848 .data = & (const struct snd_usb_midi_endpoint_info) {
849 .out_cables = 0x0003,
850 .in_cables = 0x0007
851 }
852 }
853},
854{
855 /* has ID 0x002a when not in "Advanced Driver" mode */
856 USB_DEVICE(0x0582, 0x0029),
857 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
858 .vendor_name = "EDIROL",
859 .product_name = "SD-80",
860 .ifnum = 0,
861 .type = QUIRK_MIDI_FIXED_ENDPOINT,
862 .data = & (const struct snd_usb_midi_endpoint_info) {
863 .out_cables = 0x000f,
864 .in_cables = 0x000f
865 }
866 }
867},
868{ /*
869 * This quirk is for the "Advanced" modes of the Edirol UA-700.
870 * If the sample format switch is not in an advanced setting, the
871 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
872 * but offers only 16-bit PCM and no MIDI.
873 */
874 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
875 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
876 .vendor_name = "EDIROL",
877 .product_name = "UA-700",
878 .ifnum = QUIRK_ANY_INTERFACE,
879 .type = QUIRK_COMPOSITE,
880 .data = (const struct snd_usb_audio_quirk[]) {
881 {
882 .ifnum = 1,
883 .type = QUIRK_AUDIO_EDIROL_UAXX
884 },
885 {
886 .ifnum = 2,
887 .type = QUIRK_AUDIO_EDIROL_UAXX
888 },
889 {
890 .ifnum = 3,
891 .type = QUIRK_AUDIO_EDIROL_UAXX
892 },
893 {
894 .ifnum = -1
895 }
896 }
897 }
898},
899{
900 /* has ID 0x002e when not in "Advanced Driver" mode */
901 USB_DEVICE(0x0582, 0x002d),
902 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
903 .vendor_name = "Roland",
904 .product_name = "XV-2020",
905 .ifnum = 0,
906 .type = QUIRK_MIDI_FIXED_ENDPOINT,
907 .data = & (const struct snd_usb_midi_endpoint_info) {
908 .out_cables = 0x0001,
909 .in_cables = 0x0001
910 }
911 }
912},
913{
914 /* has ID 0x0030 when not in "Advanced Driver" mode */
915 USB_DEVICE(0x0582, 0x002f),
916 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
917 .vendor_name = "Roland",
918 .product_name = "VariOS",
919 .ifnum = 0,
920 .type = QUIRK_MIDI_FIXED_ENDPOINT,
921 .data = & (const struct snd_usb_midi_endpoint_info) {
922 .out_cables = 0x0007,
923 .in_cables = 0x0007
924 }
925 }
926},
927{
928 /* has ID 0x0034 when not in "Advanced Driver" mode */
929 USB_DEVICE(0x0582, 0x0033),
930 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
931 .vendor_name = "EDIROL",
932 .product_name = "PCR",
933 .ifnum = 0,
934 .type = QUIRK_MIDI_FIXED_ENDPOINT,
935 .data = & (const struct snd_usb_midi_endpoint_info) {
936 .out_cables = 0x0003,
937 .in_cables = 0x0007
938 }
939 }
940},
941 /* TODO: add Roland M-1000 support */
942{
943 /*
944 * Has ID 0x0038 when not in "Advanced Driver" mode;
945 * later revisions use IDs 0x0054 and 0x00a2.
946 */
947 USB_DEVICE(0x0582, 0x0037),
948 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
949 .vendor_name = "Roland",
950 .product_name = "Digital Piano",
951 .ifnum = 0,
952 .type = QUIRK_MIDI_FIXED_ENDPOINT,
953 .data = & (const struct snd_usb_midi_endpoint_info) {
954 .out_cables = 0x0001,
955 .in_cables = 0x0001
956 }
957 }
958},
959{
960 /*
961 * This quirk is for the "Advanced Driver" mode. If off, the GS-10
962 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
963 * and no MIDI.
964 */
965 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
966 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
967 .vendor_name = "BOSS",
968 .product_name = "GS-10",
969 .ifnum = QUIRK_ANY_INTERFACE,
970 .type = QUIRK_COMPOSITE,
971 .data = & (const struct snd_usb_audio_quirk[]) {
972 {
973 .ifnum = 1,
974 .type = QUIRK_AUDIO_STANDARD_INTERFACE
975 },
976 {
977 .ifnum = 2,
978 .type = QUIRK_AUDIO_STANDARD_INTERFACE
979 },
980 {
981 .ifnum = 3,
982 .type = QUIRK_MIDI_STANDARD_INTERFACE
983 },
984 {
985 .ifnum = -1
986 }
987 }
988 }
989},
990{
991 /* has ID 0x0041 when not in "Advanced Driver" mode */
992 USB_DEVICE(0x0582, 0x0040),
993 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
994 .vendor_name = "Roland",
995 .product_name = "GI-20",
996 .ifnum = 0,
997 .type = QUIRK_MIDI_FIXED_ENDPOINT,
998 .data = & (const struct snd_usb_midi_endpoint_info) {
999 .out_cables = 0x0001,
1000 .in_cables = 0x0001
1001 }
1002 }
1003},
1004{
1005 /* has ID 0x0043 when not in "Advanced Driver" mode */
1006 USB_DEVICE(0x0582, 0x0042),
1007 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1008 .vendor_name = "Roland",
1009 .product_name = "RS-70",
1010 .ifnum = 0,
1011 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1012 .data = & (const struct snd_usb_midi_endpoint_info) {
1013 .out_cables = 0x0001,
1014 .in_cables = 0x0001
1015 }
1016 }
1017},
1018{
1019 /* has ID 0x0049 when not in "Advanced Driver" mode */
1020 USB_DEVICE(0x0582, 0x0047),
1021 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1022 /* .vendor_name = "EDIROL", */
1023 /* .product_name = "UR-80", */
1024 .ifnum = QUIRK_ANY_INTERFACE,
1025 .type = QUIRK_COMPOSITE,
1026 .data = (const struct snd_usb_audio_quirk[]) {
1027 /* in the 96 kHz modes, only interface 1 is there */
1028 {
1029 .ifnum = 1,
1030 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1031 },
1032 {
1033 .ifnum = 2,
1034 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1035 },
1036 {
1037 .ifnum = -1
1038 }
1039 }
1040 }
1041},
1042{
1043 /* has ID 0x004a when not in "Advanced Driver" mode */
1044 USB_DEVICE(0x0582, 0x0048),
1045 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1046 /* .vendor_name = "EDIROL", */
1047 /* .product_name = "UR-80", */
1048 .ifnum = 0,
1049 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1050 .data = & (const struct snd_usb_midi_endpoint_info) {
1051 .out_cables = 0x0003,
1052 .in_cables = 0x0007
1053 }
1054 }
1055},
1056 /* TODO: add Edirol M-100FX support */
1057{
1058 /* has ID 0x004e when not in "Advanced Driver" mode */
1059 USB_DEVICE(0x0582, 0x004c),
1060 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1061 .vendor_name = "EDIROL",
1062 .product_name = "PCR-A",
1063 .ifnum = QUIRK_ANY_INTERFACE,
1064 .type = QUIRK_COMPOSITE,
1065 .data = (const struct snd_usb_audio_quirk[]) {
1066 {
1067 .ifnum = 1,
1068 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1069 },
1070 {
1071 .ifnum = 2,
1072 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1073 },
1074 {
1075 .ifnum = -1
1076 }
1077 }
1078 }
1079},
1080{
1081 /* has ID 0x004f when not in "Advanced Driver" mode */
1082 USB_DEVICE(0x0582, 0x004d),
1083 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1084 .vendor_name = "EDIROL",
1085 .product_name = "PCR-A",
1086 .ifnum = 0,
1087 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1088 .data = & (const struct snd_usb_midi_endpoint_info) {
1089 .out_cables = 0x0003,
1090 .in_cables = 0x0007
1091 }
1092 }
1093},
1094{
1095 /*
1096 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1097 * is standard compliant, but has only 16-bit PCM.
1098 */
1099 USB_DEVICE(0x0582, 0x0050),
1100 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1101 .vendor_name = "EDIROL",
1102 .product_name = "UA-3FX",
1103 .ifnum = QUIRK_ANY_INTERFACE,
1104 .type = QUIRK_COMPOSITE,
1105 .data = (const struct snd_usb_audio_quirk[]) {
1106 {
1107 .ifnum = 1,
1108 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1109 },
1110 {
1111 .ifnum = 2,
1112 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1113 },
1114 {
1115 .ifnum = -1
1116 }
1117 }
1118 }
1119},
1120{
1121 USB_DEVICE(0x0582, 0x0052),
1122 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1123 .vendor_name = "EDIROL",
1124 .product_name = "UM-1SX",
1125 .ifnum = 0,
1126 .type = QUIRK_MIDI_STANDARD_INTERFACE
1127 }
1128},
1129{
1130 USB_DEVICE(0x0582, 0x0060),
1131 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1132 .vendor_name = "Roland",
1133 .product_name = "EXR Series",
1134 .ifnum = 0,
1135 .type = QUIRK_MIDI_STANDARD_INTERFACE
1136 }
1137},
1138{
1139 /* has ID 0x0067 when not in "Advanced Driver" mode */
1140 USB_DEVICE(0x0582, 0x0065),
1141 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1142 .vendor_name = "EDIROL",
1143 .product_name = "PCR-1",
1144 .ifnum = 0,
1145 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1146 .data = & (const struct snd_usb_midi_endpoint_info) {
1147 .out_cables = 0x0001,
1148 .in_cables = 0x0003
1149 }
1150 }
1151},
1152{
1153 /* has ID 0x006b when not in "Advanced Driver" mode */
1154 USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1155 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1156 .vendor_name = "Roland",
1157 .product_name = "SP-606",
1158 .ifnum = 3,
1159 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1160 .data = & (const struct snd_usb_midi_endpoint_info) {
1161 .out_cables = 0x0001,
1162 .in_cables = 0x0001
1163 }
1164 }
1165},
1166{
1167 /* has ID 0x006e when not in "Advanced Driver" mode */
1168 USB_DEVICE(0x0582, 0x006d),
1169 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1170 .vendor_name = "Roland",
1171 .product_name = "FANTOM-X",
1172 .ifnum = 0,
1173 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1174 .data = & (const struct snd_usb_midi_endpoint_info) {
1175 .out_cables = 0x0001,
1176 .in_cables = 0x0001
1177 }
1178 }
1179},
1180{ /*
1181 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1182 * If the switch is not in an advanced setting, the UA-25 has
1183 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1184 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1185 */
1186 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1187 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1188 .vendor_name = "EDIROL",
1189 .product_name = "UA-25",
1190 .ifnum = QUIRK_ANY_INTERFACE,
1191 .type = QUIRK_COMPOSITE,
1192 .data = (const struct snd_usb_audio_quirk[]) {
1193 {
1194 .ifnum = 0,
1195 .type = QUIRK_AUDIO_EDIROL_UAXX
1196 },
1197 {
1198 .ifnum = 1,
1199 .type = QUIRK_AUDIO_EDIROL_UAXX
1200 },
1201 {
1202 .ifnum = 2,
1203 .type = QUIRK_AUDIO_EDIROL_UAXX
1204 },
1205 {
1206 .ifnum = -1
1207 }
1208 }
1209 }
1210},
1211{
1212 /* has ID 0x0076 when not in "Advanced Driver" mode */
1213 USB_DEVICE(0x0582, 0x0075),
1214 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1215 .vendor_name = "BOSS",
1216 .product_name = "DR-880",
1217 .ifnum = 0,
1218 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1219 .data = & (const struct snd_usb_midi_endpoint_info) {
1220 .out_cables = 0x0001,
1221 .in_cables = 0x0001
1222 }
1223 }
1224},
1225{
1226 /* has ID 0x007b when not in "Advanced Driver" mode */
1227 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1228 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1229 .vendor_name = "Roland",
1230 /* "RD" or "RD-700SX"? */
1231 .ifnum = 0,
1232 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1233 .data = & (const struct snd_usb_midi_endpoint_info) {
1234 .out_cables = 0x0003,
1235 .in_cables = 0x0003
1236 }
1237 }
1238},
1239{
1240 /* has ID 0x0081 when not in "Advanced Driver" mode */
1241 USB_DEVICE(0x0582, 0x0080),
1242 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1243 .vendor_name = "Roland",
1244 .product_name = "G-70",
1245 .ifnum = 0,
1246 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1247 .data = & (const struct snd_usb_midi_endpoint_info) {
1248 .out_cables = 0x0001,
1249 .in_cables = 0x0001
1250 }
1251 }
1252},
1253 /* TODO: add Roland V-SYNTH XT support */
1254 /* TODO: add BOSS GT-PRO support */
1255{
1256 /* has ID 0x008c when not in "Advanced Driver" mode */
1257 USB_DEVICE(0x0582, 0x008b),
1258 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1259 .vendor_name = "EDIROL",
1260 .product_name = "PC-50",
1261 .ifnum = 0,
1262 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1263 .data = & (const struct snd_usb_midi_endpoint_info) {
1264 .out_cables = 0x0001,
1265 .in_cables = 0x0001
1266 }
1267 }
1268},
1269 /* TODO: add Edirol PC-80 support */
1270{
1271 USB_DEVICE(0x0582, 0x0096),
1272 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1273 .vendor_name = "EDIROL",
1274 .product_name = "UA-1EX",
1275 .ifnum = QUIRK_ANY_INTERFACE,
1276 .type = QUIRK_COMPOSITE,
1277 .data = (const struct snd_usb_audio_quirk[]) {
1278 {
1279 .ifnum = 0,
1280 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1281 },
1282 {
1283 .ifnum = 1,
1284 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1285 },
1286 {
1287 .ifnum = -1
1288 }
1289 }
1290 }
1291},
1292{
1293 USB_DEVICE(0x0582, 0x009a),
1294 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1295 .vendor_name = "EDIROL",
1296 .product_name = "UM-3EX",
1297 .ifnum = 0,
1298 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1299 .data = & (const struct snd_usb_midi_endpoint_info) {
1300 .out_cables = 0x000f,
1301 .in_cables = 0x000f
1302 }
1303 }
1304},
1305{
1306 /*
1307 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1308 * is standard compliant, but has only 16-bit PCM and no MIDI.
1309 */
1310 USB_DEVICE(0x0582, 0x00a3),
1311 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1312 .vendor_name = "EDIROL",
1313 .product_name = "UA-4FX",
1314 .ifnum = QUIRK_ANY_INTERFACE,
1315 .type = QUIRK_COMPOSITE,
1316 .data = (const struct snd_usb_audio_quirk[]) {
1317 {
1318 .ifnum = 0,
1319 .type = QUIRK_AUDIO_EDIROL_UAXX
1320 },
1321 {
1322 .ifnum = 1,
1323 .type = QUIRK_AUDIO_EDIROL_UAXX
1324 },
1325 {
1326 .ifnum = 2,
1327 .type = QUIRK_AUDIO_EDIROL_UAXX
1328 },
1329 {
1330 .ifnum = -1
1331 }
1332 }
1333 }
1334},
1335 /* TODO: add Edirol MD-P1 support */
1336{
1337 USB_DEVICE(0x582, 0x00a6),
1338 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1339 .vendor_name = "Roland",
1340 .product_name = "Juno-G",
1341 .ifnum = 0,
1342 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1343 .data = & (const struct snd_usb_midi_endpoint_info) {
1344 .out_cables = 0x0001,
1345 .in_cables = 0x0001
1346 }
1347 }
1348},
1349{
1350 /* Roland SH-201 */
1351 USB_DEVICE(0x0582, 0x00ad),
1352 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1353 .vendor_name = "Roland",
1354 .product_name = "SH-201",
1355 .ifnum = QUIRK_ANY_INTERFACE,
1356 .type = QUIRK_COMPOSITE,
1357 .data = (const struct snd_usb_audio_quirk[]) {
1358 {
1359 .ifnum = 0,
1360 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1361 },
1362 {
1363 .ifnum = 1,
1364 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1365 },
1366 {
1367 .ifnum = 2,
1368 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1369 .data = & (const struct snd_usb_midi_endpoint_info) {
1370 .out_cables = 0x0001,
1371 .in_cables = 0x0001
1372 }
1373 },
1374 {
1375 .ifnum = -1
1376 }
1377 }
1378 }
1379},
1380{
1381 /* Roland SonicCell */
1382 USB_DEVICE(0x0582, 0x00c2),
1383 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1384 .vendor_name = "Roland",
1385 .product_name = "SonicCell",
1386 .ifnum = QUIRK_ANY_INTERFACE,
1387 .type = QUIRK_COMPOSITE,
1388 .data = (const struct snd_usb_audio_quirk[]) {
1389 {
1390 .ifnum = 0,
1391 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1392 },
1393 {
1394 .ifnum = 1,
1395 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1396 },
1397 {
1398 .ifnum = 2,
1399 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1400 .data = & (const struct snd_usb_midi_endpoint_info) {
1401 .out_cables = 0x0001,
1402 .in_cables = 0x0001
1403 }
1404 },
1405 {
1406 .ifnum = -1
1407 }
1408 }
1409 }
1410},
1411{
1412 /* Edirol M-16DX */
1413 /* FIXME: This quirk gives a good-working capture stream but the
1414 * playback seems problematic because of lacking of sync
1415 * with capture stream. It needs to sync with the capture
1416 * clock. As now, you'll get frequent sound distortions
1417 * via the playback.
1418 */
1419 USB_DEVICE(0x0582, 0x00c4),
1420 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1421 .ifnum = QUIRK_ANY_INTERFACE,
1422 .type = QUIRK_COMPOSITE,
1423 .data = (const struct snd_usb_audio_quirk[]) {
1424 {
1425 .ifnum = 0,
1426 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1427 },
1428 {
1429 .ifnum = 1,
1430 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1431 },
1432 {
1433 .ifnum = 2,
1434 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1435 .data = & (const struct snd_usb_midi_endpoint_info) {
1436 .out_cables = 0x0001,
1437 .in_cables = 0x0001
1438 }
1439 },
1440 {
1441 .ifnum = -1
1442 }
1443 }
1444 }
1445},
1446{
1447 /* BOSS GT-10 */
1448 USB_DEVICE(0x0582, 0x00da),
1449 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1450 .ifnum = QUIRK_ANY_INTERFACE,
1451 .type = QUIRK_COMPOSITE,
1452 .data = (const struct snd_usb_audio_quirk[]) {
1453 {
1454 .ifnum = 0,
1455 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1456 },
1457 {
1458 .ifnum = 1,
1459 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1460 },
1461 {
1462 .ifnum = 2,
1463 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1464 .data = & (const struct snd_usb_midi_endpoint_info) {
1465 .out_cables = 0x0001,
1466 .in_cables = 0x0001
1467 }
1468 },
1469 {
1470 .ifnum = -1
1471 }
1472 }
1473 }
1474},
1475{
1476 /* Advanced modes of the Edirol UA-25EX.
1477 * For the standard mode, UA-25EX has ID 0582:00e7, which
1478 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1479 */
1480 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1481 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1482 .vendor_name = "EDIROL",
1483 .product_name = "UA-25EX",
1484 .ifnum = QUIRK_ANY_INTERFACE,
1485 .type = QUIRK_COMPOSITE,
1486 .data = (const struct snd_usb_audio_quirk[]) {
1487 {
1488 .ifnum = 0,
1489 .type = QUIRK_AUDIO_EDIROL_UAXX
1490 },
1491 {
1492 .ifnum = 1,
1493 .type = QUIRK_AUDIO_EDIROL_UAXX
1494 },
1495 {
1496 .ifnum = 2,
1497 .type = QUIRK_AUDIO_EDIROL_UAXX
1498 },
1499 {
1500 .ifnum = -1
1501 }
1502 }
1503 }
1504},
1505{
1506 /* has ID 0x00ea when not in Advanced Driver mode */
1507 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9),
1508 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1509 /* .vendor_name = "Roland", */
1510 /* .product_name = "UA-1G", */
1511 .ifnum = QUIRK_ANY_INTERFACE,
1512 .type = QUIRK_COMPOSITE,
1513 .data = (const struct snd_usb_audio_quirk[]) {
1514 {
1515 .ifnum = 0,
1516 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1517 },
1518 {
1519 .ifnum = 1,
1520 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1521 },
1522 {
1523 .ifnum = -1
1524 }
1525 }
1526 }
1527},
1528
1529/* Guillemot devices */
1530{
1531 /*
1532 * This is for the "Windows Edition" where the external MIDI ports are
1533 * the only MIDI ports; the control data is reported through HID
1534 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard
1535 * compliant USB MIDI ports for external MIDI and controls.
1536 */
1537 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1538 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1539 .vendor_name = "Hercules",
1540 .product_name = "DJ Console (WE)",
1541 .ifnum = 4,
1542 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1543 .data = & (const struct snd_usb_midi_endpoint_info) {
1544 .out_cables = 0x0001,
1545 .in_cables = 0x0001
1546 }
1547 }
1548},
1549
1550/* Midiman/M-Audio devices */
1551{
1552 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1553 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1554 .vendor_name = "M-Audio",
1555 .product_name = "MidiSport 2x2",
1556 .ifnum = QUIRK_ANY_INTERFACE,
1557 .type = QUIRK_MIDI_MIDIMAN,
1558 .data = & (const struct snd_usb_midi_endpoint_info) {
1559 .out_cables = 0x0003,
1560 .in_cables = 0x0003
1561 }
1562 }
1563},
1564{
1565 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1566 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1567 .vendor_name = "M-Audio",
1568 .product_name = "MidiSport 1x1",
1569 .ifnum = QUIRK_ANY_INTERFACE,
1570 .type = QUIRK_MIDI_MIDIMAN,
1571 .data = & (const struct snd_usb_midi_endpoint_info) {
1572 .out_cables = 0x0001,
1573 .in_cables = 0x0001
1574 }
1575 }
1576},
1577{
1578 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1579 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1580 .vendor_name = "M-Audio",
1581 .product_name = "Keystation",
1582 .ifnum = QUIRK_ANY_INTERFACE,
1583 .type = QUIRK_MIDI_MIDIMAN,
1584 .data = & (const struct snd_usb_midi_endpoint_info) {
1585 .out_cables = 0x0001,
1586 .in_cables = 0x0001
1587 }
1588 }
1589},
1590{
1591 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1592 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1593 .vendor_name = "M-Audio",
1594 .product_name = "MidiSport 4x4",
1595 .ifnum = QUIRK_ANY_INTERFACE,
1596 .type = QUIRK_MIDI_MIDIMAN,
1597 .data = & (const struct snd_usb_midi_endpoint_info) {
1598 .out_cables = 0x000f,
1599 .in_cables = 0x000f
1600 }
1601 }
1602},
1603{
1604 /*
1605 * For hardware revision 1.05; in the later revisions (1.10 and
1606 * 1.21), 0x1031 is the ID for the device without firmware.
1607 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1608 */
1609 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1610 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1611 .vendor_name = "M-Audio",
1612 .product_name = "MidiSport 8x8",
1613 .ifnum = QUIRK_ANY_INTERFACE,
1614 .type = QUIRK_MIDI_MIDIMAN,
1615 .data = & (const struct snd_usb_midi_endpoint_info) {
1616 .out_cables = 0x01ff,
1617 .in_cables = 0x01ff
1618 }
1619 }
1620},
1621{
1622 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1623 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1624 .vendor_name = "M-Audio",
1625 .product_name = "MidiSport 8x8",
1626 .ifnum = QUIRK_ANY_INTERFACE,
1627 .type = QUIRK_MIDI_MIDIMAN,
1628 .data = & (const struct snd_usb_midi_endpoint_info) {
1629 .out_cables = 0x01ff,
1630 .in_cables = 0x01ff
1631 }
1632 }
1633},
1634{
1635 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1636 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1637 .vendor_name = "M-Audio",
1638 .product_name = "MidiSport 2x4",
1639 .ifnum = QUIRK_ANY_INTERFACE,
1640 .type = QUIRK_MIDI_MIDIMAN,
1641 .data = & (const struct snd_usb_midi_endpoint_info) {
1642 .out_cables = 0x000f,
1643 .in_cables = 0x0003
1644 }
1645 }
1646},
1647{
1648 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1649 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1650 .vendor_name = "M-Audio",
1651 .product_name = "Quattro",
1652 .ifnum = QUIRK_ANY_INTERFACE,
1653 .type = QUIRK_COMPOSITE,
1654 .data = & (const struct snd_usb_audio_quirk[]) {
1655 /*
1656 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1657 * and share endpoints with the other interfaces.
1658 * Ignore them. The other interfaces can do 24 bits,
1659 * but captured samples are big-endian (see usbaudio.c).
1660 */
1661 {
1662 .ifnum = 0,
1663 .type = QUIRK_IGNORE_INTERFACE
1664 },
1665 {
1666 .ifnum = 1,
1667 .type = QUIRK_IGNORE_INTERFACE
1668 },
1669 {
1670 .ifnum = 2,
1671 .type = QUIRK_IGNORE_INTERFACE
1672 },
1673 {
1674 .ifnum = 3,
1675 .type = QUIRK_IGNORE_INTERFACE
1676 },
1677 {
1678 .ifnum = 4,
1679 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1680 },
1681 {
1682 .ifnum = 5,
1683 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1684 },
1685 {
1686 .ifnum = 6,
1687 .type = QUIRK_IGNORE_INTERFACE
1688 },
1689 {
1690 .ifnum = 7,
1691 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1692 },
1693 {
1694 .ifnum = 8,
1695 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1696 },
1697 {
1698 .ifnum = 9,
1699 .type = QUIRK_MIDI_MIDIMAN,
1700 .data = & (const struct snd_usb_midi_endpoint_info) {
1701 .out_cables = 0x0001,
1702 .in_cables = 0x0001
1703 }
1704 },
1705 {
1706 .ifnum = -1
1707 }
1708 }
1709 }
1710},
1711{
1712 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1713 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1714 .vendor_name = "M-Audio",
1715 .product_name = "AudioPhile",
1716 .ifnum = 6,
1717 .type = QUIRK_MIDI_MIDIMAN,
1718 .data = & (const struct snd_usb_midi_endpoint_info) {
1719 .out_cables = 0x0001,
1720 .in_cables = 0x0001
1721 }
1722 }
1723},
1724{
1725 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1726 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1727 .vendor_name = "M-Audio",
1728 .product_name = "Ozone",
1729 .ifnum = 3,
1730 .type = QUIRK_MIDI_MIDIMAN,
1731 .data = & (const struct snd_usb_midi_endpoint_info) {
1732 .out_cables = 0x0001,
1733 .in_cables = 0x0001
1734 }
1735 }
1736},
1737{
1738 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1739 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1740 .vendor_name = "M-Audio",
1741 .product_name = "OmniStudio",
1742 .ifnum = QUIRK_ANY_INTERFACE,
1743 .type = QUIRK_COMPOSITE,
1744 .data = & (const struct snd_usb_audio_quirk[]) {
1745 {
1746 .ifnum = 0,
1747 .type = QUIRK_IGNORE_INTERFACE
1748 },
1749 {
1750 .ifnum = 1,
1751 .type = QUIRK_IGNORE_INTERFACE
1752 },
1753 {
1754 .ifnum = 2,
1755 .type = QUIRK_IGNORE_INTERFACE
1756 },
1757 {
1758 .ifnum = 3,
1759 .type = QUIRK_IGNORE_INTERFACE
1760 },
1761 {
1762 .ifnum = 4,
1763 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1764 },
1765 {
1766 .ifnum = 5,
1767 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1768 },
1769 {
1770 .ifnum = 6,
1771 .type = QUIRK_IGNORE_INTERFACE
1772 },
1773 {
1774 .ifnum = 7,
1775 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1776 },
1777 {
1778 .ifnum = 8,
1779 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1780 },
1781 {
1782 .ifnum = 9,
1783 .type = QUIRK_MIDI_MIDIMAN,
1784 .data = & (const struct snd_usb_midi_endpoint_info) {
1785 .out_cables = 0x0001,
1786 .in_cables = 0x0001
1787 }
1788 },
1789 {
1790 .ifnum = -1
1791 }
1792 }
1793 }
1794},
1795{
1796 USB_DEVICE(0x0763, 0x2019),
1797 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1798 /* .vendor_name = "M-Audio", */
1799 /* .product_name = "Ozone Academic", */
1800 .ifnum = QUIRK_ANY_INTERFACE,
1801 .type = QUIRK_COMPOSITE,
1802 .data = & (const struct snd_usb_audio_quirk[]) {
1803 {
1804 .ifnum = 0,
1805 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1806 },
1807 {
1808 .ifnum = 1,
1809 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1810 },
1811 {
1812 .ifnum = 2,
1813 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1814 },
1815 {
1816 .ifnum = 3,
1817 .type = QUIRK_MIDI_MIDIMAN,
1818 .data = & (const struct snd_usb_midi_endpoint_info) {
1819 .out_cables = 0x0001,
1820 .in_cables = 0x0001
1821 }
1822 },
1823 {
1824 .ifnum = -1
1825 }
1826 }
1827 }
1828},
1829
1830/* Casio devices */
1831{
1832 USB_DEVICE(0x07cf, 0x6801),
1833 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1834 .vendor_name = "Casio",
1835 .product_name = "PL-40R",
1836 .ifnum = 0,
1837 .type = QUIRK_MIDI_YAMAHA
1838 }
1839},
1840{
1841 /* this ID is used by several devices without a product ID */
1842 USB_DEVICE(0x07cf, 0x6802),
1843 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1844 .vendor_name = "Casio",
1845 .product_name = "Keyboard",
1846 .ifnum = 0,
1847 .type = QUIRK_MIDI_YAMAHA
1848 }
1849},
1850
1851/* Mark of the Unicorn devices */
1852{
1853 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1854 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1855 USB_DEVICE_ID_MATCH_PRODUCT |
1856 USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
1857 .idVendor = 0x07fd,
1858 .idProduct = 0x0001,
1859 .bDeviceSubClass = 2,
1860 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1861 .vendor_name = "MOTU",
1862 .product_name = "Fastlane",
1863 .ifnum = QUIRK_ANY_INTERFACE,
1864 .type = QUIRK_COMPOSITE,
1865 .data = & (const struct snd_usb_audio_quirk[]) {
1866 {
1867 .ifnum = 0,
1868 .type = QUIRK_MIDI_FASTLANE
1869 },
1870 {
1871 .ifnum = 1,
1872 .type = QUIRK_IGNORE_INTERFACE
1873 },
1874 {
1875 .ifnum = -1
1876 }
1877 }
1878 }
1879},
1880
1881/* Emagic devices */
1882{
1883 USB_DEVICE(0x086a, 0x0001),
1884 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1885 .vendor_name = "Emagic",
1886 /* .product_name = "Unitor8", */
1887 .ifnum = 2,
1888 .type = QUIRK_MIDI_EMAGIC,
1889 .data = & (const struct snd_usb_midi_endpoint_info) {
1890 .out_cables = 0x80ff,
1891 .in_cables = 0x80ff
1892 }
1893 }
1894},
1895{
1896 USB_DEVICE(0x086a, 0x0002),
1897 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1898 .vendor_name = "Emagic",
1899 /* .product_name = "AMT8", */
1900 .ifnum = 2,
1901 .type = QUIRK_MIDI_EMAGIC,
1902 .data = & (const struct snd_usb_midi_endpoint_info) {
1903 .out_cables = 0x80ff,
1904 .in_cables = 0x80ff
1905 }
1906 }
1907},
1908{
1909 USB_DEVICE(0x086a, 0x0003),
1910 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1911 .vendor_name = "Emagic",
1912 /* .product_name = "MT4", */
1913 .ifnum = 2,
1914 .type = QUIRK_MIDI_EMAGIC,
1915 .data = & (const struct snd_usb_midi_endpoint_info) {
1916 .out_cables = 0x800f,
1917 .in_cables = 0x8003
1918 }
1919 }
1920},
1921
1922/* TerraTec devices */
1923{
1924 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
1925 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1926 .vendor_name = "TerraTec",
1927 .product_name = "PHASE 26",
1928 .ifnum = 3,
1929 .type = QUIRK_MIDI_STANDARD_INTERFACE
1930 }
1931},
1932{
1933 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1934 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1935 .vendor_name = "TerraTec",
1936 .product_name = "PHASE 26",
1937 .ifnum = 3,
1938 .type = QUIRK_MIDI_STANDARD_INTERFACE
1939 }
1940},
1941{
1942 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
1943 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1944 .vendor_name = "TerraTec",
1945 .product_name = "PHASE 26",
1946 .ifnum = 3,
1947 .type = QUIRK_MIDI_STANDARD_INTERFACE
1948 }
1949},
1950{
1951 USB_DEVICE(0x0ccd, 0x0028),
1952 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1953 .vendor_name = "TerraTec",
1954 .product_name = "Aureon5.1MkII",
1955 .ifnum = QUIRK_NO_INTERFACE
1956 }
1957},
1958{
1959 USB_DEVICE(0x0ccd, 0x0035),
1960 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1961 .vendor_name = "Miditech",
1962 .product_name = "Play'n Roll",
1963 .ifnum = 0,
1964 .type = QUIRK_MIDI_CME
1965 }
1966},
1967
1968/* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
1969{
1970 USB_DEVICE(0x103d, 0x0100),
1971 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1972 .vendor_name = "Stanton",
1973 .product_name = "ScratchAmp",
1974 .ifnum = QUIRK_NO_INTERFACE
1975 }
1976},
1977{
1978 USB_DEVICE(0x103d, 0x0101),
1979 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1980 .vendor_name = "Stanton",
1981 .product_name = "ScratchAmp",
1982 .ifnum = QUIRK_NO_INTERFACE
1983 }
1984},
1985
1986/* Novation EMS devices */
1987{
1988 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
1989 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1990 .vendor_name = "Novation",
1991 .product_name = "ReMOTE Audio/XStation",
1992 .ifnum = 4,
1993 .type = QUIRK_MIDI_NOVATION
1994 }
1995},
1996{
1997 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
1998 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1999 .vendor_name = "Novation",
2000 .product_name = "Speedio",
2001 .ifnum = 3,
2002 .type = QUIRK_MIDI_NOVATION
2003 }
2004},
2005{
2006 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2007 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2008 .vendor_name = "Novation",
2009 .product_name = "ReMOTE25",
2010 .ifnum = 0,
2011 .type = QUIRK_MIDI_NOVATION
2012 }
2013},
2014
2015/* Access Music devices */
2016{
2017 /* VirusTI Desktop */
2018 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2019 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2020 .ifnum = QUIRK_ANY_INTERFACE,
2021 .type = QUIRK_COMPOSITE,
2022 .data = &(const struct snd_usb_audio_quirk[]) {
2023 {
2024 .ifnum = 3,
2025 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2026 .data = &(const struct snd_usb_midi_endpoint_info) {
2027 .out_cables = 0x0003,
2028 .in_cables = 0x0003
2029 }
2030 },
2031 {
2032 .ifnum = 4,
2033 .type = QUIRK_IGNORE_INTERFACE
2034 },
2035 {
2036 .ifnum = -1
2037 }
2038 }
2039 }
2040},
2041
2042/* */
2043{
2044 /* aka. Serato Scratch Live DJ Box */
2045 USB_DEVICE(0x13e5, 0x0001),
2046 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2047 .vendor_name = "Rane",
2048 .product_name = "SL-1",
2049 .ifnum = QUIRK_NO_INTERFACE
2050 }
2051},
2052
2053/* Miditech devices */
2054{
2055 USB_DEVICE(0x4752, 0x0011),
2056 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2057 .vendor_name = "Miditech",
2058 .product_name = "Midistart-2",
2059 .ifnum = 0,
2060 .type = QUIRK_MIDI_CME
2061 }
2062},
2063
2064/* Central Music devices */
2065{
2066 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2067 USB_DEVICE(0x7104, 0x2202),
2068 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2069 .ifnum = 0,
2070 .type = QUIRK_MIDI_CME
2071 }
2072},
2073
2074/* Hauppauge HVR-950Q and HVR-850 */
2075{
2076 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
2077 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2078 USB_DEVICE_ID_MATCH_INT_CLASS |
2079 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2080 .bInterfaceClass = USB_CLASS_AUDIO,
2081 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2082 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2083 .vendor_name = "Hauppauge",
2084 .product_name = "HVR-950Q",
2085 .ifnum = QUIRK_ANY_INTERFACE,
2086 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2087 }
2088},
2089{
2090 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7201),
2091 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2092 USB_DEVICE_ID_MATCH_INT_CLASS |
2093 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2094 .bInterfaceClass = USB_CLASS_AUDIO,
2095 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2096 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2097 .vendor_name = "Hauppauge",
2098 .product_name = "HVR-950Q",
2099 .ifnum = QUIRK_ANY_INTERFACE,
2100 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2101 }
2102},
2103{
2104 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7202),
2105 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2106 USB_DEVICE_ID_MATCH_INT_CLASS |
2107 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2108 .bInterfaceClass = USB_CLASS_AUDIO,
2109 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2110 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2111 .vendor_name = "Hauppauge",
2112 .product_name = "HVR-950Q",
2113 .ifnum = QUIRK_ANY_INTERFACE,
2114 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2115 }
2116},
2117{
2118 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7203),
2119 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2120 USB_DEVICE_ID_MATCH_INT_CLASS |
2121 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2122 .bInterfaceClass = USB_CLASS_AUDIO,
2123 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2124 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2125 .vendor_name = "Hauppauge",
2126 .product_name = "HVR-950Q",
2127 .ifnum = QUIRK_ANY_INTERFACE,
2128 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2129 }
2130},
2131{
2132 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7204),
2133 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2134 USB_DEVICE_ID_MATCH_INT_CLASS |
2135 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2136 .bInterfaceClass = USB_CLASS_AUDIO,
2137 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2138 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2139 .vendor_name = "Hauppauge",
2140 .product_name = "HVR-950Q",
2141 .ifnum = QUIRK_ANY_INTERFACE,
2142 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2143 }
2144},
2145{
2146 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7205),
2147 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2148 USB_DEVICE_ID_MATCH_INT_CLASS |
2149 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2150 .bInterfaceClass = USB_CLASS_AUDIO,
2151 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2152 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2153 .vendor_name = "Hauppauge",
2154 .product_name = "HVR-950Q",
2155 .ifnum = QUIRK_ANY_INTERFACE,
2156 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2157 }
2158},
2159{
2160 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7250),
2161 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2162 USB_DEVICE_ID_MATCH_INT_CLASS |
2163 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2164 .bInterfaceClass = USB_CLASS_AUDIO,
2165 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2166 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2167 .vendor_name = "Hauppauge",
2168 .product_name = "HVR-950Q",
2169 .ifnum = QUIRK_ANY_INTERFACE,
2170 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2171 }
2172},
2173{
2174 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7230),
2175 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2176 USB_DEVICE_ID_MATCH_INT_CLASS |
2177 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2178 .bInterfaceClass = USB_CLASS_AUDIO,
2179 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2180 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2181 .vendor_name = "Hauppauge",
2182 .product_name = "HVR-850",
2183 .ifnum = QUIRK_ANY_INTERFACE,
2184 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2185 }
2186},
2187
2188/* Digidesign Mbox */
2189{
2190 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2191 USB_DEVICE(0x0dba, 0x1000),
2192 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2193 .vendor_name = "Digidesign",
2194 .product_name = "MBox",
2195 .ifnum = QUIRK_ANY_INTERFACE,
2196 .type = QUIRK_COMPOSITE,
2197 .data = (const struct snd_usb_audio_quirk[]){
2198 {
2199 .ifnum = 0,
2200 .type = QUIRK_IGNORE_INTERFACE,
2201 },
2202 {
2203 .ifnum = 1,
2204 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2205 .data = &(const struct audioformat) {
2206 .format = SNDRV_PCM_FORMAT_S24_3BE,
2207 .channels = 2,
2208 .iface = 1,
2209 .altsetting = 1,
2210 .altset_idx = 1,
2211 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2212 .endpoint = 0x02,
2213 .ep_attr = 0x01,
2214 .maxpacksize = 0x130,
2215 .rates = SNDRV_PCM_RATE_44100 |
2216 SNDRV_PCM_RATE_48000,
2217 .rate_min = 44100,
2218 .rate_max = 48000,
2219 .nr_rates = 2,
2220 .rate_table = (unsigned int[]) {
2221 44100, 48000
2222 }
2223 }
2224 },
2225 {
2226 .ifnum = -1
2227 }
2228 }
2229
2230 }
2231},
2232
2233{
2234 /*
2235 * Some USB MIDI devices don't have an audio control interface,
2236 * so we have to grab MIDI streaming interfaces here.
2237 */
2238 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
2239 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2240 .bInterfaceClass = USB_CLASS_AUDIO,
2241 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
2242 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2243 .ifnum = QUIRK_ANY_INTERFACE,
2244 .type = QUIRK_MIDI_STANDARD_INTERFACE
2245 }
2246},
2247
2248#undef USB_DEVICE_VENDOR_SPEC
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-04 07:51:03 -0500