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