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