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