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