Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
quirks-table.h
Go to the documentation of this file.
1 /*
2  * ALSA USB Audio Driver
3  *
4  * Copyright (c) 2002 by Takashi Iwai <[email protected]>,
5  * Clemens Ladisch <[email protected]>
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 /* FTDI devices */
43 {
44  USB_DEVICE(0x0403, 0xb8d8),
45  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
46  /* .vendor_name = "STARR LABS", */
47  /* .product_name = "Starr Labs MIDI USB device", */
48  .ifnum = 0,
49  .type = QUIRK_MIDI_FTDI
50  }
51 },
52 
53 /* Creative/Toshiba Multimedia Center SB-0500 */
54 {
55  USB_DEVICE(0x041e, 0x3048),
56  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
57  .vendor_name = "Toshiba",
58  .product_name = "SB-0500",
59  .ifnum = QUIRK_NO_INTERFACE
60  }
61 },
62 
63 /* Creative/E-Mu devices */
64 {
65  USB_DEVICE(0x041e, 0x3010),
66  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
67  .vendor_name = "Creative Labs",
68  .product_name = "Sound Blaster MP3+",
69  .ifnum = QUIRK_NO_INTERFACE
70  }
71 },
72 {
73  /* E-Mu 0202 USB */
74  .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
75  .idVendor = 0x041e,
76  .idProduct = 0x3f02,
77  .bInterfaceClass = USB_CLASS_AUDIO,
78 },
79 {
80  /* E-Mu 0404 USB */
81  .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
82  .idVendor = 0x041e,
83  .idProduct = 0x3f04,
84  .bInterfaceClass = USB_CLASS_AUDIO,
85 },
86 {
87  /* E-Mu Tracker Pre */
88  .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
89  .idVendor = 0x041e,
90  .idProduct = 0x3f0a,
91  .bInterfaceClass = USB_CLASS_AUDIO,
92 },
93 {
94  /* E-Mu 0204 USB */
95  .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
96  .idVendor = 0x041e,
97  .idProduct = 0x3f19,
98  .bInterfaceClass = USB_CLASS_AUDIO,
99 },
100 
101 /*
102  * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
103  * class matches do not take effect without an explicit ID match.
104  */
105 {
106  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
107  USB_DEVICE_ID_MATCH_INT_CLASS |
108  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
109  .idVendor = 0x046d,
110  .idProduct = 0x0850,
111  .bInterfaceClass = USB_CLASS_AUDIO,
112  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
113 },
114 {
115  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
116  USB_DEVICE_ID_MATCH_INT_CLASS |
117  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
118  .idVendor = 0x046d,
119  .idProduct = 0x08ae,
120  .bInterfaceClass = USB_CLASS_AUDIO,
121  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
122 },
123 {
124  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
125  USB_DEVICE_ID_MATCH_INT_CLASS |
126  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
127  .idVendor = 0x046d,
128  .idProduct = 0x08c6,
129  .bInterfaceClass = USB_CLASS_AUDIO,
130  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
131 },
132 {
133  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
134  USB_DEVICE_ID_MATCH_INT_CLASS |
135  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
136  .idVendor = 0x046d,
137  .idProduct = 0x08f0,
138  .bInterfaceClass = USB_CLASS_AUDIO,
139  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
140 },
141 {
142  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
143  USB_DEVICE_ID_MATCH_INT_CLASS |
144  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
145  .idVendor = 0x046d,
146  .idProduct = 0x08f5,
147  .bInterfaceClass = USB_CLASS_AUDIO,
148  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
149 },
150 {
151  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
152  USB_DEVICE_ID_MATCH_INT_CLASS |
153  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
154  .idVendor = 0x046d,
155  .idProduct = 0x08f6,
156  .bInterfaceClass = USB_CLASS_AUDIO,
157  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
158 },
159 {
160  USB_DEVICE(0x046d, 0x0990),
161  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
162  .vendor_name = "Logitech, Inc.",
163  .product_name = "QuickCam Pro 9000",
164  .ifnum = QUIRK_NO_INTERFACE
165  }
166 },
167 
168 /*
169  * Yamaha devices
170  */
171 
172 #define YAMAHA_DEVICE(id, name) { \
173  USB_DEVICE(0x0499, id), \
174  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
175  .vendor_name = "Yamaha", \
176  .product_name = name, \
177  .ifnum = QUIRK_ANY_INTERFACE, \
178  .type = QUIRK_MIDI_YAMAHA \
179  } \
180 }
181 #define YAMAHA_INTERFACE(id, intf, name) { \
182  USB_DEVICE_VENDOR_SPEC(0x0499, id), \
183  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
184  .vendor_name = "Yamaha", \
185  .product_name = name, \
186  .ifnum = intf, \
187  .type = QUIRK_MIDI_YAMAHA \
188  } \
189 }
190 YAMAHA_DEVICE(0x1000, "UX256"),
191 YAMAHA_DEVICE(0x1001, "MU1000"),
192 YAMAHA_DEVICE(0x1002, "MU2000"),
193 YAMAHA_DEVICE(0x1003, "MU500"),
194 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
195 YAMAHA_DEVICE(0x1005, "MOTIF6"),
196 YAMAHA_DEVICE(0x1006, "MOTIF7"),
197 YAMAHA_DEVICE(0x1007, "MOTIF8"),
198 YAMAHA_DEVICE(0x1008, "UX96"),
199 YAMAHA_DEVICE(0x1009, "UX16"),
200 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
201 YAMAHA_DEVICE(0x100c, "UC-MX"),
202 YAMAHA_DEVICE(0x100d, "UC-KX"),
203 YAMAHA_DEVICE(0x100e, "S08"),
204 YAMAHA_DEVICE(0x100f, "CLP-150"),
205 YAMAHA_DEVICE(0x1010, "CLP-170"),
206 YAMAHA_DEVICE(0x1011, "P-250"),
207 YAMAHA_DEVICE(0x1012, "TYROS"),
208 YAMAHA_DEVICE(0x1013, "PF-500"),
209 YAMAHA_DEVICE(0x1014, "S90"),
210 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
211 YAMAHA_DEVICE(0x1016, "MDP-5"),
212 YAMAHA_DEVICE(0x1017, "CVP-204"),
213 YAMAHA_DEVICE(0x1018, "CVP-206"),
214 YAMAHA_DEVICE(0x1019, "CVP-208"),
215 YAMAHA_DEVICE(0x101a, "CVP-210"),
216 YAMAHA_DEVICE(0x101b, "PSR-1100"),
217 YAMAHA_DEVICE(0x101c, "PSR-2100"),
218 YAMAHA_DEVICE(0x101d, "CLP-175"),
219 YAMAHA_DEVICE(0x101e, "PSR-K1"),
220 YAMAHA_DEVICE(0x101f, "EZ-J24"),
221 YAMAHA_DEVICE(0x1020, "EZ-250i"),
222 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
223 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
224 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
225 YAMAHA_DEVICE(0x1024, "CVP-301"),
226 YAMAHA_DEVICE(0x1025, "CVP-303"),
227 YAMAHA_DEVICE(0x1026, "CVP-305"),
228 YAMAHA_DEVICE(0x1027, "CVP-307"),
229 YAMAHA_DEVICE(0x1028, "CVP-309"),
230 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
231 YAMAHA_DEVICE(0x102a, "PSR-1500"),
232 YAMAHA_DEVICE(0x102b, "PSR-3000"),
233 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
234 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
235 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
236 YAMAHA_DEVICE(0x1032, "DGX-305"),
237 YAMAHA_DEVICE(0x1033, "DGX-505"),
238 YAMAHA_DEVICE(0x1034, NULL),
239 YAMAHA_DEVICE(0x1035, NULL),
240 YAMAHA_DEVICE(0x1036, NULL),
241 YAMAHA_DEVICE(0x1037, NULL),
242 YAMAHA_DEVICE(0x1038, NULL),
243 YAMAHA_DEVICE(0x1039, NULL),
244 YAMAHA_DEVICE(0x103a, NULL),
245 YAMAHA_DEVICE(0x103b, NULL),
246 YAMAHA_DEVICE(0x103c, NULL),
247 YAMAHA_DEVICE(0x103d, NULL),
248 YAMAHA_DEVICE(0x103e, NULL),
249 YAMAHA_DEVICE(0x103f, NULL),
250 YAMAHA_DEVICE(0x1040, NULL),
251 YAMAHA_DEVICE(0x1041, NULL),
252 YAMAHA_DEVICE(0x1042, NULL),
253 YAMAHA_DEVICE(0x1043, NULL),
254 YAMAHA_DEVICE(0x1044, NULL),
255 YAMAHA_DEVICE(0x1045, NULL),
256 YAMAHA_INTERFACE(0x104e, 0, NULL),
257 YAMAHA_DEVICE(0x104f, NULL),
258 YAMAHA_DEVICE(0x1050, NULL),
259 YAMAHA_DEVICE(0x1051, NULL),
260 YAMAHA_DEVICE(0x1052, NULL),
261 YAMAHA_INTERFACE(0x1053, 0, NULL),
262 YAMAHA_INTERFACE(0x1054, 0, NULL),
263 YAMAHA_DEVICE(0x1055, NULL),
264 YAMAHA_DEVICE(0x1056, NULL),
265 YAMAHA_DEVICE(0x1057, NULL),
266 YAMAHA_DEVICE(0x1058, NULL),
267 YAMAHA_DEVICE(0x1059, NULL),
268 YAMAHA_DEVICE(0x105a, NULL),
269 YAMAHA_DEVICE(0x105b, NULL),
270 YAMAHA_DEVICE(0x105c, NULL),
271 YAMAHA_DEVICE(0x105d, NULL),
272 {
273  USB_DEVICE(0x0499, 0x1503),
274  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
275  /* .vendor_name = "Yamaha", */
276  /* .product_name = "MOX6/MOX8", */
277  .ifnum = QUIRK_ANY_INTERFACE,
278  .type = QUIRK_COMPOSITE,
279  .data = (const struct snd_usb_audio_quirk[]) {
280  {
281  .ifnum = 1,
282  .type = QUIRK_AUDIO_STANDARD_INTERFACE
283  },
284  {
285  .ifnum = 2,
286  .type = QUIRK_AUDIO_STANDARD_INTERFACE
287  },
288  {
289  .ifnum = 3,
290  .type = QUIRK_MIDI_YAMAHA
291  },
292  {
293  .ifnum = -1
294  }
295  }
296  }
297 },
298 YAMAHA_DEVICE(0x2000, "DGP-7"),
299 YAMAHA_DEVICE(0x2001, "DGP-5"),
300 YAMAHA_DEVICE(0x2002, NULL),
301 YAMAHA_DEVICE(0x2003, NULL),
302 YAMAHA_DEVICE(0x5000, "CS1D"),
303 YAMAHA_DEVICE(0x5001, "DSP1D"),
304 YAMAHA_DEVICE(0x5002, "DME32"),
305 YAMAHA_DEVICE(0x5003, "DM2000"),
306 YAMAHA_DEVICE(0x5004, "02R96"),
307 YAMAHA_DEVICE(0x5005, "ACU16-C"),
308 YAMAHA_DEVICE(0x5006, "NHB32-C"),
309 YAMAHA_DEVICE(0x5007, "DM1000"),
310 YAMAHA_DEVICE(0x5008, "01V96"),
311 YAMAHA_DEVICE(0x5009, "SPX2000"),
312 YAMAHA_DEVICE(0x500a, "PM5D"),
313 YAMAHA_DEVICE(0x500b, "DME64N"),
314 YAMAHA_DEVICE(0x500c, "DME24N"),
315 YAMAHA_DEVICE(0x500d, NULL),
316 YAMAHA_DEVICE(0x500e, NULL),
317 YAMAHA_DEVICE(0x500f, NULL),
318 YAMAHA_DEVICE(0x7000, "DTX"),
319 YAMAHA_DEVICE(0x7010, "UB99"),
320 #undef YAMAHA_DEVICE
321 #undef YAMAHA_INTERFACE
322 
323 /*
324  * Roland/RolandED/Edirol/BOSS devices
325  */
326 {
327  USB_DEVICE(0x0582, 0x0000),
328  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
329  .vendor_name = "Roland",
330  .product_name = "UA-100",
331  .ifnum = QUIRK_ANY_INTERFACE,
332  .type = QUIRK_COMPOSITE,
333  .data = (const struct snd_usb_audio_quirk[]) {
334  {
335  .ifnum = 0,
336  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
337  .data = & (const struct audioformat) {
338  .formats = SNDRV_PCM_FMTBIT_S16_LE,
339  .channels = 4,
340  .iface = 0,
341  .altsetting = 1,
342  .altset_idx = 1,
343  .attributes = 0,
344  .endpoint = 0x01,
345  .ep_attr = 0x09,
346  .rates = SNDRV_PCM_RATE_CONTINUOUS,
347  .rate_min = 44100,
348  .rate_max = 44100,
349  }
350  },
351  {
352  .ifnum = 1,
353  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
354  .data = & (const struct audioformat) {
355  .formats = SNDRV_PCM_FMTBIT_S16_LE,
356  .channels = 2,
357  .iface = 1,
358  .altsetting = 1,
359  .altset_idx = 1,
360  .attributes = UAC_EP_CS_ATTR_FILL_MAX,
361  .endpoint = 0x81,
362  .ep_attr = 0x05,
363  .rates = SNDRV_PCM_RATE_CONTINUOUS,
364  .rate_min = 44100,
365  .rate_max = 44100,
366  }
367  },
368  {
369  .ifnum = 2,
370  .type = QUIRK_MIDI_FIXED_ENDPOINT,
371  .data = & (const struct snd_usb_midi_endpoint_info) {
372  .out_cables = 0x0007,
373  .in_cables = 0x0007
374  }
375  },
376  {
377  .ifnum = -1
378  }
379  }
380  }
381 },
382 {
383  USB_DEVICE(0x0582, 0x0002),
384  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
385  .vendor_name = "EDIROL",
386  .product_name = "UM-4",
387  .ifnum = QUIRK_ANY_INTERFACE,
388  .type = QUIRK_COMPOSITE,
389  .data = (const struct snd_usb_audio_quirk[]) {
390  {
391  .ifnum = 0,
392  .type = QUIRK_IGNORE_INTERFACE
393  },
394  {
395  .ifnum = 1,
396  .type = QUIRK_IGNORE_INTERFACE
397  },
398  {
399  .ifnum = 2,
400  .type = QUIRK_MIDI_FIXED_ENDPOINT,
401  .data = & (const struct snd_usb_midi_endpoint_info) {
402  .out_cables = 0x000f,
403  .in_cables = 0x000f
404  }
405  },
406  {
407  .ifnum = -1
408  }
409  }
410  }
411 },
412 {
413  USB_DEVICE(0x0582, 0x0003),
414  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
415  .vendor_name = "Roland",
416  .product_name = "SC-8850",
417  .ifnum = QUIRK_ANY_INTERFACE,
418  .type = QUIRK_COMPOSITE,
419  .data = (const struct snd_usb_audio_quirk[]) {
420  {
421  .ifnum = 0,
422  .type = QUIRK_IGNORE_INTERFACE
423  },
424  {
425  .ifnum = 1,
426  .type = QUIRK_IGNORE_INTERFACE
427  },
428  {
429  .ifnum = 2,
430  .type = QUIRK_MIDI_FIXED_ENDPOINT,
431  .data = & (const struct snd_usb_midi_endpoint_info) {
432  .out_cables = 0x003f,
433  .in_cables = 0x003f
434  }
435  },
436  {
437  .ifnum = -1
438  }
439  }
440  }
441 },
442 {
443  USB_DEVICE(0x0582, 0x0004),
444  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
445  .vendor_name = "Roland",
446  .product_name = "U-8",
447  .ifnum = QUIRK_ANY_INTERFACE,
448  .type = QUIRK_COMPOSITE,
449  .data = (const struct snd_usb_audio_quirk[]) {
450  {
451  .ifnum = 0,
452  .type = QUIRK_IGNORE_INTERFACE
453  },
454  {
455  .ifnum = 1,
456  .type = QUIRK_IGNORE_INTERFACE
457  },
458  {
459  .ifnum = 2,
460  .type = QUIRK_MIDI_FIXED_ENDPOINT,
461  .data = & (const struct snd_usb_midi_endpoint_info) {
462  .out_cables = 0x0005,
463  .in_cables = 0x0005
464  }
465  },
466  {
467  .ifnum = -1
468  }
469  }
470  }
471 },
472 {
473  /* Has ID 0x0099 when not in "Advanced Driver" mode.
474  * The UM-2EX has only one input, but we cannot detect this. */
475  USB_DEVICE(0x0582, 0x0005),
476  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
477  .vendor_name = "EDIROL",
478  .product_name = "UM-2",
479  .ifnum = QUIRK_ANY_INTERFACE,
480  .type = QUIRK_COMPOSITE,
481  .data = (const struct snd_usb_audio_quirk[]) {
482  {
483  .ifnum = 0,
484  .type = QUIRK_IGNORE_INTERFACE
485  },
486  {
487  .ifnum = 1,
488  .type = QUIRK_IGNORE_INTERFACE
489  },
490  {
491  .ifnum = 2,
492  .type = QUIRK_MIDI_FIXED_ENDPOINT,
493  .data = & (const struct snd_usb_midi_endpoint_info) {
494  .out_cables = 0x0003,
495  .in_cables = 0x0003
496  }
497  },
498  {
499  .ifnum = -1
500  }
501  }
502  }
503 },
504 {
505  USB_DEVICE(0x0582, 0x0007),
506  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
507  .vendor_name = "Roland",
508  .product_name = "SC-8820",
509  .ifnum = QUIRK_ANY_INTERFACE,
510  .type = QUIRK_COMPOSITE,
511  .data = (const struct snd_usb_audio_quirk[]) {
512  {
513  .ifnum = 0,
514  .type = QUIRK_IGNORE_INTERFACE
515  },
516  {
517  .ifnum = 1,
518  .type = QUIRK_IGNORE_INTERFACE
519  },
520  {
521  .ifnum = 2,
522  .type = QUIRK_MIDI_FIXED_ENDPOINT,
523  .data = & (const struct snd_usb_midi_endpoint_info) {
524  .out_cables = 0x0013,
525  .in_cables = 0x0013
526  }
527  },
528  {
529  .ifnum = -1
530  }
531  }
532  }
533 },
534 {
535  USB_DEVICE(0x0582, 0x0008),
536  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
537  .vendor_name = "Roland",
538  .product_name = "PC-300",
539  .ifnum = QUIRK_ANY_INTERFACE,
540  .type = QUIRK_COMPOSITE,
541  .data = (const struct snd_usb_audio_quirk[]) {
542  {
543  .ifnum = 0,
544  .type = QUIRK_IGNORE_INTERFACE
545  },
546  {
547  .ifnum = 1,
548  .type = QUIRK_IGNORE_INTERFACE
549  },
550  {
551  .ifnum = 2,
552  .type = QUIRK_MIDI_FIXED_ENDPOINT,
553  .data = & (const struct snd_usb_midi_endpoint_info) {
554  .out_cables = 0x0001,
555  .in_cables = 0x0001
556  }
557  },
558  {
559  .ifnum = -1
560  }
561  }
562  }
563 },
564 {
565  /* has ID 0x009d when not in "Advanced Driver" mode */
566  USB_DEVICE(0x0582, 0x0009),
567  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
568  .vendor_name = "EDIROL",
569  .product_name = "UM-1",
570  .ifnum = QUIRK_ANY_INTERFACE,
571  .type = QUIRK_COMPOSITE,
572  .data = (const struct snd_usb_audio_quirk[]) {
573  {
574  .ifnum = 0,
575  .type = QUIRK_IGNORE_INTERFACE
576  },
577  {
578  .ifnum = 1,
579  .type = QUIRK_IGNORE_INTERFACE
580  },
581  {
582  .ifnum = 2,
583  .type = QUIRK_MIDI_FIXED_ENDPOINT,
584  .data = & (const struct snd_usb_midi_endpoint_info) {
585  .out_cables = 0x0001,
586  .in_cables = 0x0001
587  }
588  },
589  {
590  .ifnum = -1
591  }
592  }
593  }
594 },
595 {
596  USB_DEVICE(0x0582, 0x000b),
597  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
598  .vendor_name = "Roland",
599  .product_name = "SK-500",
600  .ifnum = QUIRK_ANY_INTERFACE,
601  .type = QUIRK_COMPOSITE,
602  .data = (const struct snd_usb_audio_quirk[]) {
603  {
604  .ifnum = 0,
605  .type = QUIRK_IGNORE_INTERFACE
606  },
607  {
608  .ifnum = 1,
609  .type = QUIRK_IGNORE_INTERFACE
610  },
611  {
612  .ifnum = 2,
613  .type = QUIRK_MIDI_FIXED_ENDPOINT,
614  .data = & (const struct snd_usb_midi_endpoint_info) {
615  .out_cables = 0x0013,
616  .in_cables = 0x0013
617  }
618  },
619  {
620  .ifnum = -1
621  }
622  }
623  }
624 },
625 {
626  /* thanks to Emiliano Grilli <[email protected]>
627  * for helping researching this data */
628  USB_DEVICE(0x0582, 0x000c),
629  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
630  .vendor_name = "Roland",
631  .product_name = "SC-D70",
632  .ifnum = QUIRK_ANY_INTERFACE,
633  .type = QUIRK_COMPOSITE,
634  .data = (const struct snd_usb_audio_quirk[]) {
635  {
636  .ifnum = 0,
637  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
638  .data = & (const struct audioformat) {
639  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
640  .channels = 2,
641  .iface = 0,
642  .altsetting = 1,
643  .altset_idx = 1,
644  .attributes = 0,
645  .endpoint = 0x01,
646  .ep_attr = 0x01,
647  .rates = SNDRV_PCM_RATE_CONTINUOUS,
648  .rate_min = 44100,
649  .rate_max = 44100,
650  }
651  },
652  {
653  .ifnum = 1,
654  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
655  .data = & (const struct audioformat) {
656  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
657  .channels = 2,
658  .iface = 1,
659  .altsetting = 1,
660  .altset_idx = 1,
661  .attributes = 0,
662  .endpoint = 0x81,
663  .ep_attr = 0x01,
664  .rates = SNDRV_PCM_RATE_CONTINUOUS,
665  .rate_min = 44100,
666  .rate_max = 44100,
667  }
668  },
669  {
670  .ifnum = 2,
671  .type = QUIRK_MIDI_FIXED_ENDPOINT,
672  .data = & (const struct snd_usb_midi_endpoint_info) {
673  .out_cables = 0x0007,
674  .in_cables = 0x0007
675  }
676  },
677  {
678  .ifnum = -1
679  }
680  }
681  }
682 },
683 { /*
684  * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
685  * If the advanced mode switch at the back of the unit is off, the
686  * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
687  * but offers only 16-bit PCM.
688  * In advanced mode, the UA-5 will output S24_3LE samples (two
689  * channels) at the rate indicated on the front switch, including
690  * the 96kHz sample rate.
691  */
692  USB_DEVICE(0x0582, 0x0010),
693  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
694  .vendor_name = "EDIROL",
695  .product_name = "UA-5",
696  .ifnum = QUIRK_ANY_INTERFACE,
697  .type = QUIRK_COMPOSITE,
698  .data = (const struct snd_usb_audio_quirk[]) {
699  {
700  .ifnum = 1,
701  .type = QUIRK_AUDIO_STANDARD_INTERFACE
702  },
703  {
704  .ifnum = 2,
705  .type = QUIRK_AUDIO_STANDARD_INTERFACE
706  },
707  {
708  .ifnum = -1
709  }
710  }
711  }
712 },
713 {
714  /* has ID 0x0013 when not in "Advanced Driver" mode */
715  USB_DEVICE(0x0582, 0x0012),
716  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
717  .vendor_name = "Roland",
718  .product_name = "XV-5050",
719  .ifnum = 0,
720  .type = QUIRK_MIDI_FIXED_ENDPOINT,
721  .data = & (const struct snd_usb_midi_endpoint_info) {
722  .out_cables = 0x0001,
723  .in_cables = 0x0001
724  }
725  }
726 },
727 {
728  /* has ID 0x0015 when not in "Advanced Driver" mode */
729  USB_DEVICE(0x0582, 0x0014),
730  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
731  .vendor_name = "EDIROL",
732  .product_name = "UM-880",
733  .ifnum = 0,
734  .type = QUIRK_MIDI_FIXED_ENDPOINT,
735  .data = & (const struct snd_usb_midi_endpoint_info) {
736  .out_cables = 0x01ff,
737  .in_cables = 0x01ff
738  }
739  }
740 },
741 {
742  /* has ID 0x0017 when not in "Advanced Driver" mode */
743  USB_DEVICE(0x0582, 0x0016),
744  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
745  .vendor_name = "EDIROL",
746  .product_name = "SD-90",
747  .ifnum = QUIRK_ANY_INTERFACE,
748  .type = QUIRK_COMPOSITE,
749  .data = (const struct snd_usb_audio_quirk[]) {
750  {
751  .ifnum = 0,
752  .type = QUIRK_AUDIO_STANDARD_INTERFACE
753  },
754  {
755  .ifnum = 1,
756  .type = QUIRK_AUDIO_STANDARD_INTERFACE
757  },
758  {
759  .ifnum = 2,
760  .type = QUIRK_MIDI_FIXED_ENDPOINT,
761  .data = & (const struct snd_usb_midi_endpoint_info) {
762  .out_cables = 0x000f,
763  .in_cables = 0x000f
764  }
765  },
766  {
767  .ifnum = -1
768  }
769  }
770  }
771 },
772 {
773  /* has ID 0x001c when not in "Advanced Driver" mode */
774  USB_DEVICE(0x0582, 0x001b),
775  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
776  .vendor_name = "Roland",
777  .product_name = "MMP-2",
778  .ifnum = QUIRK_ANY_INTERFACE,
779  .type = QUIRK_COMPOSITE,
780  .data = (const struct snd_usb_audio_quirk[]) {
781  {
782  .ifnum = 0,
783  .type = QUIRK_IGNORE_INTERFACE
784  },
785  {
786  .ifnum = 1,
787  .type = QUIRK_IGNORE_INTERFACE
788  },
789  {
790  .ifnum = 2,
791  .type = QUIRK_MIDI_FIXED_ENDPOINT,
792  .data = & (const struct snd_usb_midi_endpoint_info) {
793  .out_cables = 0x0001,
794  .in_cables = 0x0001
795  }
796  },
797  {
798  .ifnum = -1
799  }
800  }
801  }
802 },
803 {
804  /* has ID 0x001e when not in "Advanced Driver" mode */
805  USB_DEVICE(0x0582, 0x001d),
806  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
807  .vendor_name = "Roland",
808  .product_name = "V-SYNTH",
809  .ifnum = 0,
810  .type = QUIRK_MIDI_FIXED_ENDPOINT,
811  .data = & (const struct snd_usb_midi_endpoint_info) {
812  .out_cables = 0x0001,
813  .in_cables = 0x0001
814  }
815  }
816 },
817 {
818  /* has ID 0x0024 when not in "Advanced Driver" mode */
819  USB_DEVICE(0x0582, 0x0023),
820  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
821  .vendor_name = "EDIROL",
822  .product_name = "UM-550",
823  .ifnum = 0,
824  .type = QUIRK_MIDI_FIXED_ENDPOINT,
825  .data = & (const struct snd_usb_midi_endpoint_info) {
826  .out_cables = 0x003f,
827  .in_cables = 0x003f
828  }
829  }
830 },
831 {
832  /*
833  * This quirk is for the "Advanced Driver" mode. If off, the UA-20
834  * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
835  * and no MIDI.
836  */
837  USB_DEVICE(0x0582, 0x0025),
838  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
839  .vendor_name = "EDIROL",
840  .product_name = "UA-20",
841  .ifnum = QUIRK_ANY_INTERFACE,
842  .type = QUIRK_COMPOSITE,
843  .data = (const struct snd_usb_audio_quirk[]) {
844  {
845  .ifnum = 0,
846  .type = QUIRK_IGNORE_INTERFACE
847  },
848  {
849  .ifnum = 1,
850  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
851  .data = & (const struct audioformat) {
852  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
853  .channels = 2,
854  .iface = 1,
855  .altsetting = 1,
856  .altset_idx = 1,
857  .attributes = 0,
858  .endpoint = 0x01,
859  .ep_attr = 0x01,
860  .rates = SNDRV_PCM_RATE_CONTINUOUS,
861  .rate_min = 44100,
862  .rate_max = 44100,
863  }
864  },
865  {
866  .ifnum = 2,
867  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
868  .data = & (const struct audioformat) {
869  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
870  .channels = 2,
871  .iface = 2,
872  .altsetting = 1,
873  .altset_idx = 1,
874  .attributes = 0,
875  .endpoint = 0x82,
876  .ep_attr = 0x01,
877  .rates = SNDRV_PCM_RATE_CONTINUOUS,
878  .rate_min = 44100,
879  .rate_max = 44100,
880  }
881  },
882  {
883  .ifnum = 3,
884  .type = QUIRK_MIDI_FIXED_ENDPOINT,
885  .data = & (const struct snd_usb_midi_endpoint_info) {
886  .out_cables = 0x0001,
887  .in_cables = 0x0001
888  }
889  },
890  {
891  .ifnum = -1
892  }
893  }
894  }
895 },
896 {
897  /* has ID 0x0028 when not in "Advanced Driver" mode */
898  USB_DEVICE(0x0582, 0x0027),
899  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
900  .vendor_name = "EDIROL",
901  .product_name = "SD-20",
902  .ifnum = 0,
903  .type = QUIRK_MIDI_FIXED_ENDPOINT,
904  .data = & (const struct snd_usb_midi_endpoint_info) {
905  .out_cables = 0x0003,
906  .in_cables = 0x0007
907  }
908  }
909 },
910 {
911  /* has ID 0x002a when not in "Advanced Driver" mode */
912  USB_DEVICE(0x0582, 0x0029),
913  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
914  .vendor_name = "EDIROL",
915  .product_name = "SD-80",
916  .ifnum = 0,
917  .type = QUIRK_MIDI_FIXED_ENDPOINT,
918  .data = & (const struct snd_usb_midi_endpoint_info) {
919  .out_cables = 0x000f,
920  .in_cables = 0x000f
921  }
922  }
923 },
924 { /*
925  * This quirk is for the "Advanced" modes of the Edirol UA-700.
926  * If the sample format switch is not in an advanced setting, the
927  * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
928  * but offers only 16-bit PCM and no MIDI.
929  */
930  USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
931  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
932  .vendor_name = "EDIROL",
933  .product_name = "UA-700",
934  .ifnum = QUIRK_ANY_INTERFACE,
935  .type = QUIRK_COMPOSITE,
936  .data = (const struct snd_usb_audio_quirk[]) {
937  {
938  .ifnum = 1,
939  .type = QUIRK_AUDIO_EDIROL_UAXX
940  },
941  {
942  .ifnum = 2,
943  .type = QUIRK_AUDIO_EDIROL_UAXX
944  },
945  {
946  .ifnum = 3,
947  .type = QUIRK_AUDIO_EDIROL_UAXX
948  },
949  {
950  .ifnum = -1
951  }
952  }
953  }
954 },
955 {
956  /* has ID 0x002e when not in "Advanced Driver" mode */
957  USB_DEVICE(0x0582, 0x002d),
958  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
959  .vendor_name = "Roland",
960  .product_name = "XV-2020",
961  .ifnum = 0,
962  .type = QUIRK_MIDI_FIXED_ENDPOINT,
963  .data = & (const struct snd_usb_midi_endpoint_info) {
964  .out_cables = 0x0001,
965  .in_cables = 0x0001
966  }
967  }
968 },
969 {
970  /* has ID 0x0030 when not in "Advanced Driver" mode */
971  USB_DEVICE(0x0582, 0x002f),
972  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
973  .vendor_name = "Roland",
974  .product_name = "VariOS",
975  .ifnum = 0,
976  .type = QUIRK_MIDI_FIXED_ENDPOINT,
977  .data = & (const struct snd_usb_midi_endpoint_info) {
978  .out_cables = 0x0007,
979  .in_cables = 0x0007
980  }
981  }
982 },
983 {
984  /* has ID 0x0034 when not in "Advanced Driver" mode */
985  USB_DEVICE(0x0582, 0x0033),
986  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
987  .vendor_name = "EDIROL",
988  .product_name = "PCR",
989  .ifnum = 0,
990  .type = QUIRK_MIDI_FIXED_ENDPOINT,
991  .data = & (const struct snd_usb_midi_endpoint_info) {
992  .out_cables = 0x0003,
993  .in_cables = 0x0007
994  }
995  }
996 },
997  /* TODO: add Roland M-1000 support */
998 {
999  /*
1000  * Has ID 0x0038 when not in "Advanced Driver" mode;
1001  * later revisions use IDs 0x0054 and 0x00a2.
1002  */
1003  USB_DEVICE(0x0582, 0x0037),
1004  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1005  .vendor_name = "Roland",
1006  .product_name = "Digital Piano",
1007  .ifnum = 0,
1008  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1009  .data = & (const struct snd_usb_midi_endpoint_info) {
1010  .out_cables = 0x0001,
1011  .in_cables = 0x0001
1012  }
1013  }
1014 },
1015 {
1016  /*
1017  * This quirk is for the "Advanced Driver" mode. If off, the GS-10
1018  * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1019  * and no MIDI.
1020  */
1021  USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1022  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1023  .vendor_name = "BOSS",
1024  .product_name = "GS-10",
1025  .ifnum = QUIRK_ANY_INTERFACE,
1026  .type = QUIRK_COMPOSITE,
1027  .data = & (const struct snd_usb_audio_quirk[]) {
1028  {
1029  .ifnum = 1,
1030  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1031  },
1032  {
1033  .ifnum = 2,
1034  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1035  },
1036  {
1037  .ifnum = 3,
1038  .type = QUIRK_MIDI_STANDARD_INTERFACE
1039  },
1040  {
1041  .ifnum = -1
1042  }
1043  }
1044  }
1045 },
1046 {
1047  /* has ID 0x0041 when not in "Advanced Driver" mode */
1048  USB_DEVICE(0x0582, 0x0040),
1049  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1050  .vendor_name = "Roland",
1051  .product_name = "GI-20",
1052  .ifnum = 0,
1053  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1054  .data = & (const struct snd_usb_midi_endpoint_info) {
1055  .out_cables = 0x0001,
1056  .in_cables = 0x0001
1057  }
1058  }
1059 },
1060 {
1061  /* has ID 0x0043 when not in "Advanced Driver" mode */
1062  USB_DEVICE(0x0582, 0x0042),
1063  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1064  .vendor_name = "Roland",
1065  .product_name = "RS-70",
1066  .ifnum = 0,
1067  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1068  .data = & (const struct snd_usb_midi_endpoint_info) {
1069  .out_cables = 0x0001,
1070  .in_cables = 0x0001
1071  }
1072  }
1073 },
1074 {
1075  /* has ID 0x0049 when not in "Advanced Driver" mode */
1076  USB_DEVICE(0x0582, 0x0047),
1077  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1078  /* .vendor_name = "EDIROL", */
1079  /* .product_name = "UR-80", */
1080  .ifnum = QUIRK_ANY_INTERFACE,
1081  .type = QUIRK_COMPOSITE,
1082  .data = (const struct snd_usb_audio_quirk[]) {
1083  /* in the 96 kHz modes, only interface 1 is there */
1084  {
1085  .ifnum = 1,
1086  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1087  },
1088  {
1089  .ifnum = 2,
1090  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1091  },
1092  {
1093  .ifnum = -1
1094  }
1095  }
1096  }
1097 },
1098 {
1099  /* has ID 0x004a when not in "Advanced Driver" mode */
1100  USB_DEVICE(0x0582, 0x0048),
1101  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1102  /* .vendor_name = "EDIROL", */
1103  /* .product_name = "UR-80", */
1104  .ifnum = 0,
1105  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1106  .data = & (const struct snd_usb_midi_endpoint_info) {
1107  .out_cables = 0x0003,
1108  .in_cables = 0x0007
1109  }
1110  }
1111 },
1112  /* TODO: add Edirol M-100FX support */
1113 {
1114  /* has ID 0x004e when not in "Advanced Driver" mode */
1115  USB_DEVICE(0x0582, 0x004c),
1116  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1117  .vendor_name = "EDIROL",
1118  .product_name = "PCR-A",
1119  .ifnum = QUIRK_ANY_INTERFACE,
1120  .type = QUIRK_COMPOSITE,
1121  .data = (const struct snd_usb_audio_quirk[]) {
1122  {
1123  .ifnum = 1,
1124  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1125  },
1126  {
1127  .ifnum = 2,
1128  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1129  },
1130  {
1131  .ifnum = -1
1132  }
1133  }
1134  }
1135 },
1136 {
1137  /* has ID 0x004f when not in "Advanced Driver" mode */
1138  USB_DEVICE(0x0582, 0x004d),
1139  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1140  .vendor_name = "EDIROL",
1141  .product_name = "PCR-A",
1142  .ifnum = 0,
1143  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1144  .data = & (const struct snd_usb_midi_endpoint_info) {
1145  .out_cables = 0x0003,
1146  .in_cables = 0x0007
1147  }
1148  }
1149 },
1150 {
1151  /*
1152  * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1153  * is standard compliant, but has only 16-bit PCM.
1154  */
1155  USB_DEVICE(0x0582, 0x0050),
1156  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1157  .vendor_name = "EDIROL",
1158  .product_name = "UA-3FX",
1159  .ifnum = QUIRK_ANY_INTERFACE,
1160  .type = QUIRK_COMPOSITE,
1161  .data = (const struct snd_usb_audio_quirk[]) {
1162  {
1163  .ifnum = 1,
1164  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1165  },
1166  {
1167  .ifnum = 2,
1168  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1169  },
1170  {
1171  .ifnum = -1
1172  }
1173  }
1174  }
1175 },
1176 {
1177  USB_DEVICE(0x0582, 0x0052),
1178  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1179  .vendor_name = "EDIROL",
1180  .product_name = "UM-1SX",
1181  .ifnum = 0,
1182  .type = QUIRK_MIDI_STANDARD_INTERFACE
1183  }
1184 },
1185 {
1186  USB_DEVICE(0x0582, 0x0060),
1187  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1188  .vendor_name = "Roland",
1189  .product_name = "EXR Series",
1190  .ifnum = 0,
1191  .type = QUIRK_MIDI_STANDARD_INTERFACE
1192  }
1193 },
1194 {
1195  /* has ID 0x0066 when not in "Advanced Driver" mode */
1196  USB_DEVICE(0x0582, 0x0064),
1197  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1198  /* .vendor_name = "EDIROL", */
1199  /* .product_name = "PCR-1", */
1200  .ifnum = QUIRK_ANY_INTERFACE,
1201  .type = QUIRK_COMPOSITE,
1202  .data = (const struct snd_usb_audio_quirk[]) {
1203  {
1204  .ifnum = 1,
1205  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1206  },
1207  {
1208  .ifnum = 2,
1209  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1210  },
1211  {
1212  .ifnum = -1
1213  }
1214  }
1215  }
1216 },
1217 {
1218  /* has ID 0x0067 when not in "Advanced Driver" mode */
1219  USB_DEVICE(0x0582, 0x0065),
1220  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1221  /* .vendor_name = "EDIROL", */
1222  /* .product_name = "PCR-1", */
1223  .ifnum = 0,
1224  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1225  .data = & (const struct snd_usb_midi_endpoint_info) {
1226  .out_cables = 0x0001,
1227  .in_cables = 0x0003
1228  }
1229  }
1230 },
1231 {
1232  /* has ID 0x006b when not in "Advanced Driver" mode */
1233  USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1234  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1235  .vendor_name = "Roland",
1236  .product_name = "SP-606",
1237  .ifnum = 3,
1238  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1239  .data = & (const struct snd_usb_midi_endpoint_info) {
1240  .out_cables = 0x0001,
1241  .in_cables = 0x0001
1242  }
1243  }
1244 },
1245 {
1246  /* has ID 0x006e when not in "Advanced Driver" mode */
1247  USB_DEVICE(0x0582, 0x006d),
1248  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1249  .vendor_name = "Roland",
1250  .product_name = "FANTOM-X",
1251  .ifnum = 0,
1252  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1253  .data = & (const struct snd_usb_midi_endpoint_info) {
1254  .out_cables = 0x0001,
1255  .in_cables = 0x0001
1256  }
1257  }
1258 },
1259 { /*
1260  * This quirk is for the "Advanced" modes of the Edirol UA-25.
1261  * If the switch is not in an advanced setting, the UA-25 has
1262  * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1263  * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1264  */
1265  USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1266  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1267  .vendor_name = "EDIROL",
1268  .product_name = "UA-25",
1269  .ifnum = QUIRK_ANY_INTERFACE,
1270  .type = QUIRK_COMPOSITE,
1271  .data = (const struct snd_usb_audio_quirk[]) {
1272  {
1273  .ifnum = 0,
1274  .type = QUIRK_AUDIO_EDIROL_UAXX
1275  },
1276  {
1277  .ifnum = 1,
1278  .type = QUIRK_AUDIO_EDIROL_UAXX
1279  },
1280  {
1281  .ifnum = 2,
1282  .type = QUIRK_AUDIO_EDIROL_UAXX
1283  },
1284  {
1285  .ifnum = -1
1286  }
1287  }
1288  }
1289 },
1290 {
1291  /* has ID 0x0076 when not in "Advanced Driver" mode */
1292  USB_DEVICE(0x0582, 0x0075),
1293  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1294  .vendor_name = "BOSS",
1295  .product_name = "DR-880",
1296  .ifnum = 0,
1297  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1298  .data = & (const struct snd_usb_midi_endpoint_info) {
1299  .out_cables = 0x0001,
1300  .in_cables = 0x0001
1301  }
1302  }
1303 },
1304 {
1305  /* has ID 0x007b when not in "Advanced Driver" mode */
1306  USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1307  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1308  .vendor_name = "Roland",
1309  /* "RD" or "RD-700SX"? */
1310  .ifnum = 0,
1311  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1312  .data = & (const struct snd_usb_midi_endpoint_info) {
1313  .out_cables = 0x0003,
1314  .in_cables = 0x0003
1315  }
1316  }
1317 },
1318 {
1319  /* has ID 0x0081 when not in "Advanced Driver" mode */
1320  USB_DEVICE(0x0582, 0x0080),
1321  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1322  .vendor_name = "Roland",
1323  .product_name = "G-70",
1324  .ifnum = 0,
1325  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1326  .data = & (const struct snd_usb_midi_endpoint_info) {
1327  .out_cables = 0x0001,
1328  .in_cables = 0x0001
1329  }
1330  }
1331 },
1332  /* TODO: add Roland V-SYNTH XT support */
1333  /* TODO: add BOSS GT-PRO support */
1334 {
1335  /* has ID 0x008c when not in "Advanced Driver" mode */
1336  USB_DEVICE(0x0582, 0x008b),
1337  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1338  .vendor_name = "EDIROL",
1339  .product_name = "PC-50",
1340  .ifnum = 0,
1341  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1342  .data = & (const struct snd_usb_midi_endpoint_info) {
1343  .out_cables = 0x0001,
1344  .in_cables = 0x0001
1345  }
1346  }
1347 },
1348  /* TODO: add Edirol PC-80 support */
1349 {
1350  USB_DEVICE(0x0582, 0x0096),
1351  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1352  .vendor_name = "EDIROL",
1353  .product_name = "UA-1EX",
1354  .ifnum = QUIRK_ANY_INTERFACE,
1355  .type = QUIRK_COMPOSITE,
1356  .data = (const struct snd_usb_audio_quirk[]) {
1357  {
1358  .ifnum = 0,
1359  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1360  },
1361  {
1362  .ifnum = 1,
1363  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1364  },
1365  {
1366  .ifnum = -1
1367  }
1368  }
1369  }
1370 },
1371 {
1372  USB_DEVICE(0x0582, 0x009a),
1373  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1374  .vendor_name = "EDIROL",
1375  .product_name = "UM-3EX",
1376  .ifnum = 0,
1377  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1378  .data = & (const struct snd_usb_midi_endpoint_info) {
1379  .out_cables = 0x000f,
1380  .in_cables = 0x000f
1381  }
1382  }
1383 },
1384 {
1385  /*
1386  * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1387  * is standard compliant, but has only 16-bit PCM and no MIDI.
1388  */
1389  USB_DEVICE(0x0582, 0x00a3),
1390  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1391  .vendor_name = "EDIROL",
1392  .product_name = "UA-4FX",
1393  .ifnum = QUIRK_ANY_INTERFACE,
1394  .type = QUIRK_COMPOSITE,
1395  .data = (const struct snd_usb_audio_quirk[]) {
1396  {
1397  .ifnum = 0,
1398  .type = QUIRK_AUDIO_EDIROL_UAXX
1399  },
1400  {
1401  .ifnum = 1,
1402  .type = QUIRK_AUDIO_EDIROL_UAXX
1403  },
1404  {
1405  .ifnum = 2,
1406  .type = QUIRK_AUDIO_EDIROL_UAXX
1407  },
1408  {
1409  .ifnum = -1
1410  }
1411  }
1412  }
1413 },
1414  /* TODO: add Edirol MD-P1 support */
1415 {
1416  USB_DEVICE(0x582, 0x00a6),
1417  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1418  .vendor_name = "Roland",
1419  .product_name = "Juno-G",
1420  .ifnum = 0,
1421  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1422  .data = & (const struct snd_usb_midi_endpoint_info) {
1423  .out_cables = 0x0001,
1424  .in_cables = 0x0001
1425  }
1426  }
1427 },
1428 {
1429  /* Roland SH-201 */
1430  USB_DEVICE(0x0582, 0x00ad),
1431  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1432  .vendor_name = "Roland",
1433  .product_name = "SH-201",
1434  .ifnum = QUIRK_ANY_INTERFACE,
1435  .type = QUIRK_COMPOSITE,
1436  .data = (const struct snd_usb_audio_quirk[]) {
1437  {
1438  .ifnum = 0,
1439  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1440  },
1441  {
1442  .ifnum = 1,
1443  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1444  },
1445  {
1446  .ifnum = 2,
1447  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1448  .data = & (const struct snd_usb_midi_endpoint_info) {
1449  .out_cables = 0x0001,
1450  .in_cables = 0x0001
1451  }
1452  },
1453  {
1454  .ifnum = -1
1455  }
1456  }
1457  }
1458 },
1459 {
1460  /* Roland SonicCell */
1461  USB_DEVICE(0x0582, 0x00c2),
1462  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1463  .vendor_name = "Roland",
1464  .product_name = "SonicCell",
1465  .ifnum = QUIRK_ANY_INTERFACE,
1466  .type = QUIRK_COMPOSITE,
1467  .data = (const struct snd_usb_audio_quirk[]) {
1468  {
1469  .ifnum = 0,
1470  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1471  },
1472  {
1473  .ifnum = 1,
1474  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1475  },
1476  {
1477  .ifnum = 2,
1478  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1479  .data = & (const struct snd_usb_midi_endpoint_info) {
1480  .out_cables = 0x0001,
1481  .in_cables = 0x0001
1482  }
1483  },
1484  {
1485  .ifnum = -1
1486  }
1487  }
1488  }
1489 },
1490 {
1491  /* Edirol M-16DX */
1492  /* FIXME: This quirk gives a good-working capture stream but the
1493  * playback seems problematic because of lacking of sync
1494  * with capture stream. It needs to sync with the capture
1495  * clock. As now, you'll get frequent sound distortions
1496  * via the playback.
1497  */
1498  USB_DEVICE(0x0582, 0x00c4),
1499  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1500  .ifnum = QUIRK_ANY_INTERFACE,
1501  .type = QUIRK_COMPOSITE,
1502  .data = (const struct snd_usb_audio_quirk[]) {
1503  {
1504  .ifnum = 0,
1505  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1506  },
1507  {
1508  .ifnum = 1,
1509  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1510  },
1511  {
1512  .ifnum = 2,
1513  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1514  .data = & (const struct snd_usb_midi_endpoint_info) {
1515  .out_cables = 0x0001,
1516  .in_cables = 0x0001
1517  }
1518  },
1519  {
1520  .ifnum = -1
1521  }
1522  }
1523  }
1524 },
1525 {
1526  /* BOSS GT-10 */
1527  USB_DEVICE(0x0582, 0x00da),
1528  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1529  .ifnum = QUIRK_ANY_INTERFACE,
1530  .type = QUIRK_COMPOSITE,
1531  .data = (const struct snd_usb_audio_quirk[]) {
1532  {
1533  .ifnum = 0,
1534  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1535  },
1536  {
1537  .ifnum = 1,
1538  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1539  },
1540  {
1541  .ifnum = 2,
1542  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1543  .data = & (const struct snd_usb_midi_endpoint_info) {
1544  .out_cables = 0x0001,
1545  .in_cables = 0x0001
1546  }
1547  },
1548  {
1549  .ifnum = -1
1550  }
1551  }
1552  }
1553 },
1554 {
1555  /* Advanced modes of the Edirol UA-25EX.
1556  * For the standard mode, UA-25EX has ID 0582:00e7, which
1557  * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1558  */
1559  USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1560  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1561  .vendor_name = "EDIROL",
1562  .product_name = "UA-25EX",
1563  .ifnum = QUIRK_ANY_INTERFACE,
1564  .type = QUIRK_COMPOSITE,
1565  .data = (const struct snd_usb_audio_quirk[]) {
1566  {
1567  .ifnum = 0,
1568  .type = QUIRK_AUDIO_EDIROL_UAXX
1569  },
1570  {
1571  .ifnum = 1,
1572  .type = QUIRK_AUDIO_EDIROL_UAXX
1573  },
1574  {
1575  .ifnum = 2,
1576  .type = QUIRK_AUDIO_EDIROL_UAXX
1577  },
1578  {
1579  .ifnum = -1
1580  }
1581  }
1582  }
1583 },
1584 {
1585  /* has ID 0x00ea when not in Advanced Driver mode */
1586  USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9),
1587  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1588  /* .vendor_name = "Roland", */
1589  /* .product_name = "UA-1G", */
1590  .ifnum = QUIRK_ANY_INTERFACE,
1591  .type = QUIRK_COMPOSITE,
1592  .data = (const struct snd_usb_audio_quirk[]) {
1593  {
1594  .ifnum = 0,
1595  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1596  },
1597  {
1598  .ifnum = 1,
1599  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1600  },
1601  {
1602  .ifnum = -1
1603  }
1604  }
1605  }
1606 },
1607 {
1608  USB_DEVICE_VENDOR_SPEC(0x0582, 0x0104),
1609  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1610  /* .vendor_name = "Roland", */
1611  /* .product_name = "UM-1G", */
1612  .ifnum = 0,
1613  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1614  .data = & (const struct snd_usb_midi_endpoint_info) {
1615  .out_cables = 0x0001,
1616  .in_cables = 0x0001
1617  }
1618  }
1619 },
1620 {
1621  /* Edirol UM-3G */
1622  USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1623  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1624  .ifnum = 0,
1625  .type = QUIRK_MIDI_STANDARD_INTERFACE
1626  }
1627 },
1628 {
1629  /* Boss JS-8 Jam Station */
1630  USB_DEVICE(0x0582, 0x0109),
1631  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1632  /* .vendor_name = "BOSS", */
1633  /* .product_name = "JS-8", */
1634  .ifnum = QUIRK_ANY_INTERFACE,
1635  .type = QUIRK_COMPOSITE,
1636  .data = (const struct snd_usb_audio_quirk[]) {
1637  {
1638  .ifnum = 0,
1639  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1640  },
1641  {
1642  .ifnum = 1,
1643  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1644  },
1645  {
1646  .ifnum = 2,
1647  .type = QUIRK_MIDI_STANDARD_INTERFACE
1648  },
1649  {
1650  .ifnum = -1
1651  }
1652  }
1653  }
1654 },
1655 {
1656  /* has ID 0x0110 when not in Advanced Driver mode */
1657  USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f),
1658  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1659  /* .vendor_name = "Roland", */
1660  /* .product_name = "A-PRO", */
1661  .ifnum = 1,
1662  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1663  .data = & (const struct snd_usb_midi_endpoint_info) {
1664  .out_cables = 0x0003,
1665  .in_cables = 0x0007
1666  }
1667  }
1668 },
1669 {
1670  /* Roland GAIA SH-01 */
1671  USB_DEVICE(0x0582, 0x0111),
1672  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1673  .vendor_name = "Roland",
1674  .product_name = "GAIA",
1675  .ifnum = QUIRK_ANY_INTERFACE,
1676  .type = QUIRK_COMPOSITE,
1677  .data = (const struct snd_usb_audio_quirk[]) {
1678  {
1679  .ifnum = 0,
1680  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1681  },
1682  {
1683  .ifnum = 1,
1684  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1685  },
1686  {
1687  .ifnum = 2,
1688  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1689  .data = &(const struct snd_usb_midi_endpoint_info) {
1690  .out_cables = 0x0003,
1691  .in_cables = 0x0003
1692  }
1693  },
1694  {
1695  .ifnum = -1
1696  }
1697  }
1698  }
1699 },
1700 {
1701  USB_DEVICE(0x0582, 0x0113),
1702  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1703  /* .vendor_name = "BOSS", */
1704  /* .product_name = "ME-25", */
1705  .ifnum = QUIRK_ANY_INTERFACE,
1706  .type = QUIRK_COMPOSITE,
1707  .data = (const struct snd_usb_audio_quirk[]) {
1708  {
1709  .ifnum = 0,
1710  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1711  },
1712  {
1713  .ifnum = 1,
1714  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1715  },
1716  {
1717  .ifnum = 2,
1718  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1719  .data = & (const struct snd_usb_midi_endpoint_info) {
1720  .out_cables = 0x0001,
1721  .in_cables = 0x0001
1722  }
1723  },
1724  {
1725  .ifnum = -1
1726  }
1727  }
1728  }
1729 },
1730 {
1731  USB_DEVICE(0x0582, 0x0127),
1732  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1733  /* .vendor_name = "Roland", */
1734  /* .product_name = "GR-55", */
1735  .ifnum = QUIRK_ANY_INTERFACE,
1736  .type = QUIRK_COMPOSITE,
1737  .data = (const struct snd_usb_audio_quirk[]) {
1738  {
1739  .ifnum = 0,
1740  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1741  },
1742  {
1743  .ifnum = 1,
1744  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1745  },
1746  {
1747  .ifnum = 2,
1748  .type = QUIRK_MIDI_STANDARD_INTERFACE
1749  },
1750  {
1751  .ifnum = -1
1752  }
1753  }
1754  }
1755 },
1756 {
1757  /* Added support for Roland UM-ONE which differs from UM-1 */
1758  USB_DEVICE(0x0582, 0x012a),
1759  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1760  /* .vendor_name = "ROLAND", */
1761  /* .product_name = "UM-ONE", */
1762  .ifnum = 0,
1763  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1764  .data = & (const struct snd_usb_midi_endpoint_info) {
1765  .out_cables = 0x0001,
1766  .in_cables = 0x0003
1767  }
1768  }
1769 },
1770 {
1771  USB_DEVICE(0x0582, 0x011e),
1772  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1773  /* .vendor_name = "BOSS", */
1774  /* .product_name = "BR-800", */
1775  .ifnum = QUIRK_ANY_INTERFACE,
1776  .type = QUIRK_COMPOSITE,
1777  .data = (const struct snd_usb_audio_quirk[]) {
1778  {
1779  .ifnum = 0,
1780  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1781  },
1782  {
1783  .ifnum = 1,
1784  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1785  },
1786  {
1787  .ifnum = 2,
1788  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1789  .data = & (const struct snd_usb_midi_endpoint_info) {
1790  .out_cables = 0x0001,
1791  .in_cables = 0x0001
1792  }
1793  },
1794  {
1795  .ifnum = -1
1796  }
1797  }
1798  }
1799 },
1800 {
1801  USB_DEVICE(0x0582, 0x0130),
1802  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1803  /* .vendor_name = "BOSS", */
1804  /* .product_name = "MICRO BR-80", */
1805  .ifnum = QUIRK_ANY_INTERFACE,
1806  .type = QUIRK_COMPOSITE,
1807  .data = (const struct snd_usb_audio_quirk[]) {
1808  {
1809  .ifnum = 0,
1810  .type = QUIRK_IGNORE_INTERFACE
1811  },
1812  {
1813  .ifnum = 1,
1814  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1815  },
1816  {
1817  .ifnum = 2,
1818  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1819  },
1820  {
1821  .ifnum = 3,
1822  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1823  .data = & (const struct snd_usb_midi_endpoint_info) {
1824  .out_cables = 0x0001,
1825  .in_cables = 0x0001
1826  }
1827  },
1828  {
1829  .ifnum = -1
1830  }
1831  }
1832  }
1833 },
1834 {
1835  USB_DEVICE(0x0582, 0x014d),
1836  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1837  /* .vendor_name = "BOSS", */
1838  /* .product_name = "GT-100", */
1839  .ifnum = QUIRK_ANY_INTERFACE,
1840  .type = QUIRK_COMPOSITE,
1841  .data = (const struct snd_usb_audio_quirk[]) {
1842  {
1843  .ifnum = 1,
1844  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1845  },
1846  {
1847  .ifnum = 2,
1848  .type = QUIRK_AUDIO_STANDARD_INTERFACE
1849  },
1850  {
1851  .ifnum = 3,
1852  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1853  .data = & (const struct snd_usb_midi_endpoint_info) {
1854  .out_cables = 0x0001,
1855  .in_cables = 0x0001
1856  }
1857  },
1858  {
1859  .ifnum = -1
1860  }
1861  }
1862  }
1863 },
1864 
1865 /* Guillemot devices */
1866 {
1867  /*
1868  * This is for the "Windows Edition" where the external MIDI ports are
1869  * the only MIDI ports; the control data is reported through HID
1870  * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard
1871  * compliant USB MIDI ports for external MIDI and controls.
1872  */
1873  USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1874  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1875  .vendor_name = "Hercules",
1876  .product_name = "DJ Console (WE)",
1877  .ifnum = 4,
1878  .type = QUIRK_MIDI_FIXED_ENDPOINT,
1879  .data = & (const struct snd_usb_midi_endpoint_info) {
1880  .out_cables = 0x0001,
1881  .in_cables = 0x0001
1882  }
1883  }
1884 },
1885 
1886 /* Midiman/M-Audio devices */
1887 {
1888  USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1889  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1890  .vendor_name = "M-Audio",
1891  .product_name = "MidiSport 2x2",
1892  .ifnum = QUIRK_ANY_INTERFACE,
1893  .type = QUIRK_MIDI_MIDIMAN,
1894  .data = & (const struct snd_usb_midi_endpoint_info) {
1895  .out_cables = 0x0003,
1896  .in_cables = 0x0003
1897  }
1898  }
1899 },
1900 {
1901  USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1902  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1903  .vendor_name = "M-Audio",
1904  .product_name = "MidiSport 1x1",
1905  .ifnum = QUIRK_ANY_INTERFACE,
1906  .type = QUIRK_MIDI_MIDIMAN,
1907  .data = & (const struct snd_usb_midi_endpoint_info) {
1908  .out_cables = 0x0001,
1909  .in_cables = 0x0001
1910  }
1911  }
1912 },
1913 {
1914  USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1915  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1916  .vendor_name = "M-Audio",
1917  .product_name = "Keystation",
1918  .ifnum = QUIRK_ANY_INTERFACE,
1919  .type = QUIRK_MIDI_MIDIMAN,
1920  .data = & (const struct snd_usb_midi_endpoint_info) {
1921  .out_cables = 0x0001,
1922  .in_cables = 0x0001
1923  }
1924  }
1925 },
1926 {
1927  USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1928  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1929  .vendor_name = "M-Audio",
1930  .product_name = "MidiSport 4x4",
1931  .ifnum = QUIRK_ANY_INTERFACE,
1932  .type = QUIRK_MIDI_MIDIMAN,
1933  .data = & (const struct snd_usb_midi_endpoint_info) {
1934  .out_cables = 0x000f,
1935  .in_cables = 0x000f
1936  }
1937  }
1938 },
1939 {
1940  /*
1941  * For hardware revision 1.05; in the later revisions (1.10 and
1942  * 1.21), 0x1031 is the ID for the device without firmware.
1943  * Thanks to Olaf Giesbrecht <[email protected]>
1944  */
1945  USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1946  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1947  .vendor_name = "M-Audio",
1948  .product_name = "MidiSport 8x8",
1949  .ifnum = QUIRK_ANY_INTERFACE,
1950  .type = QUIRK_MIDI_MIDIMAN,
1951  .data = & (const struct snd_usb_midi_endpoint_info) {
1952  .out_cables = 0x01ff,
1953  .in_cables = 0x01ff
1954  }
1955  }
1956 },
1957 {
1958  USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1959  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1960  .vendor_name = "M-Audio",
1961  .product_name = "MidiSport 8x8",
1962  .ifnum = QUIRK_ANY_INTERFACE,
1963  .type = QUIRK_MIDI_MIDIMAN,
1964  .data = & (const struct snd_usb_midi_endpoint_info) {
1965  .out_cables = 0x01ff,
1966  .in_cables = 0x01ff
1967  }
1968  }
1969 },
1970 {
1971  USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1972  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1973  .vendor_name = "M-Audio",
1974  .product_name = "MidiSport 2x4",
1975  .ifnum = QUIRK_ANY_INTERFACE,
1976  .type = QUIRK_MIDI_MIDIMAN,
1977  .data = & (const struct snd_usb_midi_endpoint_info) {
1978  .out_cables = 0x000f,
1979  .in_cables = 0x0003
1980  }
1981  }
1982 },
1983 {
1984  USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1985  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1986  .vendor_name = "M-Audio",
1987  .product_name = "Quattro",
1988  .ifnum = QUIRK_ANY_INTERFACE,
1989  .type = QUIRK_COMPOSITE,
1990  .data = & (const struct snd_usb_audio_quirk[]) {
1991  /*
1992  * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1993  * and share endpoints with the other interfaces.
1994  * Ignore them. The other interfaces can do 24 bits,
1995  * but captured samples are big-endian (see usbaudio.c).
1996  */
1997  {
1998  .ifnum = 0,
1999  .type = QUIRK_IGNORE_INTERFACE
2000  },
2001  {
2002  .ifnum = 1,
2003  .type = QUIRK_IGNORE_INTERFACE
2004  },
2005  {
2006  .ifnum = 2,
2007  .type = QUIRK_IGNORE_INTERFACE
2008  },
2009  {
2010  .ifnum = 3,
2011  .type = QUIRK_IGNORE_INTERFACE
2012  },
2013  {
2014  .ifnum = 4,
2015  .type = QUIRK_AUDIO_STANDARD_INTERFACE
2016  },
2017  {
2018  .ifnum = 5,
2019  .type = QUIRK_AUDIO_STANDARD_INTERFACE
2020  },
2021  {
2022  .ifnum = 6,
2023  .type = QUIRK_IGNORE_INTERFACE
2024  },
2025  {
2026  .ifnum = 7,
2027  .type = QUIRK_AUDIO_STANDARD_INTERFACE
2028  },
2029  {
2030  .ifnum = 8,
2031  .type = QUIRK_AUDIO_STANDARD_INTERFACE
2032  },
2033  {
2034  .ifnum = 9,
2035  .type = QUIRK_MIDI_MIDIMAN,
2036  .data = & (const struct snd_usb_midi_endpoint_info) {
2037  .out_cables = 0x0001,
2038  .in_cables = 0x0001
2039  }
2040  },
2041  {
2042  .ifnum = -1
2043  }
2044  }
2045  }
2046 },
2047 {
2048  USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
2049  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2050  .vendor_name = "M-Audio",
2051  .product_name = "AudioPhile",
2052  .ifnum = 6,
2053  .type = QUIRK_MIDI_MIDIMAN,
2054  .data = & (const struct snd_usb_midi_endpoint_info) {
2055  .out_cables = 0x0001,
2056  .in_cables = 0x0001
2057  }
2058  }
2059 },
2060 {
2061  USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
2062  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2063  .vendor_name = "M-Audio",
2064  .product_name = "Ozone",
2065  .ifnum = 3,
2066  .type = QUIRK_MIDI_MIDIMAN,
2067  .data = & (const struct snd_usb_midi_endpoint_info) {
2068  .out_cables = 0x0001,
2069  .in_cables = 0x0001
2070  }
2071  }
2072 },
2073 {
2074  USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
2075  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2076  .vendor_name = "M-Audio",
2077  .product_name = "OmniStudio",
2078  .ifnum = QUIRK_ANY_INTERFACE,
2079  .type = QUIRK_COMPOSITE,
2080  .data = & (const struct snd_usb_audio_quirk[]) {
2081  {
2082  .ifnum = 0,
2083  .type = QUIRK_IGNORE_INTERFACE
2084  },
2085  {
2086  .ifnum = 1,
2087  .type = QUIRK_IGNORE_INTERFACE
2088  },
2089  {
2090  .ifnum = 2,
2091  .type = QUIRK_IGNORE_INTERFACE
2092  },
2093  {
2094  .ifnum = 3,
2095  .type = QUIRK_IGNORE_INTERFACE
2096  },
2097  {
2098  .ifnum = 4,
2099  .type = QUIRK_AUDIO_STANDARD_INTERFACE
2100  },
2101  {
2102  .ifnum = 5,
2103  .type = QUIRK_AUDIO_STANDARD_INTERFACE
2104  },
2105  {
2106  .ifnum = 6,
2107  .type = QUIRK_IGNORE_INTERFACE
2108  },
2109  {
2110  .ifnum = 7,
2111  .type = QUIRK_AUDIO_STANDARD_INTERFACE
2112  },
2113  {
2114  .ifnum = 8,
2115  .type = QUIRK_AUDIO_STANDARD_INTERFACE
2116  },
2117  {
2118  .ifnum = 9,
2119  .type = QUIRK_MIDI_MIDIMAN,
2120  .data = & (const struct snd_usb_midi_endpoint_info) {
2121  .out_cables = 0x0001,
2122  .in_cables = 0x0001
2123  }
2124  },
2125  {
2126  .ifnum = -1
2127  }
2128  }
2129  }
2130 },
2131 {
2132  USB_DEVICE(0x0763, 0x2019),
2133  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2134  /* .vendor_name = "M-Audio", */
2135  /* .product_name = "Ozone Academic", */
2136  .ifnum = QUIRK_ANY_INTERFACE,
2137  .type = QUIRK_COMPOSITE,
2138  .data = & (const struct snd_usb_audio_quirk[]) {
2139  {
2140  .ifnum = 0,
2141  .type = QUIRK_AUDIO_STANDARD_INTERFACE
2142  },
2143  {
2144  .ifnum = 1,
2145  .type = QUIRK_AUDIO_STANDARD_INTERFACE
2146  },
2147  {
2148  .ifnum = 2,
2149  .type = QUIRK_AUDIO_STANDARD_INTERFACE
2150  },
2151  {
2152  .ifnum = 3,
2153  .type = QUIRK_MIDI_MIDIMAN,
2154  .data = & (const struct snd_usb_midi_endpoint_info) {
2155  .out_cables = 0x0001,
2156  .in_cables = 0x0001
2157  }
2158  },
2159  {
2160  .ifnum = -1
2161  }
2162  }
2163  }
2164 },
2165 {
2166  USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2167  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2168  /* .vendor_name = "M-Audio", */
2169  /* .product_name = "Fast Track Ultra", */
2170  .ifnum = QUIRK_ANY_INTERFACE,
2171  .type = QUIRK_COMPOSITE,
2172  .data = & (const struct snd_usb_audio_quirk[]) {
2173  {
2174  .ifnum = 0,
2175  .type = QUIRK_AUDIO_STANDARD_MIXER,
2176  },
2177  {
2178  .ifnum = 1,
2179  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2180  .data = & (const struct audioformat) {
2181  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2182  .channels = 8,
2183  .iface = 1,
2184  .altsetting = 1,
2185  .altset_idx = 1,
2186  .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2187  .endpoint = 0x01,
2188  .ep_attr = 0x09,
2189  .rates = SNDRV_PCM_RATE_44100 |
2190  SNDRV_PCM_RATE_48000 |
2191  SNDRV_PCM_RATE_88200 |
2192  SNDRV_PCM_RATE_96000,
2193  .rate_min = 44100,
2194  .rate_max = 96000,
2195  .nr_rates = 4,
2196  .rate_table = (unsigned int[]) {
2197  44100, 48000, 88200, 96000
2198  }
2199  }
2200  },
2201  {
2202  .ifnum = 2,
2203  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2204  .data = & (const struct audioformat) {
2205  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2206  .channels = 8,
2207  .iface = 2,
2208  .altsetting = 1,
2209  .altset_idx = 1,
2210  .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2211  .endpoint = 0x81,
2212  .ep_attr = 0x05,
2213  .rates = SNDRV_PCM_RATE_44100 |
2214  SNDRV_PCM_RATE_48000 |
2215  SNDRV_PCM_RATE_88200 |
2216  SNDRV_PCM_RATE_96000,
2217  .rate_min = 44100,
2218  .rate_max = 96000,
2219  .nr_rates = 4,
2220  .rate_table = (unsigned int[]) {
2221  44100, 48000, 88200, 96000
2222  }
2223  }
2224  },
2225  /* interface 3 (MIDI) is standard compliant */
2226  {
2227  .ifnum = -1
2228  }
2229  }
2230  }
2231 },
2232 {
2233  USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2234  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2235  /* .vendor_name = "M-Audio", */
2236  /* .product_name = "Fast Track Ultra 8R", */
2237  .ifnum = QUIRK_ANY_INTERFACE,
2238  .type = QUIRK_COMPOSITE,
2239  .data = & (const struct snd_usb_audio_quirk[]) {
2240  {
2241  .ifnum = 0,
2242  .type = QUIRK_AUDIO_STANDARD_MIXER,
2243  },
2244  {
2245  .ifnum = 1,
2246  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2247  .data = & (const struct audioformat) {
2248  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2249  .channels = 8,
2250  .iface = 1,
2251  .altsetting = 1,
2252  .altset_idx = 1,
2253  .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2254  .endpoint = 0x01,
2255  .ep_attr = 0x09,
2256  .rates = SNDRV_PCM_RATE_44100 |
2257  SNDRV_PCM_RATE_48000 |
2258  SNDRV_PCM_RATE_88200 |
2259  SNDRV_PCM_RATE_96000,
2260  .rate_min = 44100,
2261  .rate_max = 96000,
2262  .nr_rates = 4,
2263  .rate_table = (unsigned int[]) {
2264  44100, 48000, 88200, 96000
2265  }
2266  }
2267  },
2268  {
2269  .ifnum = 2,
2270  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2271  .data = & (const struct audioformat) {
2272  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2273  .channels = 8,
2274  .iface = 2,
2275  .altsetting = 1,
2276  .altset_idx = 1,
2277  .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2278  .endpoint = 0x81,
2279  .ep_attr = 0x05,
2280  .rates = SNDRV_PCM_RATE_44100 |
2281  SNDRV_PCM_RATE_48000 |
2282  SNDRV_PCM_RATE_88200 |
2283  SNDRV_PCM_RATE_96000,
2284  .rate_min = 44100,
2285  .rate_max = 96000,
2286  .nr_rates = 4,
2287  .rate_table = (unsigned int[]) {
2288  44100, 48000, 88200, 96000
2289  }
2290  }
2291  },
2292  /* interface 3 (MIDI) is standard compliant */
2293  {
2294  .ifnum = -1
2295  }
2296  }
2297  }
2298 },
2299 
2300 /* Casio devices */
2301 {
2302  USB_DEVICE(0x07cf, 0x6801),
2303  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2304  .vendor_name = "Casio",
2305  .product_name = "PL-40R",
2306  .ifnum = 0,
2307  .type = QUIRK_MIDI_YAMAHA
2308  }
2309 },
2310 {
2311  /* this ID is used by several devices without a product ID */
2312  USB_DEVICE(0x07cf, 0x6802),
2313  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2314  .vendor_name = "Casio",
2315  .product_name = "Keyboard",
2316  .ifnum = 0,
2317  .type = QUIRK_MIDI_YAMAHA
2318  }
2319 },
2320 
2321 /* Mark of the Unicorn devices */
2322 {
2323  /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2324  .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2325  USB_DEVICE_ID_MATCH_PRODUCT |
2326  USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2327  .idVendor = 0x07fd,
2328  .idProduct = 0x0001,
2329  .bDeviceSubClass = 2,
2330  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2331  .vendor_name = "MOTU",
2332  .product_name = "Fastlane",
2333  .ifnum = QUIRK_ANY_INTERFACE,
2334  .type = QUIRK_COMPOSITE,
2335  .data = & (const struct snd_usb_audio_quirk[]) {
2336  {
2337  .ifnum = 0,
2338  .type = QUIRK_MIDI_RAW_BYTES
2339  },
2340  {
2341  .ifnum = 1,
2342  .type = QUIRK_IGNORE_INTERFACE
2343  },
2344  {
2345  .ifnum = -1
2346  }
2347  }
2348  }
2349 },
2350 
2351 /* Emagic devices */
2352 {
2353  USB_DEVICE(0x086a, 0x0001),
2354  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2355  .vendor_name = "Emagic",
2356  /* .product_name = "Unitor8", */
2357  .ifnum = 2,
2358  .type = QUIRK_MIDI_EMAGIC,
2359  .data = & (const struct snd_usb_midi_endpoint_info) {
2360  .out_cables = 0x80ff,
2361  .in_cables = 0x80ff
2362  }
2363  }
2364 },
2365 {
2366  USB_DEVICE(0x086a, 0x0002),
2367  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2368  .vendor_name = "Emagic",
2369  /* .product_name = "AMT8", */
2370  .ifnum = 2,
2371  .type = QUIRK_MIDI_EMAGIC,
2372  .data = & (const struct snd_usb_midi_endpoint_info) {
2373  .out_cables = 0x80ff,
2374  .in_cables = 0x80ff
2375  }
2376  }
2377 },
2378 {
2379  USB_DEVICE(0x086a, 0x0003),
2380  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2381  .vendor_name = "Emagic",
2382  /* .product_name = "MT4", */
2383  .ifnum = 2,
2384  .type = QUIRK_MIDI_EMAGIC,
2385  .data = & (const struct snd_usb_midi_endpoint_info) {
2386  .out_cables = 0x800f,
2387  .in_cables = 0x8003
2388  }
2389  }
2390 },
2391 
2392 /* KORG devices */
2393 {
2394  USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2395  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2396  .vendor_name = "KORG, Inc.",
2397  /* .product_name = "PANDORA PX5D", */
2398  .ifnum = 3,
2399  .type = QUIRK_MIDI_STANDARD_INTERFACE,
2400  }
2401 },
2402 
2403 {
2404  USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2405  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2406  .vendor_name = "KORG, Inc.",
2407  /* .product_name = "ToneLab ST", */
2408  .ifnum = 3,
2409  .type = QUIRK_MIDI_STANDARD_INTERFACE,
2410  }
2411 },
2412 
2413 /* AKAI devices */
2414 {
2415  USB_DEVICE(0x09e8, 0x0062),
2416  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2417  .vendor_name = "AKAI",
2418  .product_name = "MPD16",
2419  .ifnum = 0,
2420  .type = QUIRK_MIDI_AKAI,
2421  }
2422 },
2423 
2424 /* TerraTec devices */
2425 {
2426  USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2427  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2428  .vendor_name = "TerraTec",
2429  .product_name = "PHASE 26",
2430  .ifnum = 3,
2431  .type = QUIRK_MIDI_STANDARD_INTERFACE
2432  }
2433 },
2434 {
2435  USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2436  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2437  .vendor_name = "TerraTec",
2438  .product_name = "PHASE 26",
2439  .ifnum = 3,
2440  .type = QUIRK_MIDI_STANDARD_INTERFACE
2441  }
2442 },
2443 {
2444  USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2445  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2446  .vendor_name = "TerraTec",
2447  .product_name = "PHASE 26",
2448  .ifnum = 3,
2449  .type = QUIRK_MIDI_STANDARD_INTERFACE
2450  }
2451 },
2452 {
2453  USB_DEVICE(0x0ccd, 0x0028),
2454  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2455  .vendor_name = "TerraTec",
2456  .product_name = "Aureon5.1MkII",
2457  .ifnum = QUIRK_NO_INTERFACE
2458  }
2459 },
2460 {
2461  USB_DEVICE(0x0ccd, 0x0035),
2462  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2463  .vendor_name = "Miditech",
2464  .product_name = "Play'n Roll",
2465  .ifnum = 0,
2466  .type = QUIRK_MIDI_CME
2467  }
2468 },
2469 
2470 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2471 {
2472  USB_DEVICE(0x103d, 0x0100),
2473  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2474  .vendor_name = "Stanton",
2475  .product_name = "ScratchAmp",
2476  .ifnum = QUIRK_NO_INTERFACE
2477  }
2478 },
2479 {
2480  USB_DEVICE(0x103d, 0x0101),
2481  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2482  .vendor_name = "Stanton",
2483  .product_name = "ScratchAmp",
2484  .ifnum = QUIRK_NO_INTERFACE
2485  }
2486 },
2487 
2488 /* Novation EMS devices */
2489 {
2490  USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2491  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2492  .vendor_name = "Novation",
2493  .product_name = "ReMOTE Audio/XStation",
2494  .ifnum = 4,
2495  .type = QUIRK_MIDI_NOVATION
2496  }
2497 },
2498 {
2499  USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2500  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2501  .vendor_name = "Novation",
2502  .product_name = "Speedio",
2503  .ifnum = 3,
2504  .type = QUIRK_MIDI_NOVATION
2505  }
2506 },
2507 {
2508  USB_DEVICE(0x1235, 0x000e),
2509  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2510  /* .vendor_name = "Novation", */
2511  /* .product_name = "Launchpad", */
2512  .ifnum = 0,
2513  .type = QUIRK_MIDI_RAW_BYTES
2514  }
2515 },
2516 {
2517  USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2518  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2519  .vendor_name = "Novation",
2520  .product_name = "ReMOTE25",
2521  .ifnum = 0,
2522  .type = QUIRK_MIDI_NOVATION
2523  }
2524 },
2525 
2526 /* Access Music devices */
2527 {
2528  /* VirusTI Desktop */
2529  USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2530  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2531  .ifnum = QUIRK_ANY_INTERFACE,
2532  .type = QUIRK_COMPOSITE,
2533  .data = &(const struct snd_usb_audio_quirk[]) {
2534  {
2535  .ifnum = 3,
2536  .type = QUIRK_MIDI_FIXED_ENDPOINT,
2537  .data = &(const struct snd_usb_midi_endpoint_info) {
2538  .out_cables = 0x0003,
2539  .in_cables = 0x0003
2540  }
2541  },
2542  {
2543  .ifnum = 4,
2544  .type = QUIRK_IGNORE_INTERFACE
2545  },
2546  {
2547  .ifnum = -1
2548  }
2549  }
2550  }
2551 },
2552 
2553 /* */
2554 {
2555  /* aka. Serato Scratch Live DJ Box */
2556  USB_DEVICE(0x13e5, 0x0001),
2557  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2558  .vendor_name = "Rane",
2559  .product_name = "SL-1",
2560  .ifnum = QUIRK_NO_INTERFACE
2561  }
2562 },
2563 
2564 /* Native Instruments MK2 series */
2565 {
2566  /* Komplete Audio 6 */
2567  .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2568  .idVendor = 0x17cc,
2569  .idProduct = 0x1000,
2570 },
2571 {
2572  /* Traktor Audio 6 */
2573  .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2574  .idVendor = 0x17cc,
2575  .idProduct = 0x1010,
2576 },
2577 {
2578  /* Traktor Audio 10 */
2579  .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2580  .idVendor = 0x17cc,
2581  .idProduct = 0x1020,
2582 },
2583 
2584 /* KeithMcMillen Stringport */
2585 {
2586  USB_DEVICE(0x1f38, 0x0001),
2587  .bInterfaceClass = USB_CLASS_AUDIO,
2588 },
2589 
2590 /* Miditech devices */
2591 {
2592  USB_DEVICE(0x4752, 0x0011),
2593  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2594  .vendor_name = "Miditech",
2595  .product_name = "Midistart-2",
2596  .ifnum = 0,
2597  .type = QUIRK_MIDI_CME
2598  }
2599 },
2600 
2601 /* Central Music devices */
2602 {
2603  /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2604  USB_DEVICE(0x7104, 0x2202),
2605  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2606  .ifnum = 0,
2607  .type = QUIRK_MIDI_CME
2608  }
2609 },
2610 
2611 /* Hauppauge HVR-950Q and HVR-850 */
2612 {
2613  USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
2614  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2615  USB_DEVICE_ID_MATCH_INT_CLASS |
2616  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2617  .bInterfaceClass = USB_CLASS_AUDIO,
2618  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2619  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2620  .vendor_name = "Hauppauge",
2621  .product_name = "HVR-950Q",
2622  .ifnum = QUIRK_ANY_INTERFACE,
2623  .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2624  }
2625 },
2626 {
2627  USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240),
2628  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2629  USB_DEVICE_ID_MATCH_INT_CLASS |
2630  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2631  .bInterfaceClass = USB_CLASS_AUDIO,
2632  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2633  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2634  .vendor_name = "Hauppauge",
2635  .product_name = "HVR-850",
2636  .ifnum = QUIRK_ANY_INTERFACE,
2637  .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2638  }
2639 },
2640 {
2641  USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210),
2642  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2643  USB_DEVICE_ID_MATCH_INT_CLASS |
2644  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2645  .bInterfaceClass = USB_CLASS_AUDIO,
2646  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2647  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2648  .vendor_name = "Hauppauge",
2649  .product_name = "HVR-950Q",
2650  .ifnum = QUIRK_ANY_INTERFACE,
2651  .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2652  }
2653 },
2654 {
2655  USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217),
2656  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2657  USB_DEVICE_ID_MATCH_INT_CLASS |
2658  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2659  .bInterfaceClass = USB_CLASS_AUDIO,
2660  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2661  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2662  .vendor_name = "Hauppauge",
2663  .product_name = "HVR-950Q",
2664  .ifnum = QUIRK_ANY_INTERFACE,
2665  .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2666  }
2667 },
2668 {
2669  USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b),
2670  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2671  USB_DEVICE_ID_MATCH_INT_CLASS |
2672  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2673  .bInterfaceClass = USB_CLASS_AUDIO,
2674  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2675  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2676  .vendor_name = "Hauppauge",
2677  .product_name = "HVR-950Q",
2678  .ifnum = QUIRK_ANY_INTERFACE,
2679  .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2680  }
2681 },
2682 {
2683  USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e),
2684  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2685  USB_DEVICE_ID_MATCH_INT_CLASS |
2686  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2687  .bInterfaceClass = USB_CLASS_AUDIO,
2688  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2689  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2690  .vendor_name = "Hauppauge",
2691  .product_name = "HVR-950Q",
2692  .ifnum = QUIRK_ANY_INTERFACE,
2693  .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2694  }
2695 },
2696 {
2697  USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f),
2698  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2699  USB_DEVICE_ID_MATCH_INT_CLASS |
2700  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2701  .bInterfaceClass = USB_CLASS_AUDIO,
2702  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2703  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2704  .vendor_name = "Hauppauge",
2705  .product_name = "HVR-950Q",
2706  .ifnum = QUIRK_ANY_INTERFACE,
2707  .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2708  }
2709 },
2710 {
2711  USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280),
2712  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2713  USB_DEVICE_ID_MATCH_INT_CLASS |
2714  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2715  .bInterfaceClass = USB_CLASS_AUDIO,
2716  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2717  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2718  .vendor_name = "Hauppauge",
2719  .product_name = "HVR-950Q",
2720  .ifnum = QUIRK_ANY_INTERFACE,
2721  .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2722  }
2723 },
2724 {
2725  USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008),
2726  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2727  USB_DEVICE_ID_MATCH_INT_CLASS |
2728  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2729  .bInterfaceClass = USB_CLASS_AUDIO,
2730  .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2731  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2732  .vendor_name = "Hauppauge",
2733  .product_name = "HVR-950Q",
2734  .ifnum = QUIRK_ANY_INTERFACE,
2735  .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2736  }
2737 },
2738 
2739 /* Digidesign Mbox */
2740 {
2741  /* Thanks to Clemens Ladisch <[email protected]> */
2742  USB_DEVICE(0x0dba, 0x1000),
2743  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2744  .vendor_name = "Digidesign",
2745  .product_name = "MBox",
2746  .ifnum = QUIRK_ANY_INTERFACE,
2747  .type = QUIRK_COMPOSITE,
2748  .data = (const struct snd_usb_audio_quirk[]){
2749  {
2750  .ifnum = 0,
2751  .type = QUIRK_IGNORE_INTERFACE,
2752  },
2753  {
2754  .ifnum = 1,
2755  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2756  .data = &(const struct audioformat) {
2757  .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2758  .channels = 2,
2759  .iface = 1,
2760  .altsetting = 1,
2761  .altset_idx = 1,
2762  .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2763  .endpoint = 0x02,
2764  .ep_attr = 0x01,
2765  .maxpacksize = 0x130,
2766  .rates = SNDRV_PCM_RATE_44100 |
2767  SNDRV_PCM_RATE_48000,
2768  .rate_min = 44100,
2769  .rate_max = 48000,
2770  .nr_rates = 2,
2771  .rate_table = (unsigned int[]) {
2772  44100, 48000
2773  }
2774  }
2775  },
2776  {
2777  .ifnum = -1
2778  }
2779  }
2780 
2781  }
2782 },
2783 {
2784  /* Tascam US122 MKII - playback-only support */
2785  .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2786  .idVendor = 0x0644,
2787  .idProduct = 0x8021,
2788  .bInterfaceClass = USB_CLASS_AUDIO,
2789  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2790  .vendor_name = "TASCAM",
2791  .product_name = "US122 MKII",
2792  .ifnum = QUIRK_ANY_INTERFACE,
2793  .type = QUIRK_COMPOSITE,
2794  .data = (const struct snd_usb_audio_quirk[]) {
2795  {
2796  .ifnum = 0,
2797  .type = QUIRK_IGNORE_INTERFACE
2798  },
2799  {
2800  .ifnum = 1,
2801  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2802  .data = &(const struct audioformat) {
2803  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2804  .channels = 2,
2805  .iface = 1,
2806  .altsetting = 1,
2807  .altset_idx = 1,
2808  .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2809  .endpoint = 0x02,
2810  .ep_attr = USB_ENDPOINT_XFER_ISOC,
2811  .rates = SNDRV_PCM_RATE_44100 |
2812  SNDRV_PCM_RATE_48000 |
2813  SNDRV_PCM_RATE_88200 |
2814  SNDRV_PCM_RATE_96000,
2815  .rate_min = 44100,
2816  .rate_max = 96000,
2817  .nr_rates = 4,
2818  .rate_table = (unsigned int[]) {
2819  44100, 48000, 88200, 96000
2820  }
2821  }
2822  },
2823  {
2824  .ifnum = -1
2825  }
2826  }
2827  }
2828 },
2829 
2830 /* Microsoft XboxLive Headset/Xbox Communicator */
2831 {
2832  USB_DEVICE(0x045e, 0x0283),
2833  .bInterfaceClass = USB_CLASS_PER_INTERFACE,
2834  .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2835  .vendor_name = "Microsoft",
2836  .product_name = "XboxLive Headset/Xbox Communicator",
2837  .ifnum = QUIRK_ANY_INTERFACE,
2838  .type = QUIRK_COMPOSITE,
2839  .data = &(const struct snd_usb_audio_quirk[]) {
2840  {
2841  /* playback */
2842  .ifnum = 0,
2843  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2844  .data = &(const struct audioformat) {
2845  .formats = SNDRV_PCM_FMTBIT_S16_LE,
2846  .channels = 1,
2847  .iface = 0,
2848  .altsetting = 0,
2849  .altset_idx = 0,
2850  .attributes = 0,
2851  .endpoint = 0x04,
2852  .ep_attr = 0x05,
2853  .rates = SNDRV_PCM_RATE_CONTINUOUS,
2854  .rate_min = 22050,
2855  .rate_max = 22050
2856  }
2857  },
2858  {
2859  /* capture */
2860  .ifnum = 1,
2861  .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2862  .data = &(const struct audioformat) {
2863  .formats = SNDRV_PCM_FMTBIT_S16_LE,
2864  .channels = 1,
2865  .iface = 1,
2866  .altsetting = 0,
2867  .altset_idx = 0,
2868  .attributes = 0,
2869  .endpoint = 0x85,
2870  .ep_attr = 0x05,
2871  .rates = SNDRV_PCM_RATE_CONTINUOUS,
2872  .rate_min = 16000,
2873  .rate_max = 16000
2874  }
2875  },
2876  {
2877  .ifnum = -1
2878  }
2879  }
2880  }
2881 },
2882 
2883 {
2884  /*
2885  * Some USB MIDI devices don't have an audio control interface,
2886  * so we have to grab MIDI streaming interfaces here.
2887  */
2888  .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
2889  USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2890  .bInterfaceClass = USB_CLASS_AUDIO,
2891  .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
2892  .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2893  .ifnum = QUIRK_ANY_INTERFACE,
2894  .type = QUIRK_MIDI_STANDARD_INTERFACE
2895  }
2896 },
2897 
2898 #undef USB_DEVICE_VENDOR_SPEC
Generated on Thu Jan 10 2013 15:08:57 for Linux Kernel by   doxygen 1.8.2