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