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