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