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