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