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