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