projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-rc-fixes-2.6
[deliverable/linux.git] / sound / usb / usbquirks.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 /*
43 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
44 * class matches do not take effect without an explicit ID match.
45 */
46 {
47 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
48 USB_DEVICE_ID_MATCH_INT_CLASS |
49 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
50 .idVendor = 0x046d,
51 .idProduct = 0x0850,
52 .bInterfaceClass = USB_CLASS_AUDIO,
53 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
54 },
55 {
56 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
57 USB_DEVICE_ID_MATCH_INT_CLASS |
58 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
59 .idVendor = 0x046d,
60 .idProduct = 0x08f0,
61 .bInterfaceClass = USB_CLASS_AUDIO,
62 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
63 },
64 {
65 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
66 USB_DEVICE_ID_MATCH_INT_CLASS |
67 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
68 .idVendor = 0x046d,
69 .idProduct = 0x08f6,
70 .bInterfaceClass = USB_CLASS_AUDIO,
71 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
72 },
73
74 /*
75 * Yamaha devices
76 */
77
78 #define YAMAHA_DEVICE(id, name) { \
79 USB_DEVICE(0x0499, id), \
80 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
81 .vendor_name = "Yamaha", \
82 .product_name = name, \
83 .ifnum = QUIRK_ANY_INTERFACE, \
84 .type = QUIRK_MIDI_YAMAHA \
85 } \
86 }
87 #define YAMAHA_INTERFACE(id, intf, name) { \
88 USB_DEVICE_VENDOR_SPEC(0x0499, id), \
89 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
90 .vendor_name = "Yamaha", \
91 .product_name = name, \
92 .ifnum = intf, \
93 .type = QUIRK_MIDI_YAMAHA \
94 } \
95 }
96 YAMAHA_DEVICE(0x1000, "UX256"),
97 YAMAHA_DEVICE(0x1001, "MU1000"),
98 YAMAHA_DEVICE(0x1002, "MU2000"),
99 YAMAHA_DEVICE(0x1003, "MU500"),
100 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
101 YAMAHA_DEVICE(0x1005, "MOTIF6"),
102 YAMAHA_DEVICE(0x1006, "MOTIF7"),
103 YAMAHA_DEVICE(0x1007, "MOTIF8"),
104 YAMAHA_DEVICE(0x1008, "UX96"),
105 YAMAHA_DEVICE(0x1009, "UX16"),
106 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
107 YAMAHA_DEVICE(0x100c, "UC-MX"),
108 YAMAHA_DEVICE(0x100d, "UC-KX"),
109 YAMAHA_DEVICE(0x100e, "S08"),
110 YAMAHA_DEVICE(0x100f, "CLP-150"),
111 YAMAHA_DEVICE(0x1010, "CLP-170"),
112 YAMAHA_DEVICE(0x1011, "P-250"),
113 YAMAHA_DEVICE(0x1012, "TYROS"),
114 YAMAHA_DEVICE(0x1013, "PF-500"),
115 YAMAHA_DEVICE(0x1014, "S90"),
116 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
117 YAMAHA_DEVICE(0x1016, "MDP-5"),
118 YAMAHA_DEVICE(0x1017, "CVP-204"),
119 YAMAHA_DEVICE(0x1018, "CVP-206"),
120 YAMAHA_DEVICE(0x1019, "CVP-208"),
121 YAMAHA_DEVICE(0x101a, "CVP-210"),
122 YAMAHA_DEVICE(0x101b, "PSR-1100"),
123 YAMAHA_DEVICE(0x101c, "PSR-2100"),
124 YAMAHA_DEVICE(0x101d, "CLP-175"),
125 YAMAHA_DEVICE(0x101e, "PSR-K1"),
126 YAMAHA_DEVICE(0x101f, "EZ-J24"),
127 YAMAHA_DEVICE(0x1020, "EZ-250i"),
128 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
129 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
130 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
131 YAMAHA_DEVICE(0x1024, "CVP-301"),
132 YAMAHA_DEVICE(0x1025, "CVP-303"),
133 YAMAHA_DEVICE(0x1026, "CVP-305"),
134 YAMAHA_DEVICE(0x1027, "CVP-307"),
135 YAMAHA_DEVICE(0x1028, "CVP-309"),
136 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
137 YAMAHA_DEVICE(0x102a, "PSR-1500"),
138 YAMAHA_DEVICE(0x102b, "PSR-3000"),
139 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
140 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
141 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
142 YAMAHA_DEVICE(0x1032, "DGX-305"),
143 YAMAHA_DEVICE(0x1033, "DGX-505"),
144 YAMAHA_DEVICE(0x1034, NULL),
145 YAMAHA_DEVICE(0x1035, NULL),
146 YAMAHA_DEVICE(0x1036, NULL),
147 YAMAHA_DEVICE(0x1037, NULL),
148 YAMAHA_DEVICE(0x1038, NULL),
149 YAMAHA_DEVICE(0x1039, NULL),
150 YAMAHA_DEVICE(0x103a, NULL),
151 YAMAHA_DEVICE(0x103b, NULL),
152 YAMAHA_DEVICE(0x103c, NULL),
153 YAMAHA_DEVICE(0x103d, NULL),
154 YAMAHA_DEVICE(0x103e, NULL),
155 YAMAHA_DEVICE(0x103f, NULL),
156 YAMAHA_DEVICE(0x1040, NULL),
157 YAMAHA_DEVICE(0x1041, NULL),
158 YAMAHA_DEVICE(0x1042, NULL),
159 YAMAHA_DEVICE(0x1043, NULL),
160 YAMAHA_DEVICE(0x1044, NULL),
161 YAMAHA_DEVICE(0x1045, NULL),
162 YAMAHA_DEVICE(0x2000, "DGP-7"),
163 YAMAHA_DEVICE(0x2001, "DGP-5"),
164 YAMAHA_DEVICE(0x2002, NULL),
165 YAMAHA_DEVICE(0x5000, "CS1D"),
166 YAMAHA_DEVICE(0x5001, "DSP1D"),
167 YAMAHA_DEVICE(0x5002, "DME32"),
168 YAMAHA_DEVICE(0x5003, "DM2000"),
169 YAMAHA_DEVICE(0x5004, "02R96"),
170 YAMAHA_DEVICE(0x5005, "ACU16-C"),
171 YAMAHA_DEVICE(0x5006, "NHB32-C"),
172 YAMAHA_DEVICE(0x5007, "DM1000"),
173 YAMAHA_DEVICE(0x5008, "01V96"),
174 YAMAHA_DEVICE(0x5009, "SPX2000"),
175 YAMAHA_DEVICE(0x500a, "PM5D"),
176 YAMAHA_DEVICE(0x500b, "DME64N"),
177 YAMAHA_DEVICE(0x500c, "DME24N"),
178 YAMAHA_DEVICE(0x500d, NULL),
179 YAMAHA_DEVICE(0x500e, NULL),
180 YAMAHA_DEVICE(0x500f, NULL),
181 YAMAHA_DEVICE(0x7000, "DTX"),
182 YAMAHA_DEVICE(0x7010, "UB99"),
183 #undef YAMAHA_DEVICE
184 #undef YAMAHA_INTERFACE
185
186 /*
187 * Roland/RolandED/Edirol/BOSS devices
188 */
189 {
190 USB_DEVICE(0x0582, 0x0000),
191 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
192 .vendor_name = "Roland",
193 .product_name = "UA-100",
194 .ifnum = QUIRK_ANY_INTERFACE,
195 .type = QUIRK_COMPOSITE,
196 .data = (const struct snd_usb_audio_quirk[]) {
197 {
198 .ifnum = 0,
199 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
200 .data = & (const struct audioformat) {
201 .format = SNDRV_PCM_FORMAT_S16_LE,
202 .channels = 4,
203 .iface = 0,
204 .altsetting = 1,
205 .altset_idx = 1,
206 .attributes = 0,
207 .endpoint = 0x01,
208 .ep_attr = 0x09,
209 .rates = SNDRV_PCM_RATE_CONTINUOUS,
210 .rate_min = 44100,
211 .rate_max = 44100,
212 }
213 },
214 {
215 .ifnum = 1,
216 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
217 .data = & (const struct audioformat) {
218 .format = SNDRV_PCM_FORMAT_S16_LE,
219 .channels = 2,
220 .iface = 1,
221 .altsetting = 1,
222 .altset_idx = 1,
223 .attributes = EP_CS_ATTR_FILL_MAX,
224 .endpoint = 0x81,
225 .ep_attr = 0x05,
226 .rates = SNDRV_PCM_RATE_CONTINUOUS,
227 .rate_min = 44100,
228 .rate_max = 44100,
229 }
230 },
231 {
232 .ifnum = 2,
233 .type = QUIRK_MIDI_FIXED_ENDPOINT,
234 .data = & (const struct snd_usb_midi_endpoint_info) {
235 .out_cables = 0x0007,
236 .in_cables = 0x0007
237 }
238 },
239 {
240 .ifnum = -1
241 }
242 }
243 }
244 },
245 {
246 USB_DEVICE(0x0582, 0x0002),
247 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
248 .vendor_name = "EDIROL",
249 .product_name = "UM-4",
250 .ifnum = QUIRK_ANY_INTERFACE,
251 .type = QUIRK_COMPOSITE,
252 .data = (const struct snd_usb_audio_quirk[]) {
253 {
254 .ifnum = 0,
255 .type = QUIRK_IGNORE_INTERFACE
256 },
257 {
258 .ifnum = 1,
259 .type = QUIRK_IGNORE_INTERFACE
260 },
261 {
262 .ifnum = 2,
263 .type = QUIRK_MIDI_FIXED_ENDPOINT,
264 .data = & (const struct snd_usb_midi_endpoint_info) {
265 .out_cables = 0x000f,
266 .in_cables = 0x000f
267 }
268 },
269 {
270 .ifnum = -1
271 }
272 }
273 }
274 },
275 {
276 USB_DEVICE(0x0582, 0x0003),
277 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
278 .vendor_name = "Roland",
279 .product_name = "SC-8850",
280 .ifnum = QUIRK_ANY_INTERFACE,
281 .type = QUIRK_COMPOSITE,
282 .data = (const struct snd_usb_audio_quirk[]) {
283 {
284 .ifnum = 0,
285 .type = QUIRK_IGNORE_INTERFACE
286 },
287 {
288 .ifnum = 1,
289 .type = QUIRK_IGNORE_INTERFACE
290 },
291 {
292 .ifnum = 2,
293 .type = QUIRK_MIDI_FIXED_ENDPOINT,
294 .data = & (const struct snd_usb_midi_endpoint_info) {
295 .out_cables = 0x003f,
296 .in_cables = 0x003f
297 }
298 },
299 {
300 .ifnum = -1
301 }
302 }
303 }
304 },
305 {
306 USB_DEVICE(0x0582, 0x0004),
307 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
308 .vendor_name = "Roland",
309 .product_name = "U-8",
310 .ifnum = QUIRK_ANY_INTERFACE,
311 .type = QUIRK_COMPOSITE,
312 .data = (const struct snd_usb_audio_quirk[]) {
313 {
314 .ifnum = 0,
315 .type = QUIRK_IGNORE_INTERFACE
316 },
317 {
318 .ifnum = 1,
319 .type = QUIRK_IGNORE_INTERFACE
320 },
321 {
322 .ifnum = 2,
323 .type = QUIRK_MIDI_FIXED_ENDPOINT,
324 .data = & (const struct snd_usb_midi_endpoint_info) {
325 .out_cables = 0x0005,
326 .in_cables = 0x0005
327 }
328 },
329 {
330 .ifnum = -1
331 }
332 }
333 }
334 },
335 {
336 /* Has ID 0x0099 when not in "Advanced Driver" mode.
337 * The UM-2EX has only one input, but we cannot detect this. */
338 USB_DEVICE(0x0582, 0x0005),
339 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
340 .vendor_name = "EDIROL",
341 .product_name = "UM-2",
342 .ifnum = QUIRK_ANY_INTERFACE,
343 .type = QUIRK_COMPOSITE,
344 .data = (const struct snd_usb_audio_quirk[]) {
345 {
346 .ifnum = 0,
347 .type = QUIRK_IGNORE_INTERFACE
348 },
349 {
350 .ifnum = 1,
351 .type = QUIRK_IGNORE_INTERFACE
352 },
353 {
354 .ifnum = 2,
355 .type = QUIRK_MIDI_FIXED_ENDPOINT,
356 .data = & (const struct snd_usb_midi_endpoint_info) {
357 .out_cables = 0x0003,
358 .in_cables = 0x0003
359 }
360 },
361 {
362 .ifnum = -1
363 }
364 }
365 }
366 },
367 {
368 USB_DEVICE(0x0582, 0x0007),
369 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
370 .vendor_name = "Roland",
371 .product_name = "SC-8820",
372 .ifnum = QUIRK_ANY_INTERFACE,
373 .type = QUIRK_COMPOSITE,
374 .data = (const struct snd_usb_audio_quirk[]) {
375 {
376 .ifnum = 0,
377 .type = QUIRK_IGNORE_INTERFACE
378 },
379 {
380 .ifnum = 1,
381 .type = QUIRK_IGNORE_INTERFACE
382 },
383 {
384 .ifnum = 2,
385 .type = QUIRK_MIDI_FIXED_ENDPOINT,
386 .data = & (const struct snd_usb_midi_endpoint_info) {
387 .out_cables = 0x0013,
388 .in_cables = 0x0013
389 }
390 },
391 {
392 .ifnum = -1
393 }
394 }
395 }
396 },
397 {
398 USB_DEVICE(0x0582, 0x0008),
399 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
400 .vendor_name = "Roland",
401 .product_name = "PC-300",
402 .ifnum = QUIRK_ANY_INTERFACE,
403 .type = QUIRK_COMPOSITE,
404 .data = (const struct snd_usb_audio_quirk[]) {
405 {
406 .ifnum = 0,
407 .type = QUIRK_IGNORE_INTERFACE
408 },
409 {
410 .ifnum = 1,
411 .type = QUIRK_IGNORE_INTERFACE
412 },
413 {
414 .ifnum = 2,
415 .type = QUIRK_MIDI_FIXED_ENDPOINT,
416 .data = & (const struct snd_usb_midi_endpoint_info) {
417 .out_cables = 0x0001,
418 .in_cables = 0x0001
419 }
420 },
421 {
422 .ifnum = -1
423 }
424 }
425 }
426 },
427 {
428 /* has ID 0x009d when not in "Advanced Driver" mode */
429 USB_DEVICE(0x0582, 0x0009),
430 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
431 .vendor_name = "EDIROL",
432 .product_name = "UM-1",
433 .ifnum = QUIRK_ANY_INTERFACE,
434 .type = QUIRK_COMPOSITE,
435 .data = (const struct snd_usb_audio_quirk[]) {
436 {
437 .ifnum = 0,
438 .type = QUIRK_IGNORE_INTERFACE
439 },
440 {
441 .ifnum = 1,
442 .type = QUIRK_IGNORE_INTERFACE
443 },
444 {
445 .ifnum = 2,
446 .type = QUIRK_MIDI_FIXED_ENDPOINT,
447 .data = & (const struct snd_usb_midi_endpoint_info) {
448 .out_cables = 0x0001,
449 .in_cables = 0x0001
450 }
451 },
452 {
453 .ifnum = -1
454 }
455 }
456 }
457 },
458 {
459 USB_DEVICE(0x0582, 0x000b),
460 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
461 .vendor_name = "Roland",
462 .product_name = "SK-500",
463 .ifnum = QUIRK_ANY_INTERFACE,
464 .type = QUIRK_COMPOSITE,
465 .data = (const struct snd_usb_audio_quirk[]) {
466 {
467 .ifnum = 0,
468 .type = QUIRK_IGNORE_INTERFACE
469 },
470 {
471 .ifnum = 1,
472 .type = QUIRK_IGNORE_INTERFACE
473 },
474 {
475 .ifnum = 2,
476 .type = QUIRK_MIDI_FIXED_ENDPOINT,
477 .data = & (const struct snd_usb_midi_endpoint_info) {
478 .out_cables = 0x0013,
479 .in_cables = 0x0013
480 }
481 },
482 {
483 .ifnum = -1
484 }
485 }
486 }
487 },
488 {
489 /* thanks to Emiliano Grilli <emillo@libero.it>
490 * for helping researching this data */
491 USB_DEVICE(0x0582, 0x000c),
492 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
493 .vendor_name = "Roland",
494 .product_name = "SC-D70",
495 .ifnum = QUIRK_ANY_INTERFACE,
496 .type = QUIRK_COMPOSITE,
497 .data = (const struct snd_usb_audio_quirk[]) {
498 {
499 .ifnum = 0,
500 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
501 .data = & (const struct audioformat) {
502 .format = SNDRV_PCM_FORMAT_S24_3LE,
503 .channels = 2,
504 .iface = 0,
505 .altsetting = 1,
506 .altset_idx = 1,
507 .attributes = 0,
508 .endpoint = 0x01,
509 .ep_attr = 0x01,
510 .rates = SNDRV_PCM_RATE_CONTINUOUS,
511 .rate_min = 44100,
512 .rate_max = 44100,
513 }
514 },
515 {
516 .ifnum = 1,
517 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
518 .data = & (const struct audioformat) {
519 .format = SNDRV_PCM_FORMAT_S24_3LE,
520 .channels = 2,
521 .iface = 1,
522 .altsetting = 1,
523 .altset_idx = 1,
524 .attributes = 0,
525 .endpoint = 0x81,
526 .ep_attr = 0x01,
527 .rates = SNDRV_PCM_RATE_CONTINUOUS,
528 .rate_min = 44100,
529 .rate_max = 44100,
530 }
531 },
532 {
533 .ifnum = 2,
534 .type = QUIRK_MIDI_FIXED_ENDPOINT,
535 .data = & (const struct snd_usb_midi_endpoint_info) {
536 .out_cables = 0x0007,
537 .in_cables = 0x0007
538 }
539 },
540 {
541 .ifnum = -1
542 }
543 }
544 }
545 },
546 { /*
547 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
548 * If the advanced mode switch at the back of the unit is off, the
549 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
550 * but offers only 16-bit PCM.
551 * In advanced mode, the UA-5 will output S24_3LE samples (two
552 * channels) at the rate indicated on the front switch, including
553 * the 96kHz sample rate.
554 */
555 USB_DEVICE(0x0582, 0x0010),
556 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
557 .vendor_name = "EDIROL",
558 .product_name = "UA-5",
559 .ifnum = QUIRK_ANY_INTERFACE,
560 .type = QUIRK_COMPOSITE,
561 .data = (const struct snd_usb_audio_quirk[]) {
562 {
563 .ifnum = 1,
564 .type = QUIRK_AUDIO_STANDARD_INTERFACE
565 },
566 {
567 .ifnum = 2,
568 .type = QUIRK_AUDIO_STANDARD_INTERFACE
569 },
570 {
571 .ifnum = -1
572 }
573 }
574 }
575 },
576 {
577 /* has ID 0x0013 when not in "Advanced Driver" mode */
578 USB_DEVICE(0x0582, 0x0012),
579 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
580 .vendor_name = "Roland",
581 .product_name = "XV-5050",
582 .ifnum = 0,
583 .type = QUIRK_MIDI_FIXED_ENDPOINT,
584 .data = & (const struct snd_usb_midi_endpoint_info) {
585 .out_cables = 0x0001,
586 .in_cables = 0x0001
587 }
588 }
589 },
590 {
591 /* has ID 0x0015 when not in "Advanced Driver" mode */
592 USB_DEVICE(0x0582, 0x0014),
593 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
594 .vendor_name = "EDIROL",
595 .product_name = "UM-880",
596 .ifnum = 0,
597 .type = QUIRK_MIDI_FIXED_ENDPOINT,
598 .data = & (const struct snd_usb_midi_endpoint_info) {
599 .out_cables = 0x01ff,
600 .in_cables = 0x01ff
601 }
602 }
603 },
604 {
605 /* has ID 0x0017 when not in "Advanced Driver" mode */
606 USB_DEVICE(0x0582, 0x0016),
607 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
608 .vendor_name = "EDIROL",
609 .product_name = "SD-90",
610 .ifnum = QUIRK_ANY_INTERFACE,
611 .type = QUIRK_COMPOSITE,
612 .data = (const struct snd_usb_audio_quirk[]) {
613 {
614 .ifnum = 0,
615 .type = QUIRK_IGNORE_INTERFACE
616 },
617 {
618 .ifnum = 1,
619 .type = QUIRK_IGNORE_INTERFACE
620 },
621 {
622 .ifnum = 2,
623 .type = QUIRK_MIDI_FIXED_ENDPOINT,
624 .data = & (const struct snd_usb_midi_endpoint_info) {
625 .out_cables = 0x000f,
626 .in_cables = 0x000f
627 }
628 },
629 {
630 .ifnum = -1
631 }
632 }
633 }
634 },
635 {
636 /* has ID 0x001c when not in "Advanced Driver" mode */
637 USB_DEVICE(0x0582, 0x001b),
638 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
639 .vendor_name = "Roland",
640 .product_name = "MMP-2",
641 .ifnum = QUIRK_ANY_INTERFACE,
642 .type = QUIRK_COMPOSITE,
643 .data = (const struct snd_usb_audio_quirk[]) {
644 {
645 .ifnum = 0,
646 .type = QUIRK_IGNORE_INTERFACE
647 },
648 {
649 .ifnum = 1,
650 .type = QUIRK_IGNORE_INTERFACE
651 },
652 {
653 .ifnum = 2,
654 .type = QUIRK_MIDI_FIXED_ENDPOINT,
655 .data = & (const struct snd_usb_midi_endpoint_info) {
656 .out_cables = 0x0001,
657 .in_cables = 0x0001
658 }
659 },
660 {
661 .ifnum = -1
662 }
663 }
664 }
665 },
666 {
667 /* has ID 0x001e when not in "Advanced Driver" mode */
668 USB_DEVICE(0x0582, 0x001d),
669 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
670 .vendor_name = "Roland",
671 .product_name = "V-SYNTH",
672 .ifnum = 0,
673 .type = QUIRK_MIDI_FIXED_ENDPOINT,
674 .data = & (const struct snd_usb_midi_endpoint_info) {
675 .out_cables = 0x0001,
676 .in_cables = 0x0001
677 }
678 }
679 },
680 {
681 /* has ID 0x0024 when not in "Advanced Driver" mode */
682 USB_DEVICE(0x0582, 0x0023),
683 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
684 .vendor_name = "EDIROL",
685 .product_name = "UM-550",
686 .ifnum = 0,
687 .type = QUIRK_MIDI_FIXED_ENDPOINT,
688 .data = & (const struct snd_usb_midi_endpoint_info) {
689 .out_cables = 0x003f,
690 .in_cables = 0x003f
691 }
692 }
693 },
694 {
695 /*
696 * This quirk is for the "Advanced Driver" mode. If off, the UA-20
697 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
698 * and no MIDI.
699 */
700 USB_DEVICE(0x0582, 0x0025),
701 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
702 .vendor_name = "EDIROL",
703 .product_name = "UA-20",
704 .ifnum = QUIRK_ANY_INTERFACE,
705 .type = QUIRK_COMPOSITE,
706 .data = (const struct snd_usb_audio_quirk[]) {
707 {
708 .ifnum = 0,
709 .type = QUIRK_IGNORE_INTERFACE
710 },
711 {
712 .ifnum = 1,
713 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
714 .data = & (const struct audioformat) {
715 .format = SNDRV_PCM_FORMAT_S24_3LE,
716 .channels = 2,
717 .iface = 1,
718 .altsetting = 1,
719 .altset_idx = 1,
720 .attributes = 0,
721 .endpoint = 0x01,
722 .ep_attr = 0x01,
723 .rates = SNDRV_PCM_RATE_CONTINUOUS,
724 .rate_min = 44100,
725 .rate_max = 44100,
726 }
727 },
728 {
729 .ifnum = 2,
730 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
731 .data = & (const struct audioformat) {
732 .format = SNDRV_PCM_FORMAT_S24_3LE,
733 .channels = 2,
734 .iface = 2,
735 .altsetting = 1,
736 .altset_idx = 1,
737 .attributes = 0,
738 .endpoint = 0x82,
739 .ep_attr = 0x01,
740 .rates = SNDRV_PCM_RATE_CONTINUOUS,
741 .rate_min = 44100,
742 .rate_max = 44100,
743 }
744 },
745 {
746 .ifnum = 3,
747 .type = QUIRK_MIDI_FIXED_ENDPOINT,
748 .data = & (const struct snd_usb_midi_endpoint_info) {
749 .out_cables = 0x0001,
750 .in_cables = 0x0001
751 }
752 },
753 {
754 .ifnum = -1
755 }
756 }
757 }
758 },
759 {
760 /* has ID 0x0028 when not in "Advanced Driver" mode */
761 USB_DEVICE(0x0582, 0x0027),
762 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
763 .vendor_name = "EDIROL",
764 .product_name = "SD-20",
765 .ifnum = 0,
766 .type = QUIRK_MIDI_FIXED_ENDPOINT,
767 .data = & (const struct snd_usb_midi_endpoint_info) {
768 .out_cables = 0x0003,
769 .in_cables = 0x0007
770 }
771 }
772 },
773 {
774 /* has ID 0x002a when not in "Advanced Driver" mode */
775 USB_DEVICE(0x0582, 0x0029),
776 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
777 .vendor_name = "EDIROL",
778 .product_name = "SD-80",
779 .ifnum = 0,
780 .type = QUIRK_MIDI_FIXED_ENDPOINT,
781 .data = & (const struct snd_usb_midi_endpoint_info) {
782 .out_cables = 0x000f,
783 .in_cables = 0x000f
784 }
785 }
786 },
787 { /*
788 * This quirk is for the "Advanced" modes of the Edirol UA-700.
789 * If the sample format switch is not in an advanced setting, the
790 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
791 * but offers only 16-bit PCM and no MIDI.
792 */
793 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
794 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
795 .vendor_name = "EDIROL",
796 .product_name = "UA-700",
797 .ifnum = QUIRK_ANY_INTERFACE,
798 .type = QUIRK_COMPOSITE,
799 .data = (const struct snd_usb_audio_quirk[]) {
800 {
801 .ifnum = 1,
802 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
803 },
804 {
805 .ifnum = 2,
806 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
807 },
808 {
809 .ifnum = 3,
810 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
811 },
812 {
813 .ifnum = -1
814 }
815 }
816 }
817 },
818 {
819 /* has ID 0x002e when not in "Advanced Driver" mode */
820 USB_DEVICE(0x0582, 0x002d),
821 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
822 .vendor_name = "Roland",
823 .product_name = "XV-2020",
824 .ifnum = 0,
825 .type = QUIRK_MIDI_FIXED_ENDPOINT,
826 .data = & (const struct snd_usb_midi_endpoint_info) {
827 .out_cables = 0x0001,
828 .in_cables = 0x0001
829 }
830 }
831 },
832 {
833 /* has ID 0x0030 when not in "Advanced Driver" mode */
834 USB_DEVICE(0x0582, 0x002f),
835 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
836 .vendor_name = "Roland",
837 .product_name = "VariOS",
838 .ifnum = 0,
839 .type = QUIRK_MIDI_FIXED_ENDPOINT,
840 .data = & (const struct snd_usb_midi_endpoint_info) {
841 .out_cables = 0x0007,
842 .in_cables = 0x0007
843 }
844 }
845 },
846 {
847 /* has ID 0x0034 when not in "Advanced Driver" mode */
848 USB_DEVICE(0x0582, 0x0033),
849 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
850 .vendor_name = "EDIROL",
851 .product_name = "PCR",
852 .ifnum = 0,
853 .type = QUIRK_MIDI_FIXED_ENDPOINT,
854 .data = & (const struct snd_usb_midi_endpoint_info) {
855 .out_cables = 0x0003,
856 .in_cables = 0x0007
857 }
858 }
859 },
860 /* TODO: add Roland M-1000 support */
861 {
862 /*
863 * Has ID 0x0038 when not in "Advanced Driver" mode;
864 * later revisions use IDs 0x0054 and 0x00a2.
865 */
866 USB_DEVICE(0x0582, 0x0037),
867 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
868 .vendor_name = "Roland",
869 .product_name = "Digital Piano",
870 .ifnum = 0,
871 .type = QUIRK_MIDI_FIXED_ENDPOINT,
872 .data = & (const struct snd_usb_midi_endpoint_info) {
873 .out_cables = 0x0001,
874 .in_cables = 0x0001
875 }
876 }
877 },
878 {
879 /*
880 * This quirk is for the "Advanced Driver" mode. If off, the GS-10
881 * has ID 0x003c and is standard compliant, but has only 16-bit PCM
882 * and no MIDI.
883 */
884 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
885 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
886 .vendor_name = "BOSS",
887 .product_name = "GS-10",
888 .ifnum = QUIRK_ANY_INTERFACE,
889 .type = QUIRK_COMPOSITE,
890 .data = & (const struct snd_usb_audio_quirk[]) {
891 {
892 .ifnum = 1,
893 .type = QUIRK_AUDIO_STANDARD_INTERFACE
894 },
895 {
896 .ifnum = 2,
897 .type = QUIRK_AUDIO_STANDARD_INTERFACE
898 },
899 {
900 .ifnum = 3,
901 .type = QUIRK_MIDI_STANDARD_INTERFACE
902 },
903 {
904 .ifnum = -1
905 }
906 }
907 }
908 },
909 {
910 /* has ID 0x0041 when not in "Advanced Driver" mode */
911 USB_DEVICE(0x0582, 0x0040),
912 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
913 .vendor_name = "Roland",
914 .product_name = "GI-20",
915 .ifnum = 0,
916 .type = QUIRK_MIDI_FIXED_ENDPOINT,
917 .data = & (const struct snd_usb_midi_endpoint_info) {
918 .out_cables = 0x0001,
919 .in_cables = 0x0001
920 }
921 }
922 },
923 {
924 /* has ID 0x0043 when not in "Advanced Driver" mode */
925 USB_DEVICE(0x0582, 0x0042),
926 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
927 .vendor_name = "Roland",
928 .product_name = "RS-70",
929 .ifnum = 0,
930 .type = QUIRK_MIDI_FIXED_ENDPOINT,
931 .data = & (const struct snd_usb_midi_endpoint_info) {
932 .out_cables = 0x0001,
933 .in_cables = 0x0001
934 }
935 }
936 },
937 {
938 USB_DEVICE(0x0582, 0x0044),
939 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
940 .vendor_name = "Roland",
941 .product_name = "UA-1000",
942 .ifnum = QUIRK_ANY_INTERFACE,
943 .type = QUIRK_COMPOSITE,
944 .data = (const struct snd_usb_audio_quirk[]) {
945 {
946 .ifnum = 1,
947 .type = QUIRK_AUDIO_EDIROL_UA1000
948 },
949 {
950 .ifnum = 2,
951 .type = QUIRK_AUDIO_EDIROL_UA1000
952 },
953 {
954 .ifnum = 3,
955 .type = QUIRK_MIDI_FIXED_ENDPOINT,
956 .data = & (const struct snd_usb_midi_endpoint_info) {
957 .out_cables = 0x0003,
958 .in_cables = 0x0003
959 }
960 },
961 {
962 .ifnum = -1
963 }
964 }
965 }
966 },
967 {
968 /* has ID 0x004a when not in "Advanced Driver" mode */
969 USB_DEVICE(0x0582, 0x0048),
970 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
971 .vendor_name = "EDIROL",
972 .product_name = "UR-80",
973 .ifnum = 0,
974 .type = QUIRK_MIDI_FIXED_ENDPOINT,
975 .data = & (const struct snd_usb_midi_endpoint_info) {
976 .out_cables = 0x0003,
977 .in_cables = 0x0007
978 }
979 }
980 },
981 /* TODO: add Edirol M-100FX support */
982 {
983 /* has ID 0x004e when not in "Advanced Driver" mode */
984 USB_DEVICE(0x0582, 0x004c),
985 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
986 .vendor_name = "EDIROL",
987 .product_name = "PCR-A",
988 .ifnum = QUIRK_ANY_INTERFACE,
989 .type = QUIRK_COMPOSITE,
990 .data = (const struct snd_usb_audio_quirk[]) {
991 {
992 .ifnum = 1,
993 .type = QUIRK_AUDIO_STANDARD_INTERFACE
994 },
995 {
996 .ifnum = 2,
997 .type = QUIRK_AUDIO_STANDARD_INTERFACE
998 },
999 {
1000 .ifnum = -1
1001 }
1002 }
1003 }
1004 },
1005 {
1006 /* has ID 0x004f when not in "Advanced Driver" mode */
1007 USB_DEVICE(0x0582, 0x004d),
1008 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1009 .vendor_name = "EDIROL",
1010 .product_name = "PCR-A",
1011 .ifnum = 0,
1012 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1013 .data = & (const struct snd_usb_midi_endpoint_info) {
1014 .out_cables = 0x0003,
1015 .in_cables = 0x0007
1016 }
1017 }
1018 },
1019 {
1020 /*
1021 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1022 * is standard compliant, but has only 16-bit PCM.
1023 */
1024 USB_DEVICE(0x0582, 0x0050),
1025 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1026 .vendor_name = "EDIROL",
1027 .product_name = "UA-3FX",
1028 .ifnum = QUIRK_ANY_INTERFACE,
1029 .type = QUIRK_COMPOSITE,
1030 .data = (const struct snd_usb_audio_quirk[]) {
1031 {
1032 .ifnum = 1,
1033 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1034 },
1035 {
1036 .ifnum = 2,
1037 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1038 },
1039 {
1040 .ifnum = -1
1041 }
1042 }
1043 }
1044 },
1045 {
1046 USB_DEVICE(0x0582, 0x0052),
1047 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1048 .vendor_name = "EDIROL",
1049 .product_name = "UM-1SX",
1050 .ifnum = 0,
1051 .type = QUIRK_MIDI_STANDARD_INTERFACE
1052 }
1053 },
1054 /* TODO: add Roland EXR support */
1055 {
1056 /* has ID 0x0067 when not in "Advanced Driver" mode */
1057 USB_DEVICE(0x0582, 0x0065),
1058 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1059 .vendor_name = "EDIROL",
1060 .product_name = "PCR-1",
1061 .ifnum = 0,
1062 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1063 .data = & (const struct snd_usb_midi_endpoint_info) {
1064 .out_cables = 0x0001,
1065 .in_cables = 0x0003
1066 }
1067 }
1068 },
1069 {
1070 /* has ID 0x006b when not in "Advanced Driver" mode */
1071 USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1072 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1073 .vendor_name = "Roland",
1074 .product_name = "SP-606",
1075 .ifnum = 3,
1076 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1077 .data = & (const struct snd_usb_midi_endpoint_info) {
1078 .out_cables = 0x0001,
1079 .in_cables = 0x0001
1080 }
1081 }
1082 },
1083 {
1084 /* has ID 0x006e when not in "Advanced Driver" mode */
1085 USB_DEVICE(0x0582, 0x006d),
1086 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1087 .vendor_name = "Roland",
1088 .product_name = "FANTOM-X",
1089 .ifnum = 0,
1090 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1091 .data = & (const struct snd_usb_midi_endpoint_info) {
1092 .out_cables = 0x0001,
1093 .in_cables = 0x0001
1094 }
1095 }
1096 },
1097 { /*
1098 * This quirk is for the "Advanced" modes of the Edirol UA-25.
1099 * If the switch is not in an advanced setting, the UA-25 has
1100 * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1101 * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1102 */
1103 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1104 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1105 .vendor_name = "EDIROL",
1106 .product_name = "UA-25",
1107 .ifnum = QUIRK_ANY_INTERFACE,
1108 .type = QUIRK_COMPOSITE,
1109 .data = (const struct snd_usb_audio_quirk[]) {
1110 {
1111 .ifnum = 0,
1112 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1113 },
1114 {
1115 .ifnum = 1,
1116 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1117 },
1118 {
1119 .ifnum = 2,
1120 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1121 },
1122 {
1123 .ifnum = -1
1124 }
1125 }
1126 }
1127 },
1128 {
1129 /* has ID 0x0076 when not in "Advanced Driver" mode */
1130 USB_DEVICE(0x0582, 0x0075),
1131 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1132 .vendor_name = "BOSS",
1133 .product_name = "DR-880",
1134 .ifnum = 0,
1135 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1136 .data = & (const struct snd_usb_midi_endpoint_info) {
1137 .out_cables = 0x0001,
1138 .in_cables = 0x0001
1139 }
1140 }
1141 },
1142 {
1143 /* has ID 0x007b when not in "Advanced Driver" mode */
1144 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1145 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1146 .vendor_name = "Roland",
1147 /* "RD" or "RD-700SX"? */
1148 .ifnum = 0,
1149 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1150 .data = & (const struct snd_usb_midi_endpoint_info) {
1151 .out_cables = 0x0003,
1152 .in_cables = 0x0003
1153 }
1154 }
1155 },
1156 /* Roland UA-101 in High-Speed Mode only */
1157 {
1158 USB_DEVICE(0x0582, 0x007d),
1159 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1160 .vendor_name = "Roland",
1161 .product_name = "UA-101",
1162 .ifnum = QUIRK_ANY_INTERFACE,
1163 .type = QUIRK_COMPOSITE,
1164 .data = (const struct snd_usb_audio_quirk[]) {
1165 {
1166 .ifnum = 0,
1167 .type = QUIRK_AUDIO_EDIROL_UA101
1168 },
1169 {
1170 .ifnum = 1,
1171 .type = QUIRK_AUDIO_EDIROL_UA101
1172 },
1173 {
1174 .ifnum = 2,
1175 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1176 .data = & (const struct snd_usb_midi_endpoint_info) {
1177 .out_cables = 0x0001,
1178 .in_cables = 0x0001
1179 }
1180 },
1181 {
1182 .ifnum = -1
1183 }
1184 }
1185 }
1186 },
1187 {
1188 /* has ID 0x0081 when not in "Advanced Driver" mode */
1189 USB_DEVICE(0x0582, 0x0080),
1190 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1191 .vendor_name = "Roland",
1192 .product_name = "G-70",
1193 .ifnum = 0,
1194 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1195 .data = & (const struct snd_usb_midi_endpoint_info) {
1196 .out_cables = 0x0001,
1197 .in_cables = 0x0001
1198 }
1199 }
1200 },
1201 /* TODO: add Roland V-SYNTH XT support */
1202 /* TODO: add BOSS GT-PRO support */
1203 {
1204 /* has ID 0x008c when not in "Advanced Driver" mode */
1205 USB_DEVICE(0x0582, 0x008b),
1206 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1207 .vendor_name = "EDIROL",
1208 .product_name = "PC-50",
1209 .ifnum = 0,
1210 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1211 .data = & (const struct snd_usb_midi_endpoint_info) {
1212 .out_cables = 0x0001,
1213 .in_cables = 0x0001
1214 }
1215 }
1216 },
1217 /* TODO: add Edirol PC-80 support */
1218 /* TODO: add Edirol UA-1EX support */
1219 {
1220 USB_DEVICE(0x0582, 0x009a),
1221 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1222 .vendor_name = "EDIROL",
1223 .product_name = "UM-3EX",
1224 .ifnum = 0,
1225 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1226 .data = & (const struct snd_usb_midi_endpoint_info) {
1227 .out_cables = 0x000f,
1228 .in_cables = 0x000f
1229 }
1230 }
1231 },
1232 /* TODO: add Edirol MD-P1 support */
1233
1234 /* Guillemot devices */
1235 {
1236 /*
1237 * This is for the "Windows Edition" where the external MIDI ports are
1238 * the only MIDI ports; the control data is reported through HID
1239 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard
1240 * compliant USB MIDI ports for external MIDI and controls.
1241 */
1242 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1243 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1244 .vendor_name = "Hercules",
1245 .product_name = "DJ Console (WE)",
1246 .ifnum = 4,
1247 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1248 .data = & (const struct snd_usb_midi_endpoint_info) {
1249 .out_cables = 0x0001,
1250 .in_cables = 0x0001
1251 }
1252 }
1253 },
1254
1255 /* Midiman/M-Audio devices */
1256 {
1257 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1258 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1259 .vendor_name = "M-Audio",
1260 .product_name = "MidiSport 2x2",
1261 .ifnum = QUIRK_ANY_INTERFACE,
1262 .type = QUIRK_MIDI_MIDIMAN,
1263 .data = & (const struct snd_usb_midi_endpoint_info) {
1264 .out_cables = 0x0003,
1265 .in_cables = 0x0003
1266 }
1267 }
1268 },
1269 {
1270 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1271 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1272 .vendor_name = "M-Audio",
1273 .product_name = "MidiSport 1x1",
1274 .ifnum = QUIRK_ANY_INTERFACE,
1275 .type = QUIRK_MIDI_MIDIMAN,
1276 .data = & (const struct snd_usb_midi_endpoint_info) {
1277 .out_cables = 0x0001,
1278 .in_cables = 0x0001
1279 }
1280 }
1281 },
1282 {
1283 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1284 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1285 .vendor_name = "M-Audio",
1286 .product_name = "Keystation",
1287 .ifnum = QUIRK_ANY_INTERFACE,
1288 .type = QUIRK_MIDI_MIDIMAN,
1289 .data = & (const struct snd_usb_midi_endpoint_info) {
1290 .out_cables = 0x0001,
1291 .in_cables = 0x0001
1292 }
1293 }
1294 },
1295 {
1296 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1297 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1298 .vendor_name = "M-Audio",
1299 .product_name = "MidiSport 4x4",
1300 .ifnum = QUIRK_ANY_INTERFACE,
1301 .type = QUIRK_MIDI_MIDIMAN,
1302 .data = & (const struct snd_usb_midi_endpoint_info) {
1303 .out_cables = 0x000f,
1304 .in_cables = 0x000f
1305 }
1306 }
1307 },
1308 {
1309 /*
1310 * For hardware revision 1.05; in the later revisions (1.10 and
1311 * 1.21), 0x1031 is the ID for the device without firmware.
1312 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1313 */
1314 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1315 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1316 .vendor_name = "M-Audio",
1317 .product_name = "MidiSport 8x8",
1318 .ifnum = QUIRK_ANY_INTERFACE,
1319 .type = QUIRK_MIDI_MIDIMAN,
1320 .data = & (const struct snd_usb_midi_endpoint_info) {
1321 .out_cables = 0x01ff,
1322 .in_cables = 0x01ff
1323 }
1324 }
1325 },
1326 {
1327 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1328 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1329 .vendor_name = "M-Audio",
1330 .product_name = "MidiSport 8x8",
1331 .ifnum = QUIRK_ANY_INTERFACE,
1332 .type = QUIRK_MIDI_MIDIMAN,
1333 .data = & (const struct snd_usb_midi_endpoint_info) {
1334 .out_cables = 0x01ff,
1335 .in_cables = 0x01ff
1336 }
1337 }
1338 },
1339 {
1340 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1341 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1342 .vendor_name = "M-Audio",
1343 .product_name = "MidiSport 2x4",
1344 .ifnum = QUIRK_ANY_INTERFACE,
1345 .type = QUIRK_MIDI_MIDIMAN,
1346 .data = & (const struct snd_usb_midi_endpoint_info) {
1347 .out_cables = 0x000f,
1348 .in_cables = 0x0003
1349 }
1350 }
1351 },
1352 {
1353 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1354 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1355 .vendor_name = "M-Audio",
1356 .product_name = "Quattro",
1357 .ifnum = QUIRK_ANY_INTERFACE,
1358 .type = QUIRK_COMPOSITE,
1359 .data = & (const struct snd_usb_audio_quirk[]) {
1360 /*
1361 * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1362 * and share endpoints with the other interfaces.
1363 * Ignore them. The other interfaces can do 24 bits,
1364 * but captured samples are big-endian (see usbaudio.c).
1365 */
1366 {
1367 .ifnum = 0,
1368 .type = QUIRK_IGNORE_INTERFACE
1369 },
1370 {
1371 .ifnum = 1,
1372 .type = QUIRK_IGNORE_INTERFACE
1373 },
1374 {
1375 .ifnum = 2,
1376 .type = QUIRK_IGNORE_INTERFACE
1377 },
1378 {
1379 .ifnum = 3,
1380 .type = QUIRK_IGNORE_INTERFACE
1381 },
1382 {
1383 .ifnum = 4,
1384 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1385 },
1386 {
1387 .ifnum = 5,
1388 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1389 },
1390 {
1391 .ifnum = 6,
1392 .type = QUIRK_IGNORE_INTERFACE
1393 },
1394 {
1395 .ifnum = 7,
1396 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1397 },
1398 {
1399 .ifnum = 8,
1400 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1401 },
1402 {
1403 .ifnum = 9,
1404 .type = QUIRK_MIDI_MIDIMAN,
1405 .data = & (const struct snd_usb_midi_endpoint_info) {
1406 .out_cables = 0x0001,
1407 .in_cables = 0x0001
1408 }
1409 },
1410 {
1411 .ifnum = -1
1412 }
1413 }
1414 }
1415 },
1416 {
1417 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1418 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1419 .vendor_name = "M-Audio",
1420 .product_name = "AudioPhile",
1421 .ifnum = 6,
1422 .type = QUIRK_MIDI_MIDIMAN,
1423 .data = & (const struct snd_usb_midi_endpoint_info) {
1424 .out_cables = 0x0001,
1425 .in_cables = 0x0001
1426 }
1427 }
1428 },
1429 {
1430 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1431 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1432 .vendor_name = "M-Audio",
1433 .product_name = "Ozone",
1434 .ifnum = 3,
1435 .type = QUIRK_MIDI_MIDIMAN,
1436 .data = & (const struct snd_usb_midi_endpoint_info) {
1437 .out_cables = 0x0001,
1438 .in_cables = 0x0001
1439 }
1440 }
1441 },
1442 {
1443 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1444 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1445 .vendor_name = "M-Audio",
1446 .product_name = "OmniStudio",
1447 .ifnum = QUIRK_ANY_INTERFACE,
1448 .type = QUIRK_COMPOSITE,
1449 .data = & (const struct snd_usb_audio_quirk[]) {
1450 {
1451 .ifnum = 0,
1452 .type = QUIRK_IGNORE_INTERFACE
1453 },
1454 {
1455 .ifnum = 1,
1456 .type = QUIRK_IGNORE_INTERFACE
1457 },
1458 {
1459 .ifnum = 2,
1460 .type = QUIRK_IGNORE_INTERFACE
1461 },
1462 {
1463 .ifnum = 3,
1464 .type = QUIRK_IGNORE_INTERFACE
1465 },
1466 {
1467 .ifnum = 4,
1468 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1469 },
1470 {
1471 .ifnum = 5,
1472 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1473 },
1474 {
1475 .ifnum = 6,
1476 .type = QUIRK_IGNORE_INTERFACE
1477 },
1478 {
1479 .ifnum = 7,
1480 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1481 },
1482 {
1483 .ifnum = 8,
1484 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1485 },
1486 {
1487 .ifnum = 9,
1488 .type = QUIRK_MIDI_MIDIMAN,
1489 .data = & (const struct snd_usb_midi_endpoint_info) {
1490 .out_cables = 0x0001,
1491 .in_cables = 0x0001
1492 }
1493 },
1494 {
1495 .ifnum = -1
1496 }
1497 }
1498 }
1499 },
1500
1501 /* Casio devices */
1502 {
1503 USB_DEVICE(0x07cf, 0x6801),
1504 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1505 .vendor_name = "Casio",
1506 .product_name = "PL-40R",
1507 .ifnum = 0,
1508 .type = QUIRK_MIDI_YAMAHA
1509 }
1510 },
1511 {
1512 /* this ID is used by several devices without a product ID */
1513 USB_DEVICE(0x07cf, 0x6802),
1514 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1515 .vendor_name = "Casio",
1516 .product_name = "Keyboard",
1517 .ifnum = 0,
1518 .type = QUIRK_MIDI_YAMAHA
1519 }
1520 },
1521
1522 /* Mark of the Unicorn devices */
1523 {
1524 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1525 .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1526 USB_DEVICE_ID_MATCH_PRODUCT |
1527 USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
1528 .idVendor = 0x07fd,
1529 .idProduct = 0x0001,
1530 .bDeviceSubClass = 2,
1531 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1532 .vendor_name = "MOTU",
1533 .product_name = "Fastlane",
1534 .ifnum = QUIRK_ANY_INTERFACE,
1535 .type = QUIRK_COMPOSITE,
1536 .data = & (const struct snd_usb_audio_quirk[]) {
1537 {
1538 .ifnum = 0,
1539 .type = QUIRK_MIDI_RAW
1540 },
1541 {
1542 .ifnum = 1,
1543 .type = QUIRK_IGNORE_INTERFACE
1544 },
1545 {
1546 .ifnum = -1
1547 }
1548 }
1549 }
1550 },
1551
1552 {
1553 /* Creative Sound Blaster MP3+ */
1554 USB_DEVICE(0x041e, 0x3010),
1555 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1556 .vendor_name = "Creative Labs",
1557 .product_name = "Sound Blaster MP3+",
1558 .ifnum = QUIRK_NO_INTERFACE
1559 }
1560
1561 },
1562
1563 /* Emagic devices */
1564 {
1565 USB_DEVICE(0x086a, 0x0001),
1566 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1567 .vendor_name = "Emagic",
1568 /* .product_name = "Unitor8", */
1569 .ifnum = 2,
1570 .type = QUIRK_MIDI_EMAGIC,
1571 .data = & (const struct snd_usb_midi_endpoint_info) {
1572 .out_cables = 0x80ff,
1573 .in_cables = 0x80ff
1574 }
1575 }
1576 },
1577 {
1578 USB_DEVICE(0x086a, 0x0002),
1579 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1580 .vendor_name = "Emagic",
1581 /* .product_name = "AMT8", */
1582 .ifnum = 2,
1583 .type = QUIRK_MIDI_EMAGIC,
1584 .data = & (const struct snd_usb_midi_endpoint_info) {
1585 .out_cables = 0x80ff,
1586 .in_cables = 0x80ff
1587 }
1588 }
1589 },
1590 {
1591 USB_DEVICE(0x086a, 0x0003),
1592 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1593 .vendor_name = "Emagic",
1594 /* .product_name = "MT4", */
1595 .ifnum = 2,
1596 .type = QUIRK_MIDI_EMAGIC,
1597 .data = & (const struct snd_usb_midi_endpoint_info) {
1598 .out_cables = 0x800f,
1599 .in_cables = 0x8003
1600 }
1601 }
1602 },
1603
1604 /* TerraTec devices */
1605 {
1606 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
1607 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1608 .vendor_name = "TerraTec",
1609 .product_name = "PHASE 26",
1610 .ifnum = 3,
1611 .type = QUIRK_MIDI_STANDARD_INTERFACE
1612 }
1613 },
1614 {
1615 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1616 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1617 .vendor_name = "TerraTec",
1618 .product_name = "PHASE 26",
1619 .ifnum = 3,
1620 .type = QUIRK_MIDI_STANDARD_INTERFACE
1621 }
1622 },
1623 {
1624 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
1625 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1626 .vendor_name = "TerraTec",
1627 .product_name = "PHASE 26",
1628 .ifnum = 3,
1629 .type = QUIRK_MIDI_STANDARD_INTERFACE
1630 }
1631 },
1632 {
1633 USB_DEVICE(0x0ccd, 0x0035),
1634 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1635 .vendor_name = "Miditech",
1636 .product_name = "Play'n Roll",
1637 .ifnum = 0,
1638 .type = QUIRK_MIDI_CME
1639 }
1640 },
1641
1642 /* Novation EMS devices */
1643 {
1644 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
1645 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1646 .vendor_name = "Novation",
1647 .product_name = "ReMOTE Audio/XStation",
1648 .ifnum = 4,
1649 .type = QUIRK_MIDI_NOVATION
1650 }
1651 },
1652 {
1653 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
1654 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1655 .vendor_name = "Novation",
1656 .product_name = "Speedio",
1657 .ifnum = 3,
1658 .type = QUIRK_MIDI_NOVATION
1659 }
1660 },
1661 {
1662 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
1663 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1664 .vendor_name = "Novation",
1665 .product_name = "ReMOTE25",
1666 .ifnum = 0,
1667 .type = QUIRK_MIDI_NOVATION
1668 }
1669 },
1670
1671 /* Miditech devices */
1672 {
1673 USB_DEVICE(0x4752, 0x0011),
1674 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1675 .vendor_name = "Miditech",
1676 .product_name = "Midistart-2",
1677 .ifnum = 0,
1678 .type = QUIRK_MIDI_CME
1679 }
1680 },
1681
1682 /* Central Music devices */
1683 {
1684 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
1685 USB_DEVICE(0x7104, 0x2202),
1686 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1687 .ifnum = 0,
1688 .type = QUIRK_MIDI_CME
1689 }
1690 },
1691
1692 {
1693 /*
1694 * Some USB MIDI devices don't have an audio control interface,
1695 * so we have to grab MIDI streaming interfaces here.
1696 */
1697 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
1698 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
1699 .bInterfaceClass = USB_CLASS_AUDIO,
1700 .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
1701 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1702 .ifnum = QUIRK_ANY_INTERFACE,
1703 .type = QUIRK_MIDI_STANDARD_INTERFACE
1704 }
1705 },
1706
1707 #undef USB_DEVICE_VENDOR_SPEC
Linux kernel - Deliverables
This page took 0.084032 seconds and 5 git commands to generate.