OpenCores
URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [sound/] [usb/] [usbquirks.h] - Blame information for rev 3

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.