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