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