Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 1762a59d8e8b5e99f6f4a0f292b40f3cacb108ba

Authored by Martin Schwenke
Committed by Takashi Iwai
1 parent b7838c2b91
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

ALSA: usb-audio: Add quirk for Focusrite Scarlett 18i6 

Probing this device currently fails in snd_usb_audio_probe() because
the call to snd_usb_create_mixer() fails.  This is due to unknown or
non-standard interface descriptor subtypes in parse_audio_unit():

  usbaudio: unit 51: unexpected type 0x09
  snd-usb-audio: probe of 1-8:1.0 failed with error -5

Some people are working around this by recompiling usb-audio with the
call to snd_usb_create_mixer() commented out.  It would be nice to
avoid that.

While the best idea would be to look into the mixer creation failure,
a reasonable short-term solution is to use quirks to only probe the
trouble-free interfaces.  This allows audio and MIDI interfaces to be
used without any obvious issues.

Interface 0 is the main one to ignore.  It contains lots of
control-fu, including the unexpected interface descriptor subtypes.
Interface 5 is for firmware updates and I'm not sure how to get
support for this.  Interface 3 is some sort of control interface that
I don't understand:

    Interface Descriptor:
      bLength                 9
      bDescriptorType         4
      bInterfaceNumber        3
      bAlternateSetting       0
      bNumEndpoints           0
      bInterfaceClass         1 Audio
      bInterfaceSubClass      1 Control Device
      bInterfaceProtocol      0
      iInterface              0
      AudioControl Interface Descriptor:
        bLength                 9
        bDescriptorType        36
        bDescriptorSubtype      1 (HEADER)
        bcdADC               1.00
        wTotalLength            9
        bInCollection           1
        baInterfaceNr( 0)       1

Signed-off-by: Martin Schwenke <martin@meltin.net>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

Showing 1 changed file with 52 additions and 0 deletions Inline Diff

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