Add some basic .gitignore files
[linux-3.10.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 snd_usb_audio_quirk_t) { \
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 snd_usb_audio_quirk_t) { \
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 snd_usb_audio_quirk_t) {
153                 .vendor_name = "Roland",
154                 .product_name = "UA-100",
155                 .ifnum = QUIRK_ANY_INTERFACE,
156                 .type = QUIRK_COMPOSITE,
157                 .data = (const snd_usb_audio_quirk_t[]) {
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 snd_usb_midi_endpoint_info_t) {
196                                         .out_cables = 0x0007,
197                                         .in_cables  = 0x0007
198                                 }
199                         },
200                         {
201                                 .ifnum = -1
202                         }
203                 }
204         }
205 },
206 {
207         USB_DEVICE(0x0582, 0x0002),
208         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
209                 .vendor_name = "EDIROL",
210                 .product_name = "UM-4",
211                 .ifnum = QUIRK_ANY_INTERFACE,
212                 .type = QUIRK_COMPOSITE,
213                 .data = (const snd_usb_audio_quirk_t[]) {
214                         {
215                                 .ifnum = 0,
216                                 .type = QUIRK_IGNORE_INTERFACE
217                         },
218                         {
219                                 .ifnum = 1,
220                                 .type = QUIRK_IGNORE_INTERFACE
221                         },
222                         {
223                                 .ifnum = 2,
224                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
225                                 .data = & (const snd_usb_midi_endpoint_info_t) {
226                                         .out_cables = 0x000f,
227                                         .in_cables  = 0x000f
228                                 }
229                         },
230                         {
231                                 .ifnum = -1
232                         }
233                 }
234         }
235 },
236 {
237         USB_DEVICE(0x0582, 0x0003),
238         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
239                 .vendor_name = "Roland",
240                 .product_name = "SC-8850",
241                 .ifnum = QUIRK_ANY_INTERFACE,
242                 .type = QUIRK_COMPOSITE,
243                 .data = (const snd_usb_audio_quirk_t[]) {
244                         {
245                                 .ifnum = 0,
246                                 .type = QUIRK_IGNORE_INTERFACE
247                         },
248                         {
249                                 .ifnum = 1,
250                                 .type = QUIRK_IGNORE_INTERFACE
251                         },
252                         {
253                                 .ifnum = 2,
254                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
255                                 .data = & (const snd_usb_midi_endpoint_info_t) {
256                                         .out_cables = 0x003f,
257                                         .in_cables  = 0x003f
258                                 }
259                         },
260                         {
261                                 .ifnum = -1
262                         }
263                 }
264         }
265 },
266 {
267         USB_DEVICE(0x0582, 0x0004),
268         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
269                 .vendor_name = "Roland",
270                 .product_name = "U-8",
271                 .ifnum = QUIRK_ANY_INTERFACE,
272                 .type = QUIRK_COMPOSITE,
273                 .data = (const snd_usb_audio_quirk_t[]) {
274                         {
275                                 .ifnum = 0,
276                                 .type = QUIRK_IGNORE_INTERFACE
277                         },
278                         {
279                                 .ifnum = 1,
280                                 .type = QUIRK_IGNORE_INTERFACE
281                         },
282                         {
283                                 .ifnum = 2,
284                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
285                                 .data = & (const snd_usb_midi_endpoint_info_t) {
286                                         .out_cables = 0x0005,
287                                         .in_cables  = 0x0005
288                                 }
289                         },
290                         {
291                                 .ifnum = -1
292                         }
293                 }
294         }
295 },
296 {
297         USB_DEVICE(0x0582, 0x0005),
298         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
299                 .vendor_name = "EDIROL",
300                 .product_name = "UM-2",
301                 .ifnum = QUIRK_ANY_INTERFACE,
302                 .type = QUIRK_COMPOSITE,
303                 .data = (const snd_usb_audio_quirk_t[]) {
304                         {
305                                 .ifnum = 0,
306                                 .type = QUIRK_IGNORE_INTERFACE
307                         },
308                         {
309                                 .ifnum = 1,
310                                 .type = QUIRK_IGNORE_INTERFACE
311                         },
312                         {
313                                 .ifnum = 2,
314                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
315                                 .data = & (const snd_usb_midi_endpoint_info_t) {
316                                         .out_cables = 0x0003,
317                                         .in_cables  = 0x0003
318                                 }
319                         },
320                         {
321                                 .ifnum = -1
322                         }
323                 }
324         }
325 },
326 {
327         USB_DEVICE(0x0582, 0x0007),
328         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
329                 .vendor_name = "Roland",
330                 .product_name = "SC-8820",
331                 .ifnum = QUIRK_ANY_INTERFACE,
332                 .type = QUIRK_COMPOSITE,
333                 .data = (const snd_usb_audio_quirk_t[]) {
334                         {
335                                 .ifnum = 0,
336                                 .type = QUIRK_IGNORE_INTERFACE
337                         },
338                         {
339                                 .ifnum = 1,
340                                 .type = QUIRK_IGNORE_INTERFACE
341                         },
342                         {
343                                 .ifnum = 2,
344                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
345                                 .data = & (const snd_usb_midi_endpoint_info_t) {
346                                         .out_cables = 0x0013,
347                                         .in_cables  = 0x0013
348                                 }
349                         },
350                         {
351                                 .ifnum = -1
352                         }
353                 }
354         }
355 },
356 {
357         USB_DEVICE(0x0582, 0x0008),
358         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
359                 .vendor_name = "Roland",
360                 .product_name = "PC-300",
361                 .ifnum = QUIRK_ANY_INTERFACE,
362                 .type = QUIRK_COMPOSITE,
363                 .data = (const snd_usb_audio_quirk_t[]) {
364                         {
365                                 .ifnum = 0,
366                                 .type = QUIRK_IGNORE_INTERFACE
367                         },
368                         {
369                                 .ifnum = 1,
370                                 .type = QUIRK_IGNORE_INTERFACE
371                         },
372                         {
373                                 .ifnum = 2,
374                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
375                                 .data = & (const snd_usb_midi_endpoint_info_t) {
376                                         .out_cables = 0x0001,
377                                         .in_cables  = 0x0001
378                                 }
379                         },
380                         {
381                                 .ifnum = -1
382                         }
383                 }
384         }
385 },
386 {
387         USB_DEVICE(0x0582, 0x0009),
388         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
389                 .vendor_name = "EDIROL",
390                 .product_name = "UM-1",
391                 .ifnum = QUIRK_ANY_INTERFACE,
392                 .type = QUIRK_COMPOSITE,
393                 .data = (const snd_usb_audio_quirk_t[]) {
394                         {
395                                 .ifnum = 0,
396                                 .type = QUIRK_IGNORE_INTERFACE
397                         },
398                         {
399                                 .ifnum = 1,
400                                 .type = QUIRK_IGNORE_INTERFACE
401                         },
402                         {
403                                 .ifnum = 2,
404                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
405                                 .data = & (const snd_usb_midi_endpoint_info_t) {
406                                         .out_cables = 0x0001,
407                                         .in_cables  = 0x0001
408                                 }
409                         },
410                         {
411                                 .ifnum = -1
412                         }
413                 }
414         }
415 },
416 {
417         USB_DEVICE(0x0582, 0x000b),
418         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
419                 .vendor_name = "Roland",
420                 .product_name = "SK-500",
421                 .ifnum = QUIRK_ANY_INTERFACE,
422                 .type = QUIRK_COMPOSITE,
423                 .data = (const snd_usb_audio_quirk_t[]) {
424                         {
425                                 .ifnum = 0,
426                                 .type = QUIRK_IGNORE_INTERFACE
427                         },
428                         {
429                                 .ifnum = 1,
430                                 .type = QUIRK_IGNORE_INTERFACE
431                         },
432                         {
433                                 .ifnum = 2,
434                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
435                                 .data = & (const snd_usb_midi_endpoint_info_t) {
436                                         .out_cables = 0x0013,
437                                         .in_cables  = 0x0013
438                                 }
439                         },
440                         {
441                                 .ifnum = -1
442                         }
443                 }
444         }
445 },
446 {
447         /* thanks to Emiliano Grilli <emillo@libero.it>
448          * for helping researching this data */
449         USB_DEVICE(0x0582, 0x000c),
450         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
451                 .vendor_name = "Roland",
452                 .product_name = "SC-D70",
453                 .ifnum = QUIRK_ANY_INTERFACE,
454                 .type = QUIRK_COMPOSITE,
455                 .data = (const snd_usb_audio_quirk_t[]) {
456                         {
457                                 .ifnum = 0,
458                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
459                                 .data = & (const struct audioformat) {
460                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
461                                         .channels = 2,
462                                         .iface = 0,
463                                         .altsetting = 1,
464                                         .altset_idx = 1,
465                                         .attributes = 0,
466                                         .endpoint = 0x01,
467                                         .ep_attr = 0x01,
468                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
469                                         .rate_min = 44100,
470                                         .rate_max = 44100,
471                                 }
472                         },
473                         {
474                                 .ifnum = 1,
475                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
476                                 .data = & (const struct audioformat) {
477                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
478                                         .channels = 2,
479                                         .iface = 1,
480                                         .altsetting = 1,
481                                         .altset_idx = 1,
482                                         .attributes = 0,
483                                         .endpoint = 0x81,
484                                         .ep_attr = 0x01,
485                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
486                                         .rate_min = 44100,
487                                         .rate_max = 44100,
488                                 }
489                         },
490                         {
491                                 .ifnum = 2,
492                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
493                                 .data = & (const snd_usb_midi_endpoint_info_t) {
494                                         .out_cables = 0x0007,
495                                         .in_cables  = 0x0007
496                                 }
497                         },
498                         {
499                                 .ifnum = -1
500                         }
501                 }
502         }
503 },
504 {       /*
505          * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
506          * If the advanced mode switch at the back of the unit is off, the
507          * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
508          * but offers only 16-bit PCM.
509          * In advanced mode, the UA-5 will output S24_3LE samples (two
510          * channels) at the rate indicated on the front switch, including
511          * the 96kHz sample rate.
512          */
513         USB_DEVICE(0x0582, 0x0010),
514         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
515                 .vendor_name = "EDIROL",
516                 .product_name = "UA-5",
517                 .ifnum = QUIRK_ANY_INTERFACE,
518                 .type = QUIRK_COMPOSITE,
519                 .data = (const snd_usb_audio_quirk_t[]) {
520                         {
521                                 .ifnum = 1,
522                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
523                         },
524                         {
525                                 .ifnum = 2,
526                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
527                         },
528                         {
529                                 .ifnum = -1
530                         }
531                 }
532         }
533 },
534 {
535         USB_DEVICE(0x0582, 0x0012),
536         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
537                 .vendor_name = "Roland",
538                 .product_name = "XV-5050",
539                 .ifnum = 0,
540                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
541                 .data = & (const snd_usb_midi_endpoint_info_t) {
542                         .out_cables = 0x0001,
543                         .in_cables  = 0x0001
544                 }
545         }
546 },
547 {
548         USB_DEVICE(0x0582, 0x0014),
549         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
550                 .vendor_name = "EDIROL",
551                 .product_name = "UM-880",
552                 .ifnum = 0,
553                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
554                 .data = & (const snd_usb_midi_endpoint_info_t) {
555                         .out_cables = 0x01ff,
556                         .in_cables  = 0x01ff
557                 }
558         }
559 },
560 {
561         USB_DEVICE(0x0582, 0x0016),
562         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
563                 .vendor_name = "EDIROL",
564                 .product_name = "SD-90",
565                 .ifnum = QUIRK_ANY_INTERFACE,
566                 .type = QUIRK_COMPOSITE,
567                 .data = (const snd_usb_audio_quirk_t[]) {
568                         {
569                                 .ifnum = 0,
570                                 .type = QUIRK_IGNORE_INTERFACE
571                         },
572                         {
573                                 .ifnum = 1,
574                                 .type = QUIRK_IGNORE_INTERFACE
575                         },
576                         {
577                                 .ifnum = 2,
578                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
579                                 .data = & (const snd_usb_midi_endpoint_info_t) {
580                                         .out_cables = 0x000f,
581                                         .in_cables  = 0x000f
582                                 }
583                         },
584                         {
585                                 .ifnum = -1
586                         }
587                 }
588         }
589 },
590 {
591         USB_DEVICE(0x0582, 0x001b),
592         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
593                 .vendor_name = "Roland",
594                 .product_name = "MMP-2",
595                 .ifnum = QUIRK_ANY_INTERFACE,
596                 .type = QUIRK_COMPOSITE,
597                 .data = (const snd_usb_audio_quirk_t[]) {
598                         {
599                                 .ifnum = 0,
600                                 .type = QUIRK_IGNORE_INTERFACE
601                         },
602                         {
603                                 .ifnum = 1,
604                                 .type = QUIRK_IGNORE_INTERFACE
605                         },
606                         {
607                                 .ifnum = 2,
608                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
609                                 .data = & (const snd_usb_midi_endpoint_info_t) {
610                                         .out_cables = 0x0001,
611                                         .in_cables  = 0x0001
612                                 }
613                         },
614                         {
615                                 .ifnum = -1
616                         }
617                 }
618         }
619 },
620 {
621         USB_DEVICE(0x0582, 0x001d),
622         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
623                 .vendor_name = "Roland",
624                 .product_name = "V-SYNTH",
625                 .ifnum = 0,
626                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
627                 .data = & (const snd_usb_midi_endpoint_info_t) {
628                         .out_cables = 0x0001,
629                         .in_cables  = 0x0001
630                 }
631         }
632 },
633 {
634         USB_DEVICE(0x0582, 0x0023),
635         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
636                 .vendor_name = "EDIROL",
637                 .product_name = "UM-550",
638                 .ifnum = 0,
639                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
640                 .data = & (const snd_usb_midi_endpoint_info_t) {
641                         .out_cables = 0x003f,
642                         .in_cables  = 0x003f
643                 }
644         }
645 },
646 {
647         /*
648          * This quirk is for the "Advanced Driver" mode. If off, the UA-20
649          * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
650          * and no MIDI.
651          */
652         USB_DEVICE(0x0582, 0x0025),
653         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
654                 .vendor_name = "EDIROL",
655                 .product_name = "UA-20",
656                 .ifnum = QUIRK_ANY_INTERFACE,
657                 .type = QUIRK_COMPOSITE,
658                 .data = (const snd_usb_audio_quirk_t[]) {
659                         {
660                                 .ifnum = 1,
661                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
662                         },
663                         {
664                                 .ifnum = 2,
665                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
666                         },
667                         {
668                                 .ifnum = 3,
669                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
670                         },
671                         {
672                                 .ifnum = -1
673                         }
674                 }
675         }
676 },
677 {
678         USB_DEVICE(0x0582, 0x0027),
679         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
680                 .vendor_name = "EDIROL",
681                 .product_name = "SD-20",
682                 .ifnum = 0,
683                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
684                 .data = & (const snd_usb_midi_endpoint_info_t) {
685                         .out_cables = 0x0003,
686                         .in_cables  = 0x0007
687                 }
688         }
689 },
690 {
691         USB_DEVICE(0x0582, 0x0029),
692         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
693                 .vendor_name = "EDIROL",
694                 .product_name = "SD-80",
695                 .ifnum = 0,
696                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
697                 .data = & (const snd_usb_midi_endpoint_info_t) {
698                         .out_cables = 0x000f,
699                         .in_cables  = 0x000f
700                 }
701         }
702 },
703 {       /*
704          * This quirk is for the "Advanced" modes of the Edirol UA-700.
705          * If the sample format switch is not in an advanced setting, the
706          * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
707          * but offers only 16-bit PCM and no MIDI.
708          */
709         USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
710         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
711                 .vendor_name = "EDIROL",
712                 .product_name = "UA-700",
713                 .ifnum = QUIRK_ANY_INTERFACE,
714                 .type = QUIRK_COMPOSITE,
715                 .data = (const snd_usb_audio_quirk_t[]) {
716                         {
717                                 .ifnum = 1,
718                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
719                         },
720                         {
721                                 .ifnum = 2,
722                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
723                         },
724                         {
725                                 .ifnum = 3,
726                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
727                         },
728                         {
729                                 .ifnum = -1
730                         }
731                 }
732         }
733 },
734 {
735         USB_DEVICE(0x0582, 0x002d),
736         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
737                 .vendor_name = "Roland",
738                 .product_name = "XV-2020",
739                 .ifnum = 0,
740                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
741                 .data = & (const snd_usb_midi_endpoint_info_t) {
742                         .out_cables = 0x0001,
743                         .in_cables  = 0x0001
744                 }
745         }
746 },
747 {
748         USB_DEVICE(0x0582, 0x002f),
749         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
750                 .vendor_name = "Roland",
751                 .product_name = "VariOS",
752                 .ifnum = 0,
753                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
754                 .data = & (const snd_usb_midi_endpoint_info_t) {
755                         .out_cables = 0x0007,
756                         .in_cables  = 0x0007
757                 }
758         }
759 },
760 {
761         USB_DEVICE(0x0582, 0x0033),
762         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
763                 .vendor_name = "EDIROL",
764                 .product_name = "PCR",
765                 .ifnum = 0,
766                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
767                 .data = & (const snd_usb_midi_endpoint_info_t) {
768                         .out_cables = 0x0003,
769                         .in_cables  = 0x0007
770                 }
771         }
772 },
773 {
774         USB_DEVICE(0x0582, 0x0037),
775         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
776                 .vendor_name = "Roland",
777                 .product_name = "Digital Piano",
778                 .ifnum = 0,
779                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
780                 .data = & (const snd_usb_midi_endpoint_info_t) {
781                         .out_cables = 0x0001,
782                         .in_cables  = 0x0001
783                 }
784         }
785 },
786 {
787         /*
788          * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
789          * has ID 0x003c and is standard compliant, but has only 16-bit PCM
790          * and no MIDI.
791          */
792         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
793         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
794                 .vendor_name = "BOSS",
795                 .product_name = "GS-10",
796                 .ifnum = QUIRK_ANY_INTERFACE,
797                 .type = QUIRK_COMPOSITE,
798                 .data = & (const snd_usb_audio_quirk_t[]) {
799                         {
800                                 .ifnum = 1,
801                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
802                         },
803                         {
804                                 .ifnum = 2,
805                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
806                         },
807                         {
808                                 .ifnum = 3,
809                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
810                         },
811                         {
812                                 .ifnum = -1
813                         }
814                 }
815         }
816 },
817 {
818         USB_DEVICE(0x0582, 0x0040),
819         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
820                 .vendor_name = "Roland",
821                 .product_name = "GI-20",
822                 .ifnum = 0,
823                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
824                 .data = & (const snd_usb_midi_endpoint_info_t) {
825                         .out_cables = 0x0001,
826                         .in_cables  = 0x0001
827                 }
828         }
829 },
830 {
831         USB_DEVICE(0x0582, 0x0042),
832         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
833                 .vendor_name = "Roland",
834                 .product_name = "RS-70",
835                 .ifnum = 0,
836                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
837                 .data = & (const snd_usb_midi_endpoint_info_t) {
838                         .out_cables = 0x0001,
839                         .in_cables  = 0x0001
840                 }
841         }
842 },
843 {
844         USB_DEVICE(0x0582, 0x0044),
845         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
846                 .vendor_name = "Roland",
847                 .product_name = "UA-1000",
848                 .ifnum = QUIRK_ANY_INTERFACE,
849                 .type = QUIRK_COMPOSITE,
850                 .data = (const snd_usb_audio_quirk_t[]) {
851                         {
852                                 .ifnum = 1,
853                                 .type = QUIRK_AUDIO_EDIROL_UA1000
854                         },
855                         {
856                                 .ifnum = 2,
857                                 .type = QUIRK_AUDIO_EDIROL_UA1000
858                         },
859                         {
860                                 .ifnum = 3,
861                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
862                                 .data = & (const snd_usb_midi_endpoint_info_t) {
863                                         .out_cables = 0x0003,
864                                         .in_cables  = 0x0003
865                                 }
866                         },
867                         {
868                                 .ifnum = -1
869                         }
870                 }
871         }
872 },
873 {
874         USB_DEVICE(0x0582, 0x0048),
875         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
876                 .vendor_name = "EDIROL",
877                 .product_name = "UR-80",
878                 .ifnum = 0,
879                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
880                 .data = & (const snd_usb_midi_endpoint_info_t) {
881                         .out_cables = 0x0003,
882                         .in_cables  = 0x0007
883                 }
884         }
885 },
886 {
887         USB_DEVICE(0x0582, 0x004d),
888         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
889                 .vendor_name = "EDIROL",
890                 .product_name = "PCR-A",
891                 .ifnum = 0,
892                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
893                 .data = & (const snd_usb_midi_endpoint_info_t) {
894                         .out_cables = 0x0003,
895                         .in_cables  = 0x0007
896                 }
897         }
898 },
899 {
900         /*
901          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
902          * is standard compliant, but has only 16-bit PCM.
903          */
904         USB_DEVICE(0x0582, 0x0050),
905         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
906                 .vendor_name = "EDIROL",
907                 .product_name = "UA-3FX",
908                 .ifnum = QUIRK_ANY_INTERFACE,
909                 .type = QUIRK_COMPOSITE,
910                 .data = (const snd_usb_audio_quirk_t[]) {
911                         {
912                                 .ifnum = 1,
913                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
914                         },
915                         {
916                                 .ifnum = 2,
917                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
918                         },
919                         {
920                                 .ifnum = -1
921                         }
922                 }
923         }
924 },
925 {
926         USB_DEVICE(0x0582, 0x0052),
927         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
928                 .vendor_name = "EDIROL",
929                 .product_name = "UM-1SX",
930                 .ifnum = 0,
931                 .type = QUIRK_MIDI_STANDARD_INTERFACE
932         }
933 },
934 {
935         USB_DEVICE(0x0582, 0x0065),
936         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
937                 .vendor_name = "EDIROL",
938                 .product_name = "PCR-1",
939                 .ifnum = 0,
940                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
941                 .data = & (const snd_usb_midi_endpoint_info_t) {
942                         .out_cables = 0x0001,
943                         .in_cables  = 0x0003
944                 }
945         }
946 },
947 {
948         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
949         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
950                 .vendor_name = "Roland",
951                 .product_name = "SP-606",
952                 .ifnum = 3,
953                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
954                 .data = & (const snd_usb_midi_endpoint_info_t) {
955                         .out_cables = 0x0001,
956                         .in_cables  = 0x0001
957                 }
958         }
959 },
960 {
961         USB_DEVICE(0x0582, 0x006d),
962         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
963                 .vendor_name = "Roland",
964                 .product_name = "FANTOM-X",
965                 .ifnum = 0,
966                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
967                 .data = & (const snd_usb_midi_endpoint_info_t) {
968                         .out_cables = 0x0001,
969                         .in_cables  = 0x0001
970                 }
971         }
972 },
973 {       /*
974          * This quirk is for the "Advanced" modes of the Edirol UA-25.
975          * If the switch is not in an advanced setting, the UA-25 has
976          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
977          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
978          */
979         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
980         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
981                 .vendor_name = "EDIROL",
982                 .product_name = "UA-25",
983                 .ifnum = QUIRK_ANY_INTERFACE,
984                 .type = QUIRK_COMPOSITE,
985                 .data = (const snd_usb_audio_quirk_t[]) {
986                         {
987                                 .ifnum = 0,
988                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
989                         },
990                         {
991                                 .ifnum = 1,
992                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
993                         },
994                         {
995                                 .ifnum = 2,
996                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
997                         },
998                         {
999                                 .ifnum = -1
1000                         }
1001                 }
1002         }
1003 },
1004 {
1005         USB_DEVICE(0x0582, 0x0075),
1006         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1007                 .vendor_name = "BOSS",
1008                 .product_name = "DR-880",
1009                 .ifnum = 0,
1010                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1011                 .data = & (const snd_usb_midi_endpoint_info_t) {
1012                         .out_cables = 0x0001,
1013                         .in_cables  = 0x0001
1014                 }
1015         }
1016 },
1017 {
1018         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1019         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1020                 .vendor_name = "Roland",
1021                 /* RD-700SX, RD-300SX */
1022                 .ifnum = 0,
1023                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1024                 .data = & (const snd_usb_midi_endpoint_info_t) {
1025                         .out_cables = 0x0003,
1026                         .in_cables  = 0x0003
1027                 }
1028         }
1029 },
1030
1031 /* Guillemot devices */
1032 {
1033         /*
1034          * This is for the "Windows Edition" where the external MIDI ports are
1035          * the only MIDI ports; the control data is reported through HID
1036          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1037          * compliant USB MIDI ports for external MIDI and controls.
1038          */
1039         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1040         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1041                 .vendor_name = "Hercules",
1042                 .product_name = "DJ Console (WE)",
1043                 .ifnum = 4,
1044                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1045                 .data = & (const snd_usb_midi_endpoint_info_t) {
1046                         .out_cables = 0x0001,
1047                         .in_cables = 0x0001
1048                 }
1049         }
1050 },
1051
1052 /* Midiman/M-Audio devices */
1053 {
1054         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1055         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1056                 .vendor_name = "M-Audio",
1057                 .product_name = "MidiSport 2x2",
1058                 .ifnum = QUIRK_ANY_INTERFACE,
1059                 .type = QUIRK_MIDI_MIDIMAN,
1060                 .data = & (const snd_usb_midi_endpoint_info_t) {
1061                         .out_cables = 0x0003,
1062                         .in_cables  = 0x0003
1063                 }
1064         }
1065 },
1066 {
1067         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1068         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1069                 .vendor_name = "M-Audio",
1070                 .product_name = "MidiSport 1x1",
1071                 .ifnum = QUIRK_ANY_INTERFACE,
1072                 .type = QUIRK_MIDI_MIDIMAN,
1073                 .data = & (const snd_usb_midi_endpoint_info_t) {
1074                         .out_cables = 0x0001,
1075                         .in_cables  = 0x0001
1076                 }
1077         }
1078 },
1079 {
1080         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1081         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1082                 .vendor_name = "M-Audio",
1083                 .product_name = "Keystation",
1084                 .ifnum = QUIRK_ANY_INTERFACE,
1085                 .type = QUIRK_MIDI_MIDIMAN,
1086                 .data = & (const snd_usb_midi_endpoint_info_t) {
1087                         .out_cables = 0x0001,
1088                         .in_cables  = 0x0001
1089                 }
1090         }
1091 },
1092 {
1093         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1094         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1095                 .vendor_name = "M-Audio",
1096                 .product_name = "MidiSport 4x4",
1097                 .ifnum = QUIRK_ANY_INTERFACE,
1098                 .type = QUIRK_MIDI_MIDIMAN,
1099                 .data = & (const snd_usb_midi_endpoint_info_t) {
1100                         .out_cables = 0x000f,
1101                         .in_cables  = 0x000f
1102                 }
1103         }
1104 },
1105 {
1106         /*
1107          * For hardware revision 1.05; in the later revisions (1.10 and
1108          * 1.21), 0x1031 is the ID for the device without firmware.
1109          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1110          */
1111         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1112         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1113                 .vendor_name = "M-Audio",
1114                 .product_name = "MidiSport 8x8",
1115                 .ifnum = QUIRK_ANY_INTERFACE,
1116                 .type = QUIRK_MIDI_MIDIMAN,
1117                 .data = & (const snd_usb_midi_endpoint_info_t) {
1118                         .out_cables = 0x01ff,
1119                         .in_cables  = 0x01ff
1120                 }
1121         }
1122 },
1123 {
1124         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1125         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1126                 .vendor_name = "M-Audio",
1127                 .product_name = "MidiSport 8x8",
1128                 .ifnum = QUIRK_ANY_INTERFACE,
1129                 .type = QUIRK_MIDI_MIDIMAN,
1130                 .data = & (const snd_usb_midi_endpoint_info_t) {
1131                         .out_cables = 0x01ff,
1132                         .in_cables  = 0x01ff
1133                 }
1134         }
1135 },
1136 {
1137         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1138         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1139                 .vendor_name = "M-Audio",
1140                 .product_name = "MidiSport 2x4",
1141                 .ifnum = QUIRK_ANY_INTERFACE,
1142                 .type = QUIRK_MIDI_MIDIMAN,
1143                 .data = & (const snd_usb_midi_endpoint_info_t) {
1144                         .out_cables = 0x000f,
1145                         .in_cables  = 0x0003
1146                 }
1147         }
1148 },
1149 {
1150         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1151         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1152                 .vendor_name = "M-Audio",
1153                 .product_name = "Quattro",
1154                 .ifnum = QUIRK_ANY_INTERFACE,
1155                 .type = QUIRK_COMPOSITE,
1156                 .data = & (const snd_usb_audio_quirk_t[]) {
1157                         /*
1158                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1159                          * and share endpoints with the other interfaces.
1160                          * Ignore them.  The other interfaces can do 24 bits,
1161                          * but captured samples are big-endian (see usbaudio.c).
1162                          */
1163                         {
1164                                 .ifnum = 0,
1165                                 .type = QUIRK_IGNORE_INTERFACE
1166                         },
1167                         {
1168                                 .ifnum = 1,
1169                                 .type = QUIRK_IGNORE_INTERFACE
1170                         },
1171                         {
1172                                 .ifnum = 2,
1173                                 .type = QUIRK_IGNORE_INTERFACE
1174                         },
1175                         {
1176                                 .ifnum = 3,
1177                                 .type = QUIRK_IGNORE_INTERFACE
1178                         },
1179                         {
1180                                 .ifnum = 4,
1181                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1182                         },
1183                         {
1184                                 .ifnum = 5,
1185                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1186                         },
1187                         {
1188                                 .ifnum = 6,
1189                                 .type = QUIRK_IGNORE_INTERFACE
1190                         },
1191                         {
1192                                 .ifnum = 7,
1193                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1194                         },
1195                         {
1196                                 .ifnum = 8,
1197                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1198                         },
1199                         {
1200                                 .ifnum = 9,
1201                                 .type = QUIRK_MIDI_MIDIMAN,
1202                                 .data = & (const snd_usb_midi_endpoint_info_t) {
1203                                         .out_cables = 0x0001,
1204                                         .in_cables  = 0x0001
1205                                 }
1206                         },
1207                         {
1208                                 .ifnum = -1
1209                         }
1210                 }
1211         }
1212 },
1213 {
1214         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1215         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1216                 .vendor_name = "M-Audio",
1217                 .product_name = "AudioPhile",
1218                 .ifnum = 6,
1219                 .type = QUIRK_MIDI_MIDIMAN,
1220                 .data = & (const snd_usb_midi_endpoint_info_t) {
1221                         .out_cables = 0x0001,
1222                         .in_cables  = 0x0001
1223                 }
1224         }
1225 },
1226 {
1227         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1228         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1229                 .vendor_name = "M-Audio",
1230                 .product_name = "Ozone",
1231                 .ifnum = 3,
1232                 .type = QUIRK_MIDI_MIDIMAN,
1233                 .data = & (const snd_usb_midi_endpoint_info_t) {
1234                         .out_cables = 0x0001,
1235                         .in_cables  = 0x0001
1236                 }
1237         }
1238 },
1239 {
1240         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1241         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1242                 .vendor_name = "M-Audio",
1243                 .product_name = "OmniStudio",
1244                 .ifnum = QUIRK_ANY_INTERFACE,
1245                 .type = QUIRK_COMPOSITE,
1246                 .data = & (const snd_usb_audio_quirk_t[]) {
1247                         {
1248                                 .ifnum = 0,
1249                                 .type = QUIRK_IGNORE_INTERFACE
1250                         },
1251                         {
1252                                 .ifnum = 1,
1253                                 .type = QUIRK_IGNORE_INTERFACE
1254                         },
1255                         {
1256                                 .ifnum = 2,
1257                                 .type = QUIRK_IGNORE_INTERFACE
1258                         },
1259                         {
1260                                 .ifnum = 3,
1261                                 .type = QUIRK_IGNORE_INTERFACE
1262                         },
1263                         {
1264                                 .ifnum = 4,
1265                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1266                         },
1267                         {
1268                                 .ifnum = 5,
1269                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1270                         },
1271                         {
1272                                 .ifnum = 6,
1273                                 .type = QUIRK_IGNORE_INTERFACE
1274                         },
1275                         {
1276                                 .ifnum = 7,
1277                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1278                         },
1279                         {
1280                                 .ifnum = 8,
1281                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1282                         },
1283                         {
1284                                 .ifnum = 9,
1285                                 .type = QUIRK_MIDI_MIDIMAN,
1286                                 .data = & (const snd_usb_midi_endpoint_info_t) {
1287                                         .out_cables = 0x0001,
1288                                         .in_cables  = 0x0001
1289                                 }
1290                         },
1291                         {
1292                                 .ifnum = -1
1293                         }
1294                 }
1295         }
1296 },
1297
1298 /* Mark of the Unicorn devices */
1299 {
1300         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1301         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1302                        USB_DEVICE_ID_MATCH_PRODUCT |
1303                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
1304         .idVendor = 0x07fd,
1305         .idProduct = 0x0001,
1306         .bDeviceSubClass = 2,
1307         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1308                 .vendor_name = "MOTU",
1309                 .product_name = "Fastlane",
1310                 .ifnum = QUIRK_ANY_INTERFACE,
1311                 .type = QUIRK_COMPOSITE,
1312                 .data = & (const snd_usb_audio_quirk_t[]) {
1313                         {
1314                                 .ifnum = 0,
1315                                 .type = QUIRK_MIDI_RAW
1316                         },
1317                         {
1318                                 .ifnum = 1,
1319                                 .type = QUIRK_IGNORE_INTERFACE
1320                         },
1321                         {
1322                                 .ifnum = -1
1323                         }
1324                 }
1325         }
1326 },
1327
1328 {
1329         /* Creative Sound Blaster MP3+ */
1330         USB_DEVICE(0x041e, 0x3010),
1331         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1332                 .vendor_name = "Creative Labs",
1333                 .product_name = "Sound Blaster MP3+",
1334                 .ifnum = QUIRK_NO_INTERFACE
1335         }
1336         
1337 },
1338
1339 /* Emagic devices */
1340 {
1341         USB_DEVICE(0x086a, 0x0001),
1342         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1343                 .vendor_name = "Emagic",
1344                 /* .product_name = "Unitor8", */
1345                 .ifnum = 2,
1346                 .type = QUIRK_MIDI_EMAGIC,
1347                 .data = & (const snd_usb_midi_endpoint_info_t) {
1348                         .out_cables = 0x80ff,
1349                         .in_cables  = 0x80ff
1350                 }
1351         }
1352 },
1353 {
1354         USB_DEVICE(0x086a, 0x0002),
1355         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1356                 .vendor_name = "Emagic",
1357                 /* .product_name = "AMT8", */
1358                 .ifnum = 2,
1359                 .type = QUIRK_MIDI_EMAGIC,
1360                 .data = & (const snd_usb_midi_endpoint_info_t) {
1361                         .out_cables = 0x80ff,
1362                         .in_cables  = 0x80ff
1363                 }
1364         }
1365 },
1366 {
1367         USB_DEVICE(0x086a, 0x0003),
1368         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1369                 .vendor_name = "Emagic",
1370                 /* .product_name = "MT4", */
1371                 .ifnum = 2,
1372                 .type = QUIRK_MIDI_EMAGIC,
1373                 .data = & (const snd_usb_midi_endpoint_info_t) {
1374                         .out_cables = 0x800f,
1375                         .in_cables  = 0x8003
1376                 }
1377         }
1378 },
1379
1380 /* TerraTec devices */
1381 {
1382         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
1383         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1384                 .vendor_name = "TerraTec",
1385                 .product_name = "PHASE 26",
1386                 .ifnum = 3,
1387                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1388         }
1389 },
1390 {
1391         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1392         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1393                 .vendor_name = "TerraTec",
1394                 .product_name = "PHASE 26",
1395                 .ifnum = 3,
1396                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1397         }
1398 },
1399
1400 /* Novation EMS devices */
1401 {
1402         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
1403         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1404                 .vendor_name = "Novation",
1405                 .product_name = "ReMOTE Audio/XStation",
1406                 .ifnum = 4,
1407                 .type = QUIRK_MIDI_NOVATION
1408         }
1409 },
1410 {
1411         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
1412         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1413                 .vendor_name = "Novation",
1414                 .product_name = "Speedio",
1415                 .ifnum = 3,
1416                 .type = QUIRK_MIDI_NOVATION
1417         }
1418 },
1419 {
1420         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
1421         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1422                 .vendor_name = "Novation",
1423                 .product_name = "ReMOTE25",
1424                 .ifnum = 0,
1425                 .type = QUIRK_MIDI_NOVATION
1426         }
1427 },
1428
1429 {
1430         USB_DEVICE(0x4752, 0x0011),
1431         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1432                 .vendor_name = "Miditech",
1433                 .product_name = "Midistart-2",
1434                 .ifnum = 0,
1435                 .type = QUIRK_MIDI_MIDITECH
1436         }
1437 },
1438 {
1439         USB_DEVICE(0x7104, 0x2202),
1440         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1441                 .vendor_name = "Miditech",
1442                 .product_name = "MidiStudio-2",
1443                 .ifnum = 0,
1444                 .type = QUIRK_MIDI_MIDITECH
1445         }
1446 },
1447
1448 {
1449         /*
1450          * Some USB MIDI devices don't have an audio control interface,
1451          * so we have to grab MIDI streaming interfaces here.
1452          */
1453         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
1454                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
1455         .bInterfaceClass = USB_CLASS_AUDIO,
1456         .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
1457         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1458                 .ifnum = QUIRK_ANY_INTERFACE,
1459                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1460         }
1461 },
1462
1463 #undef USB_DEVICE_VENDOR_SPEC