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