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