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