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