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