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