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