[PATCH] pmac: save master volume on sleep
[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         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
613         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
614                 .vendor_name = "BOSS",
615                 .product_name = "GS-10",
616                 .ifnum = 3,
617                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
618                 .data = & (const snd_usb_midi_endpoint_info_t) {
619                         .out_cables = 0x0003,
620                         .in_cables  = 0x0003
621                 }
622         }
623 },
624 {
625         USB_DEVICE(0x0582, 0x0040),
626         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
627                 .vendor_name = "Roland",
628                 .product_name = "GI-20",
629                 .ifnum = 0,
630                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
631                 .data = & (const snd_usb_midi_endpoint_info_t) {
632                         .out_cables = 0x0001,
633                         .in_cables  = 0x0001
634                 }
635         }
636 },
637 {
638         USB_DEVICE(0x0582, 0x0042),
639         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
640                 .vendor_name = "Roland",
641                 .product_name = "RS-70",
642                 .ifnum = 0,
643                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
644                 .data = & (const snd_usb_midi_endpoint_info_t) {
645                         .out_cables = 0x0001,
646                         .in_cables  = 0x0001
647                 }
648         }
649 },
650 {
651         USB_DEVICE(0x0582, 0x0044),
652         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
653                 .vendor_name = "Roland",
654                 .product_name = "UA-1000",
655                 .ifnum = QUIRK_ANY_INTERFACE,
656                 .type = QUIRK_COMPOSITE,
657                 .data = (const snd_usb_audio_quirk_t[]) {
658                         {
659                                 .ifnum = 1,
660                                 .type = QUIRK_AUDIO_EDIROL_UA1000
661                         },
662                         {
663                                 .ifnum = 2,
664                                 .type = QUIRK_AUDIO_EDIROL_UA1000
665                         },
666                         {
667                                 .ifnum = 3,
668                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
669                                 .data = & (const snd_usb_midi_endpoint_info_t) {
670                                         .out_cables = 0x0003,
671                                         .in_cables  = 0x0003
672                                 }
673                         },
674                         {
675                                 .ifnum = -1
676                         }
677                 }
678         }
679 },
680 {
681         USB_DEVICE(0x0582, 0x0048),
682         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
683                 .vendor_name = "EDIROL",
684                 .product_name = "UR-80",
685                 .ifnum = 0,
686                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
687                 .data = & (const snd_usb_midi_endpoint_info_t) {
688                         .out_cables = 0x0003,
689                         .in_cables  = 0x0007
690                 }
691         }
692 },
693 {
694         USB_DEVICE(0x0582, 0x004d),
695         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
696                 .vendor_name = "EDIROL",
697                 .product_name = "PCR-A",
698                 .ifnum = 0,
699                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
700                 .data = & (const snd_usb_midi_endpoint_info_t) {
701                         .out_cables = 0x0003,
702                         .in_cables  = 0x0007
703                 }
704         }
705 },
706 {
707         /*
708          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
709          * is standard compliant, but has only 16-bit PCM.
710          */
711         USB_DEVICE(0x0582, 0x0050),
712         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
713                 .vendor_name = "EDIROL",
714                 .product_name = "UA-3FX",
715                 .ifnum = QUIRK_ANY_INTERFACE,
716                 .type = QUIRK_COMPOSITE,
717                 .data = (const snd_usb_audio_quirk_t[]) {
718                         {
719                                 .ifnum = 1,
720                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
721                         },
722                         {
723                                 .ifnum = 2,
724                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
725                         },
726                         {
727                                 .ifnum = -1
728                         }
729                 }
730         }
731 },
732 {
733         USB_DEVICE(0x0582, 0x0052),
734         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
735                 .vendor_name = "EDIROL",
736                 .product_name = "UM-1SX",
737                 .ifnum = 0,
738                 .type = QUIRK_MIDI_STANDARD_INTERFACE
739         }
740 },
741 {
742         USB_DEVICE(0x0582, 0x0065),
743         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
744                 .vendor_name = "EDIROL",
745                 .product_name = "PCR-1",
746                 .ifnum = 0,
747                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
748                 .data = & (const snd_usb_midi_endpoint_info_t) {
749                         .out_cables = 0x0001,
750                         .in_cables  = 0x0003
751                 }
752         }
753 },
754 {
755         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
756         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
757                 .vendor_name = "Roland",
758                 .product_name = "SP-606",
759                 .ifnum = 3,
760                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
761                 .data = & (const snd_usb_midi_endpoint_info_t) {
762                         .out_cables = 0x0001,
763                         .in_cables  = 0x0001
764                 }
765         }
766 },
767 {
768         USB_DEVICE(0x0582, 0x006d),
769         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
770                 .vendor_name = "Roland",
771                 .product_name = "FANTOM-X",
772                 .ifnum = 0,
773                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
774                 .data = & (const snd_usb_midi_endpoint_info_t) {
775                         .out_cables = 0x0001,
776                         .in_cables  = 0x0001
777                 }
778         }
779 },
780 {       /*
781          * This quirk is for the "Advanced" modes of the Edirol UA-25.
782          * If the switch is not in an advanced setting, the UA-25 has
783          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
784          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
785          */
786         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
787         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
788                 .vendor_name = "EDIROL",
789                 .product_name = "UA-25",
790                 .ifnum = QUIRK_ANY_INTERFACE,
791                 .type = QUIRK_COMPOSITE,
792                 .data = (const snd_usb_audio_quirk_t[]) {
793                         {
794                                 .ifnum = 0,
795                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
796                         },
797                         {
798                                 .ifnum = 1,
799                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
800                         },
801                         {
802                                 .ifnum = 2,
803                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
804                         },
805                         {
806                                 .ifnum = -1
807                         }
808                 }
809         }
810 },
811 {
812         USB_DEVICE(0x0582, 0x0075),
813         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
814                 .vendor_name = "BOSS",
815                 .product_name = "DR-880",
816                 .ifnum = 0,
817                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
818                 .data = & (const snd_usb_midi_endpoint_info_t) {
819                         .out_cables = 0x0001,
820                         .in_cables  = 0x0001
821                 }
822         }
823 },
824
825 /* Midiman/M-Audio devices */
826 {
827         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
828         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
829                 .vendor_name = "M-Audio",
830                 .product_name = "MidiSport 2x2",
831                 .ifnum = QUIRK_ANY_INTERFACE,
832                 .type = QUIRK_MIDI_MIDIMAN,
833                 .data = & (const snd_usb_midi_endpoint_info_t) {
834                         .out_cables = 0x0003,
835                         .in_cables  = 0x0003
836                 }
837         }
838 },
839 {
840         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
841         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
842                 .vendor_name = "M-Audio",
843                 .product_name = "MidiSport 1x1",
844                 .ifnum = QUIRK_ANY_INTERFACE,
845                 .type = QUIRK_MIDI_MIDIMAN,
846                 .data = & (const snd_usb_midi_endpoint_info_t) {
847                         .out_cables = 0x0001,
848                         .in_cables  = 0x0001
849                 }
850         }
851 },
852 {
853         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
854         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
855                 .vendor_name = "M-Audio",
856                 .product_name = "Keystation",
857                 .ifnum = QUIRK_ANY_INTERFACE,
858                 .type = QUIRK_MIDI_MIDIMAN,
859                 .data = & (const snd_usb_midi_endpoint_info_t) {
860                         .out_cables = 0x0001,
861                         .in_cables  = 0x0001
862                 }
863         }
864 },
865 {
866         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
867         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
868                 .vendor_name = "M-Audio",
869                 .product_name = "MidiSport 4x4",
870                 .ifnum = QUIRK_ANY_INTERFACE,
871                 .type = QUIRK_MIDI_MIDIMAN,
872                 .data = & (const snd_usb_midi_endpoint_info_t) {
873                         .out_cables = 0x000f,
874                         .in_cables  = 0x000f
875                 }
876         }
877 },
878 {
879         /*
880          * For hardware revision 1.05; in the later revisions (1.10 and
881          * 1.21), 0x1031 is the ID for the device without firmware.
882          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
883          */
884         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
885         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
886                 .vendor_name = "M-Audio",
887                 .product_name = "MidiSport 8x8",
888                 .ifnum = QUIRK_ANY_INTERFACE,
889                 .type = QUIRK_MIDI_MIDIMAN,
890                 .data = & (const snd_usb_midi_endpoint_info_t) {
891                         .out_cables = 0x01ff,
892                         .in_cables  = 0x01ff
893                 }
894         }
895 },
896 {
897         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
898         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
899                 .vendor_name = "M-Audio",
900                 .product_name = "MidiSport 8x8",
901                 .ifnum = QUIRK_ANY_INTERFACE,
902                 .type = QUIRK_MIDI_MIDIMAN,
903                 .data = & (const snd_usb_midi_endpoint_info_t) {
904                         .out_cables = 0x01ff,
905                         .in_cables  = 0x01ff
906                 }
907         }
908 },
909 {
910         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
911         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
912                 .vendor_name = "M-Audio",
913                 .product_name = "MidiSport 2x4",
914                 .ifnum = QUIRK_ANY_INTERFACE,
915                 .type = QUIRK_MIDI_MIDIMAN,
916                 .data = & (const snd_usb_midi_endpoint_info_t) {
917                         .out_cables = 0x000f,
918                         .in_cables  = 0x0003
919                 }
920         }
921 },
922 {
923         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
924         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
925                 .vendor_name = "M-Audio",
926                 .product_name = "Quattro",
927                 .ifnum = QUIRK_ANY_INTERFACE,
928                 .type = QUIRK_COMPOSITE,
929                 .data = & (const snd_usb_audio_quirk_t[]) {
930                         /*
931                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
932                          * and share endpoints with the other interfaces.
933                          * Ignore them.  The other interfaces can do 24 bits,
934                          * but captured samples are big-endian (see usbaudio.c).
935                          */
936                         {
937                                 .ifnum = 0,
938                                 .type = QUIRK_IGNORE_INTERFACE
939                         },
940                         {
941                                 .ifnum = 1,
942                                 .type = QUIRK_IGNORE_INTERFACE
943                         },
944                         {
945                                 .ifnum = 2,
946                                 .type = QUIRK_IGNORE_INTERFACE
947                         },
948                         {
949                                 .ifnum = 3,
950                                 .type = QUIRK_IGNORE_INTERFACE
951                         },
952                         {
953                                 .ifnum = 4,
954                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
955                         },
956                         {
957                                 .ifnum = 5,
958                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
959                         },
960                         {
961                                 .ifnum = 6,
962                                 .type = QUIRK_IGNORE_INTERFACE
963                         },
964                         {
965                                 .ifnum = 7,
966                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
967                         },
968                         {
969                                 .ifnum = 8,
970                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
971                         },
972                         {
973                                 .ifnum = 9,
974                                 .type = QUIRK_MIDI_MIDIMAN,
975                                 .data = & (const snd_usb_midi_endpoint_info_t) {
976                                         .out_cables = 0x0001,
977                                         .in_cables  = 0x0001
978                                 }
979                         },
980                         {
981                                 .ifnum = -1
982                         }
983                 }
984         }
985 },
986 {
987         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
988         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
989                 .vendor_name = "M-Audio",
990                 .product_name = "AudioPhile",
991                 .ifnum = 6,
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 {
1000         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1001         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1002                 .vendor_name = "M-Audio",
1003                 .product_name = "Ozone",
1004                 .ifnum = 3,
1005                 .type = QUIRK_MIDI_MIDIMAN,
1006                 .data = & (const snd_usb_midi_endpoint_info_t) {
1007                         .out_cables = 0x0001,
1008                         .in_cables  = 0x0001
1009                 }
1010         }
1011 },
1012 {
1013         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1014         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1015                 .vendor_name = "M-Audio",
1016                 .product_name = "OmniStudio",
1017                 .ifnum = QUIRK_ANY_INTERFACE,
1018                 .type = QUIRK_COMPOSITE,
1019                 .data = & (const snd_usb_audio_quirk_t[]) {
1020                         {
1021                                 .ifnum = 0,
1022                                 .type = QUIRK_IGNORE_INTERFACE
1023                         },
1024                         {
1025                                 .ifnum = 1,
1026                                 .type = QUIRK_IGNORE_INTERFACE
1027                         },
1028                         {
1029                                 .ifnum = 2,
1030                                 .type = QUIRK_IGNORE_INTERFACE
1031                         },
1032                         {
1033                                 .ifnum = 3,
1034                                 .type = QUIRK_IGNORE_INTERFACE
1035                         },
1036                         {
1037                                 .ifnum = 4,
1038                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1039                         },
1040                         {
1041                                 .ifnum = 5,
1042                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1043                         },
1044                         {
1045                                 .ifnum = 6,
1046                                 .type = QUIRK_IGNORE_INTERFACE
1047                         },
1048                         {
1049                                 .ifnum = 7,
1050                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1051                         },
1052                         {
1053                                 .ifnum = 8,
1054                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1055                         },
1056                         {
1057                                 .ifnum = 9,
1058                                 .type = QUIRK_MIDI_MIDIMAN,
1059                                 .data = & (const snd_usb_midi_endpoint_info_t) {
1060                                         .out_cables = 0x0001,
1061                                         .in_cables  = 0x0001
1062                                 }
1063                         },
1064                         {
1065                                 .ifnum = -1
1066                         }
1067                 }
1068         }
1069 },
1070
1071 /* Mark of the Unicorn devices */
1072 {
1073         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1074         USB_DEVICE(0x07fd, 0x0001),
1075         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1076                 .vendor_name = "MOTU",
1077                 .product_name = "Fastlane",
1078                 .ifnum = QUIRK_ANY_INTERFACE,
1079                 .type = QUIRK_COMPOSITE,
1080                 .data = & (const snd_usb_audio_quirk_t[]) {
1081                         {
1082                                 .ifnum = 0,
1083                                 .type = QUIRK_MIDI_MOTU
1084                         },
1085                         {
1086                                 .ifnum = 1,
1087                                 .type = QUIRK_IGNORE_INTERFACE
1088                         },
1089                         {
1090                                 .ifnum = -1
1091                         }
1092                 }
1093         }
1094 },
1095
1096 {
1097         /* Creative Sound Blaster MP3+ */
1098         USB_DEVICE(0x041e, 0x3010),
1099         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1100                 .vendor_name = "Creative Labs",
1101                 .product_name = "Sound Blaster MP3+",
1102                 .ifnum = QUIRK_NO_INTERFACE
1103         }
1104         
1105 },
1106
1107 /* Emagic devices */
1108 {
1109         USB_DEVICE(0x086a, 0x0001),
1110         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1111                 .vendor_name = "Emagic",
1112                 /* .product_name = "Unitor8", */
1113                 .ifnum = 2,
1114                 .type = QUIRK_MIDI_EMAGIC,
1115                 .data = & (const snd_usb_midi_endpoint_info_t) {
1116                         .out_cables = 0x80ff,
1117                         .in_cables  = 0x80ff
1118                 }
1119         }
1120 },
1121 {
1122         USB_DEVICE(0x086a, 0x0002),
1123         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1124                 .vendor_name = "Emagic",
1125                 /* .product_name = "AMT8", */
1126                 .ifnum = 2,
1127                 .type = QUIRK_MIDI_EMAGIC,
1128                 .data = & (const snd_usb_midi_endpoint_info_t) {
1129                         .out_cables = 0x80ff,
1130                         .in_cables  = 0x80ff
1131                 }
1132         }
1133 },
1134 {
1135         USB_DEVICE(0x086a, 0x0003),
1136         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1137                 .vendor_name = "Emagic",
1138                 /* .product_name = "MT4", */
1139                 .ifnum = 2,
1140                 .type = QUIRK_MIDI_EMAGIC,
1141                 .data = & (const snd_usb_midi_endpoint_info_t) {
1142                         .out_cables = 0x800f,
1143                         .in_cables  = 0x8003
1144                 }
1145         }
1146 },
1147
1148 {
1149         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1150         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1151                 .vendor_name = "Terratec",
1152                 .product_name = "PHASE 26",
1153                 .ifnum = 3,
1154                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1155         }
1156 },
1157
1158 /* Novation EMS devices */
1159 {
1160         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
1161         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1162                 .vendor_name = "Novation",
1163                 .product_name = "ReMOTE Audio/XStation",
1164                 .ifnum = 4,
1165                 .type = QUIRK_MIDI_NOVATION
1166         }
1167 },
1168 {
1169         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
1170         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1171                 .vendor_name = "Novation",
1172                 .product_name = "Speedio",
1173                 .ifnum = 3,
1174                 .type = QUIRK_MIDI_NOVATION
1175         }
1176 },
1177 {
1178         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
1179         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1180                 .vendor_name = "Novation",
1181                 .product_name = "ReMOTE25",
1182                 .ifnum = 0,
1183                 .type = QUIRK_MIDI_NOVATION
1184         }
1185 },
1186
1187 {
1188         /*
1189          * Some USB MIDI devices don't have an audio control interface,
1190          * so we have to grab MIDI streaming interfaces here.
1191          */
1192         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
1193                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
1194         .bInterfaceClass = USB_CLASS_AUDIO,
1195         .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
1196         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1197                 .ifnum = QUIRK_ANY_INTERFACE,
1198                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1199         }
1200 },
1201
1202 #undef USB_DEVICE_VENDOR_SPEC