1 // SPDX-License-Identifier: GPL-2.0-or-later 1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* 2 /*
3 */ 3 */
4 4
5 #include <linux/init.h> 5 #include <linux/init.h>
6 #include <linux/slab.h> 6 #include <linux/slab.h>
7 #include <linux/usb.h> 7 #include <linux/usb.h>
8 #include <linux/usb/audio.h> 8 #include <linux/usb/audio.h>
9 #include <linux/usb/midi.h> 9 #include <linux/usb/midi.h>
10 #include <linux/bits.h> 10 #include <linux/bits.h>
11 11
12 #include <sound/control.h> 12 #include <sound/control.h>
13 #include <sound/core.h> 13 #include <sound/core.h>
14 #include <sound/info.h> 14 #include <sound/info.h>
15 #include <sound/pcm.h> 15 #include <sound/pcm.h>
16 16
17 #include "usbaudio.h" 17 #include "usbaudio.h"
18 #include "card.h" 18 #include "card.h"
19 #include "mixer.h" 19 #include "mixer.h"
20 #include "mixer_quirks.h" 20 #include "mixer_quirks.h"
21 #include "midi.h" 21 #include "midi.h"
22 #include "midi2.h" 22 #include "midi2.h"
23 #include "quirks.h" 23 #include "quirks.h"
24 #include "helper.h" 24 #include "helper.h"
25 #include "endpoint.h" 25 #include "endpoint.h"
26 #include "pcm.h" 26 #include "pcm.h"
27 #include "clock.h" 27 #include "clock.h"
28 #include "stream.h" 28 #include "stream.h"
29 29
30 /* 30 /*
31 * handle the quirks for the contained interfa 31 * handle the quirks for the contained interfaces
32 */ 32 */
33 static int create_composite_quirk(struct snd_u 33 static int create_composite_quirk(struct snd_usb_audio *chip,
34 struct usb_i 34 struct usb_interface *iface,
35 struct usb_d 35 struct usb_driver *driver,
36 const struct 36 const struct snd_usb_audio_quirk *quirk_comp)
37 { 37 {
38 int probed_ifnum = get_iface_desc(ifac 38 int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
39 const struct snd_usb_audio_quirk *quir 39 const struct snd_usb_audio_quirk *quirk;
40 int err; 40 int err;
41 41
42 for (quirk = quirk_comp->data; quirk-> 42 for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) {
43 iface = usb_ifnum_to_if(chip-> 43 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
44 if (!iface) 44 if (!iface)
45 continue; 45 continue;
46 if (quirk->ifnum != probed_ifn 46 if (quirk->ifnum != probed_ifnum &&
47 usb_interface_claimed(ifac 47 usb_interface_claimed(iface))
48 continue; 48 continue;
49 err = snd_usb_create_quirk(chi 49 err = snd_usb_create_quirk(chip, iface, driver, quirk);
50 if (err < 0) 50 if (err < 0)
51 return err; 51 return err;
52 } 52 }
53 53
54 for (quirk = quirk_comp->data; quirk-> 54 for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) {
55 iface = usb_ifnum_to_if(chip-> 55 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
56 if (!iface) 56 if (!iface)
57 continue; 57 continue;
58 if (quirk->ifnum != probed_ifn 58 if (quirk->ifnum != probed_ifnum &&
59 !usb_interface_claimed(ifa 59 !usb_interface_claimed(iface)) {
60 err = usb_driver_claim 60 err = usb_driver_claim_interface(driver, iface,
61 61 USB_AUDIO_IFACE_UNUSED);
62 if (err < 0) 62 if (err < 0)
63 return err; 63 return err;
64 } 64 }
65 } 65 }
66 66
67 return 0; 67 return 0;
68 } 68 }
69 69
70 static int ignore_interface_quirk(struct snd_u 70 static int ignore_interface_quirk(struct snd_usb_audio *chip,
71 struct usb_i 71 struct usb_interface *iface,
72 struct usb_d 72 struct usb_driver *driver,
73 const struct 73 const struct snd_usb_audio_quirk *quirk)
74 { 74 {
75 return 0; 75 return 0;
76 } 76 }
77 77
78 78
79 static int create_any_midi_quirk(struct snd_us 79 static int create_any_midi_quirk(struct snd_usb_audio *chip,
80 struct usb_in 80 struct usb_interface *intf,
81 struct usb_dr 81 struct usb_driver *driver,
82 const struct 82 const struct snd_usb_audio_quirk *quirk)
83 { 83 {
84 return snd_usb_midi_v2_create(chip, in 84 return snd_usb_midi_v2_create(chip, intf, quirk, 0);
85 } 85 }
86 86
87 /* 87 /*
88 * create a stream for an interface with prope 88 * create a stream for an interface with proper descriptors
89 */ 89 */
90 static int create_standard_audio_quirk(struct 90 static int create_standard_audio_quirk(struct snd_usb_audio *chip,
91 struct 91 struct usb_interface *iface,
92 struct 92 struct usb_driver *driver,
93 const s 93 const struct snd_usb_audio_quirk *quirk)
94 { 94 {
95 struct usb_host_interface *alts; 95 struct usb_host_interface *alts;
96 struct usb_interface_descriptor *altsd 96 struct usb_interface_descriptor *altsd;
97 int err; 97 int err;
98 98
99 alts = &iface->altsetting[0]; 99 alts = &iface->altsetting[0];
100 altsd = get_iface_desc(alts); 100 altsd = get_iface_desc(alts);
101 err = snd_usb_parse_audio_interface(ch 101 err = snd_usb_parse_audio_interface(chip, altsd->bInterfaceNumber);
102 if (err < 0) { 102 if (err < 0) {
103 usb_audio_err(chip, "cannot se 103 usb_audio_err(chip, "cannot setup if %d: error %d\n",
104 altsd->bInterfaceNu 104 altsd->bInterfaceNumber, err);
105 return err; 105 return err;
106 } 106 }
107 /* reset the current interface */ 107 /* reset the current interface */
108 usb_set_interface(chip->dev, altsd->bI 108 usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0);
109 return 0; 109 return 0;
110 } 110 }
111 111
112 /* create the audio stream and the correspondi 112 /* create the audio stream and the corresponding endpoints from the fixed
113 * audioformat object; this is used for quirks 113 * audioformat object; this is used for quirks with the fixed EPs
114 */ 114 */
115 static int add_audio_stream_from_fixed_fmt(str 115 static int add_audio_stream_from_fixed_fmt(struct snd_usb_audio *chip,
116 str 116 struct audioformat *fp)
117 { 117 {
118 int stream, err; 118 int stream, err;
119 119
120 stream = (fp->endpoint & USB_DIR_IN) ? 120 stream = (fp->endpoint & USB_DIR_IN) ?
121 SNDRV_PCM_STREAM_CAPTURE : SND 121 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
122 122
123 snd_usb_audioformat_set_sync_ep(chip, 123 snd_usb_audioformat_set_sync_ep(chip, fp);
124 124
125 err = snd_usb_add_audio_stream(chip, s 125 err = snd_usb_add_audio_stream(chip, stream, fp);
126 if (err < 0) 126 if (err < 0)
127 return err; 127 return err;
128 128
129 err = snd_usb_add_endpoint(chip, fp->e 129 err = snd_usb_add_endpoint(chip, fp->endpoint,
130 SND_USB_END 130 SND_USB_ENDPOINT_TYPE_DATA);
131 if (err < 0) 131 if (err < 0)
132 return err; 132 return err;
133 133
134 if (fp->sync_ep) { 134 if (fp->sync_ep) {
135 err = snd_usb_add_endpoint(chi 135 err = snd_usb_add_endpoint(chip, fp->sync_ep,
136 fp- 136 fp->implicit_fb ?
137 SND 137 SND_USB_ENDPOINT_TYPE_DATA :
138 SND 138 SND_USB_ENDPOINT_TYPE_SYNC);
139 if (err < 0) 139 if (err < 0)
140 return err; 140 return err;
141 } 141 }
142 142
143 return 0; 143 return 0;
144 } 144 }
145 145
146 /* 146 /*
147 * create a stream for an endpoint/altsetting 147 * create a stream for an endpoint/altsetting without proper descriptors
148 */ 148 */
149 static int create_fixed_stream_quirk(struct sn 149 static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
150 struct us 150 struct usb_interface *iface,
151 struct us 151 struct usb_driver *driver,
152 const str 152 const struct snd_usb_audio_quirk *quirk)
153 { 153 {
154 struct audioformat *fp; 154 struct audioformat *fp;
155 struct usb_host_interface *alts; 155 struct usb_host_interface *alts;
156 struct usb_interface_descriptor *altsd 156 struct usb_interface_descriptor *altsd;
157 unsigned *rate_table = NULL; 157 unsigned *rate_table = NULL;
158 int err; 158 int err;
159 159
160 fp = kmemdup(quirk->data, sizeof(*fp), 160 fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
161 if (!fp) 161 if (!fp)
162 return -ENOMEM; 162 return -ENOMEM;
163 163
164 INIT_LIST_HEAD(&fp->list); 164 INIT_LIST_HEAD(&fp->list);
165 if (fp->nr_rates > MAX_NR_RATES) { 165 if (fp->nr_rates > MAX_NR_RATES) {
166 kfree(fp); 166 kfree(fp);
167 return -EINVAL; 167 return -EINVAL;
168 } 168 }
169 if (fp->nr_rates > 0) { 169 if (fp->nr_rates > 0) {
170 rate_table = kmemdup(fp->rate_ 170 rate_table = kmemdup(fp->rate_table,
171 sizeof(in 171 sizeof(int) * fp->nr_rates, GFP_KERNEL);
172 if (!rate_table) { 172 if (!rate_table) {
173 kfree(fp); 173 kfree(fp);
174 return -ENOMEM; 174 return -ENOMEM;
175 } 175 }
176 fp->rate_table = rate_table; 176 fp->rate_table = rate_table;
177 } 177 }
178 178
179 if (fp->iface != get_iface_desc(&iface 179 if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||
180 fp->altset_idx >= iface->num_altse 180 fp->altset_idx >= iface->num_altsetting) {
181 err = -EINVAL; 181 err = -EINVAL;
182 goto error; 182 goto error;
183 } 183 }
184 alts = &iface->altsetting[fp->altset_i 184 alts = &iface->altsetting[fp->altset_idx];
185 altsd = get_iface_desc(alts); 185 altsd = get_iface_desc(alts);
186 if (altsd->bNumEndpoints <= fp->ep_idx 186 if (altsd->bNumEndpoints <= fp->ep_idx) {
187 err = -EINVAL; 187 err = -EINVAL;
188 goto error; 188 goto error;
189 } 189 }
190 190
191 fp->protocol = altsd->bInterfaceProtoc 191 fp->protocol = altsd->bInterfaceProtocol;
192 192
193 if (fp->datainterval == 0) 193 if (fp->datainterval == 0)
194 fp->datainterval = snd_usb_par 194 fp->datainterval = snd_usb_parse_datainterval(chip, alts);
195 if (fp->maxpacksize == 0) 195 if (fp->maxpacksize == 0)
196 fp->maxpacksize = le16_to_cpu( 196 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, fp->ep_idx)->wMaxPacketSize);
197 if (!fp->fmt_type) 197 if (!fp->fmt_type)
198 fp->fmt_type = UAC_FORMAT_TYPE 198 fp->fmt_type = UAC_FORMAT_TYPE_I;
199 199
200 err = add_audio_stream_from_fixed_fmt( 200 err = add_audio_stream_from_fixed_fmt(chip, fp);
201 if (err < 0) 201 if (err < 0)
202 goto error; 202 goto error;
203 203
204 usb_set_interface(chip->dev, fp->iface 204 usb_set_interface(chip->dev, fp->iface, 0);
205 snd_usb_init_pitch(chip, fp); 205 snd_usb_init_pitch(chip, fp);
206 snd_usb_init_sample_rate(chip, fp, fp- 206 snd_usb_init_sample_rate(chip, fp, fp->rate_max);
207 return 0; 207 return 0;
208 208
209 error: 209 error:
210 list_del(&fp->list); /* unlink for avo 210 list_del(&fp->list); /* unlink for avoiding double-free */
211 kfree(fp); 211 kfree(fp);
212 kfree(rate_table); 212 kfree(rate_table);
213 return err; 213 return err;
214 } 214 }
215 215
216 static int create_auto_pcm_quirk(struct snd_us 216 static int create_auto_pcm_quirk(struct snd_usb_audio *chip,
217 struct usb_in 217 struct usb_interface *iface,
218 struct usb_dr 218 struct usb_driver *driver)
219 { 219 {
220 struct usb_host_interface *alts; 220 struct usb_host_interface *alts;
221 struct usb_interface_descriptor *altsd 221 struct usb_interface_descriptor *altsd;
222 struct usb_endpoint_descriptor *epd; 222 struct usb_endpoint_descriptor *epd;
223 struct uac1_as_header_descriptor *ashd 223 struct uac1_as_header_descriptor *ashd;
224 struct uac_format_type_i_discrete_desc 224 struct uac_format_type_i_discrete_descriptor *fmtd;
225 225
226 /* 226 /*
227 * Most Roland/Yamaha audio streaming 227 * Most Roland/Yamaha audio streaming interfaces have more or less
228 * standard descriptors, but older dev 228 * standard descriptors, but older devices might lack descriptors, and
229 * future ones might change, so ensure 229 * future ones might change, so ensure that we fail silently if the
230 * interface doesn't look exactly righ 230 * interface doesn't look exactly right.
231 */ 231 */
232 232
233 /* must have a non-zero altsetting for 233 /* must have a non-zero altsetting for streaming */
234 if (iface->num_altsetting < 2) 234 if (iface->num_altsetting < 2)
235 return -ENODEV; 235 return -ENODEV;
236 alts = &iface->altsetting[1]; 236 alts = &iface->altsetting[1];
237 altsd = get_iface_desc(alts); 237 altsd = get_iface_desc(alts);
238 238
239 /* must have an isochronous endpoint f 239 /* must have an isochronous endpoint for streaming */
240 if (altsd->bNumEndpoints < 1) 240 if (altsd->bNumEndpoints < 1)
241 return -ENODEV; 241 return -ENODEV;
242 epd = get_endpoint(alts, 0); 242 epd = get_endpoint(alts, 0);
243 if (!usb_endpoint_xfer_isoc(epd)) 243 if (!usb_endpoint_xfer_isoc(epd))
244 return -ENODEV; 244 return -ENODEV;
245 245
246 /* must have format descriptors */ 246 /* must have format descriptors */
247 ashd = snd_usb_find_csint_desc(alts->e 247 ashd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
248 UAC_AS_ 248 UAC_AS_GENERAL);
249 fmtd = snd_usb_find_csint_desc(alts->e 249 fmtd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
250 UAC_FOR 250 UAC_FORMAT_TYPE);
251 if (!ashd || ashd->bLength < 7 || 251 if (!ashd || ashd->bLength < 7 ||
252 !fmtd || fmtd->bLength < 8) 252 !fmtd || fmtd->bLength < 8)
253 return -ENODEV; 253 return -ENODEV;
254 254
255 return create_standard_audio_quirk(chi 255 return create_standard_audio_quirk(chip, iface, driver, NULL);
256 } 256 }
257 257
258 static int create_yamaha_midi_quirk(struct snd 258 static int create_yamaha_midi_quirk(struct snd_usb_audio *chip,
259 struct usb 259 struct usb_interface *iface,
260 struct usb 260 struct usb_driver *driver,
261 struct usb 261 struct usb_host_interface *alts)
262 { 262 {
263 static const struct snd_usb_audio_quir 263 static const struct snd_usb_audio_quirk yamaha_midi_quirk = {
264 .type = QUIRK_MIDI_YAMAHA 264 .type = QUIRK_MIDI_YAMAHA
265 }; 265 };
266 struct usb_midi_in_jack_descriptor *in 266 struct usb_midi_in_jack_descriptor *injd;
267 struct usb_midi_out_jack_descriptor *o 267 struct usb_midi_out_jack_descriptor *outjd;
268 268
269 /* must have some valid jack descripto 269 /* must have some valid jack descriptors */
270 injd = snd_usb_find_csint_desc(alts->e 270 injd = snd_usb_find_csint_desc(alts->extra, alts->extralen,
271 NULL, U 271 NULL, USB_MS_MIDI_IN_JACK);
272 outjd = snd_usb_find_csint_desc(alts-> 272 outjd = snd_usb_find_csint_desc(alts->extra, alts->extralen,
273 NULL, 273 NULL, USB_MS_MIDI_OUT_JACK);
274 if (!injd && !outjd) 274 if (!injd && !outjd)
275 return -ENODEV; 275 return -ENODEV;
276 if ((injd && !snd_usb_validate_midi_de 276 if ((injd && !snd_usb_validate_midi_desc(injd)) ||
277 (outjd && !snd_usb_validate_midi_d 277 (outjd && !snd_usb_validate_midi_desc(outjd)))
278 return -ENODEV; 278 return -ENODEV;
279 if (injd && (injd->bLength < 5 || 279 if (injd && (injd->bLength < 5 ||
280 (injd->bJackType != USB_M 280 (injd->bJackType != USB_MS_EMBEDDED &&
281 injd->bJackType != USB_M 281 injd->bJackType != USB_MS_EXTERNAL)))
282 return -ENODEV; 282 return -ENODEV;
283 if (outjd && (outjd->bLength < 6 || 283 if (outjd && (outjd->bLength < 6 ||
284 (outjd->bJackType != USB 284 (outjd->bJackType != USB_MS_EMBEDDED &&
285 outjd->bJackType != USB 285 outjd->bJackType != USB_MS_EXTERNAL)))
286 return -ENODEV; 286 return -ENODEV;
287 return create_any_midi_quirk(chip, ifa 287 return create_any_midi_quirk(chip, iface, driver, &yamaha_midi_quirk);
288 } 288 }
289 289
290 static int create_roland_midi_quirk(struct snd 290 static int create_roland_midi_quirk(struct snd_usb_audio *chip,
291 struct usb 291 struct usb_interface *iface,
292 struct usb 292 struct usb_driver *driver,
293 struct usb 293 struct usb_host_interface *alts)
294 { 294 {
295 static const struct snd_usb_audio_quir 295 static const struct snd_usb_audio_quirk roland_midi_quirk = {
296 .type = QUIRK_MIDI_ROLAND 296 .type = QUIRK_MIDI_ROLAND
297 }; 297 };
298 u8 *roland_desc = NULL; 298 u8 *roland_desc = NULL;
299 299
300 /* might have a vendor-specific descri 300 /* might have a vendor-specific descriptor <06 24 F1 02 ...> */
301 for (;;) { 301 for (;;) {
302 roland_desc = snd_usb_find_csi 302 roland_desc = snd_usb_find_csint_desc(alts->extra,
303 303 alts->extralen,
304 304 roland_desc, 0xf1);
305 if (!roland_desc) 305 if (!roland_desc)
306 return -ENODEV; 306 return -ENODEV;
307 if (roland_desc[0] < 6 || rola 307 if (roland_desc[0] < 6 || roland_desc[3] != 2)
308 continue; 308 continue;
309 return create_any_midi_quirk(c 309 return create_any_midi_quirk(chip, iface, driver,
310 & 310 &roland_midi_quirk);
311 } 311 }
312 } 312 }
313 313
314 static int create_std_midi_quirk(struct snd_us 314 static int create_std_midi_quirk(struct snd_usb_audio *chip,
315 struct usb_in 315 struct usb_interface *iface,
316 struct usb_dr 316 struct usb_driver *driver,
317 struct usb_ho 317 struct usb_host_interface *alts)
318 { 318 {
319 struct usb_ms_header_descriptor *mshd; 319 struct usb_ms_header_descriptor *mshd;
320 struct usb_ms_endpoint_descriptor *mse 320 struct usb_ms_endpoint_descriptor *msepd;
321 321
322 /* must have the MIDIStreaming interfa 322 /* must have the MIDIStreaming interface header descriptor*/
323 mshd = (struct usb_ms_header_descripto 323 mshd = (struct usb_ms_header_descriptor *)alts->extra;
324 if (alts->extralen < 7 || 324 if (alts->extralen < 7 ||
325 mshd->bLength < 7 || 325 mshd->bLength < 7 ||
326 mshd->bDescriptorType != USB_DT_CS 326 mshd->bDescriptorType != USB_DT_CS_INTERFACE ||
327 mshd->bDescriptorSubtype != USB_MS 327 mshd->bDescriptorSubtype != USB_MS_HEADER)
328 return -ENODEV; 328 return -ENODEV;
329 /* must have the MIDIStreaming endpoin 329 /* must have the MIDIStreaming endpoint descriptor*/
330 msepd = (struct usb_ms_endpoint_descri 330 msepd = (struct usb_ms_endpoint_descriptor *)alts->endpoint[0].extra;
331 if (alts->endpoint[0].extralen < 4 || 331 if (alts->endpoint[0].extralen < 4 ||
332 msepd->bLength < 4 || 332 msepd->bLength < 4 ||
333 msepd->bDescriptorType != USB_DT_C 333 msepd->bDescriptorType != USB_DT_CS_ENDPOINT ||
334 msepd->bDescriptorSubtype != UAC_M 334 msepd->bDescriptorSubtype != UAC_MS_GENERAL ||
335 msepd->bNumEmbMIDIJack < 1 || 335 msepd->bNumEmbMIDIJack < 1 ||
336 msepd->bNumEmbMIDIJack > 16) 336 msepd->bNumEmbMIDIJack > 16)
337 return -ENODEV; 337 return -ENODEV;
338 338
339 return create_any_midi_quirk(chip, ifa 339 return create_any_midi_quirk(chip, iface, driver, NULL);
340 } 340 }
341 341
342 static int create_auto_midi_quirk(struct snd_u 342 static int create_auto_midi_quirk(struct snd_usb_audio *chip,
343 struct usb_i 343 struct usb_interface *iface,
344 struct usb_d 344 struct usb_driver *driver)
345 { 345 {
346 struct usb_host_interface *alts; 346 struct usb_host_interface *alts;
347 struct usb_interface_descriptor *altsd 347 struct usb_interface_descriptor *altsd;
348 struct usb_endpoint_descriptor *epd; 348 struct usb_endpoint_descriptor *epd;
349 int err; 349 int err;
350 350
351 alts = &iface->altsetting[0]; 351 alts = &iface->altsetting[0];
352 altsd = get_iface_desc(alts); 352 altsd = get_iface_desc(alts);
353 353
354 /* must have at least one bulk/interru 354 /* must have at least one bulk/interrupt endpoint for streaming */
355 if (altsd->bNumEndpoints < 1) 355 if (altsd->bNumEndpoints < 1)
356 return -ENODEV; 356 return -ENODEV;
357 epd = get_endpoint(alts, 0); 357 epd = get_endpoint(alts, 0);
358 if (!usb_endpoint_xfer_bulk(epd) && 358 if (!usb_endpoint_xfer_bulk(epd) &&
359 !usb_endpoint_xfer_int(epd)) 359 !usb_endpoint_xfer_int(epd))
360 return -ENODEV; 360 return -ENODEV;
361 361
362 switch (USB_ID_VENDOR(chip->usb_id)) { 362 switch (USB_ID_VENDOR(chip->usb_id)) {
363 case 0x0499: /* Yamaha */ 363 case 0x0499: /* Yamaha */
364 err = create_yamaha_midi_quirk 364 err = create_yamaha_midi_quirk(chip, iface, driver, alts);
365 if (err != -ENODEV) 365 if (err != -ENODEV)
366 return err; 366 return err;
367 break; 367 break;
368 case 0x0582: /* Roland */ 368 case 0x0582: /* Roland */
369 err = create_roland_midi_quirk 369 err = create_roland_midi_quirk(chip, iface, driver, alts);
370 if (err != -ENODEV) 370 if (err != -ENODEV)
371 return err; 371 return err;
372 break; 372 break;
373 } 373 }
374 374
375 return create_std_midi_quirk(chip, ifa 375 return create_std_midi_quirk(chip, iface, driver, alts);
376 } 376 }
377 377
378 static int create_autodetect_quirk(struct snd_ 378 static int create_autodetect_quirk(struct snd_usb_audio *chip,
379 struct usb_ 379 struct usb_interface *iface,
380 struct usb_ 380 struct usb_driver *driver,
381 const struc 381 const struct snd_usb_audio_quirk *quirk)
382 { 382 {
383 int err; 383 int err;
384 384
385 err = create_auto_pcm_quirk(chip, ifac 385 err = create_auto_pcm_quirk(chip, iface, driver);
386 if (err == -ENODEV) 386 if (err == -ENODEV)
387 err = create_auto_midi_quirk(c 387 err = create_auto_midi_quirk(chip, iface, driver);
388 return err; 388 return err;
389 } 389 }
390 390
391 /* 391 /*
392 * Create a stream for an Edirol UA-700/UA-25/ 392 * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface.
393 * The only way to detect the sample rate is b 393 * The only way to detect the sample rate is by looking at wMaxPacketSize.
394 */ 394 */
395 static int create_uaxx_quirk(struct snd_usb_au 395 static int create_uaxx_quirk(struct snd_usb_audio *chip,
396 struct usb_interf 396 struct usb_interface *iface,
397 struct usb_driver 397 struct usb_driver *driver,
398 const struct snd_ 398 const struct snd_usb_audio_quirk *quirk)
399 { 399 {
400 static const struct audioformat ua_for 400 static const struct audioformat ua_format = {
401 .formats = SNDRV_PCM_FMTBIT_S2 401 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
402 .channels = 2, 402 .channels = 2,
403 .fmt_type = UAC_FORMAT_TYPE_I, 403 .fmt_type = UAC_FORMAT_TYPE_I,
404 .altsetting = 1, 404 .altsetting = 1,
405 .altset_idx = 1, 405 .altset_idx = 1,
406 .rates = SNDRV_PCM_RATE_CONTIN 406 .rates = SNDRV_PCM_RATE_CONTINUOUS,
407 }; 407 };
408 struct usb_host_interface *alts; 408 struct usb_host_interface *alts;
409 struct usb_interface_descriptor *altsd 409 struct usb_interface_descriptor *altsd;
410 struct audioformat *fp; 410 struct audioformat *fp;
411 int err; 411 int err;
412 412
413 /* both PCM and MIDI interfaces have 2 413 /* both PCM and MIDI interfaces have 2 or more altsettings */
414 if (iface->num_altsetting < 2) 414 if (iface->num_altsetting < 2)
415 return -ENXIO; 415 return -ENXIO;
416 alts = &iface->altsetting[1]; 416 alts = &iface->altsetting[1];
417 altsd = get_iface_desc(alts); 417 altsd = get_iface_desc(alts);
418 418
419 if (altsd->bNumEndpoints == 2) { 419 if (altsd->bNumEndpoints == 2) {
420 static const struct snd_usb_mi 420 static const struct snd_usb_midi_endpoint_info ua700_ep = {
421 .out_cables = 0x0003, 421 .out_cables = 0x0003,
422 .in_cables = 0x0003 422 .in_cables = 0x0003
423 }; 423 };
424 static const struct snd_usb_au 424 static const struct snd_usb_audio_quirk ua700_quirk = {
425 .type = QUIRK_MIDI_FIX 425 .type = QUIRK_MIDI_FIXED_ENDPOINT,
426 .data = &ua700_ep 426 .data = &ua700_ep
427 }; 427 };
428 static const struct snd_usb_mi 428 static const struct snd_usb_midi_endpoint_info uaxx_ep = {
429 .out_cables = 0x0001, 429 .out_cables = 0x0001,
430 .in_cables = 0x0001 430 .in_cables = 0x0001
431 }; 431 };
432 static const struct snd_usb_au 432 static const struct snd_usb_audio_quirk uaxx_quirk = {
433 .type = QUIRK_MIDI_FIX 433 .type = QUIRK_MIDI_FIXED_ENDPOINT,
434 .data = &uaxx_ep 434 .data = &uaxx_ep
435 }; 435 };
436 const struct snd_usb_audio_qui 436 const struct snd_usb_audio_quirk *quirk =
437 chip->usb_id == USB_ID 437 chip->usb_id == USB_ID(0x0582, 0x002b)
438 ? &ua700_quirk : &uaxx 438 ? &ua700_quirk : &uaxx_quirk;
439 return __snd_usbmidi_create(ch 439 return __snd_usbmidi_create(chip->card, iface,
440 &c 440 &chip->midi_list, quirk,
441 ch 441 chip->usb_id,
442 &c 442 &chip->num_rawmidis);
443 } 443 }
444 444
445 if (altsd->bNumEndpoints != 1) 445 if (altsd->bNumEndpoints != 1)
446 return -ENXIO; 446 return -ENXIO;
447 447
448 fp = kmemdup(&ua_format, sizeof(*fp), 448 fp = kmemdup(&ua_format, sizeof(*fp), GFP_KERNEL);
449 if (!fp) 449 if (!fp)
450 return -ENOMEM; 450 return -ENOMEM;
451 451
452 fp->iface = altsd->bInterfaceNumber; 452 fp->iface = altsd->bInterfaceNumber;
453 fp->endpoint = get_endpoint(alts, 0)-> 453 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
454 fp->ep_attr = get_endpoint(alts, 0)->b 454 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
455 fp->datainterval = 0; 455 fp->datainterval = 0;
456 fp->maxpacksize = le16_to_cpu(get_endp 456 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
457 INIT_LIST_HEAD(&fp->list); 457 INIT_LIST_HEAD(&fp->list);
458 458
459 switch (fp->maxpacksize) { 459 switch (fp->maxpacksize) {
460 case 0x120: 460 case 0x120:
461 fp->rate_max = fp->rate_min = 461 fp->rate_max = fp->rate_min = 44100;
462 break; 462 break;
463 case 0x138: 463 case 0x138:
464 case 0x140: 464 case 0x140:
465 fp->rate_max = fp->rate_min = 465 fp->rate_max = fp->rate_min = 48000;
466 break; 466 break;
467 case 0x258: 467 case 0x258:
468 case 0x260: 468 case 0x260:
469 fp->rate_max = fp->rate_min = 469 fp->rate_max = fp->rate_min = 96000;
470 break; 470 break;
471 default: 471 default:
472 usb_audio_err(chip, "unknown s 472 usb_audio_err(chip, "unknown sample rate\n");
473 kfree(fp); 473 kfree(fp);
474 return -ENXIO; 474 return -ENXIO;
475 } 475 }
476 476
477 err = add_audio_stream_from_fixed_fmt( 477 err = add_audio_stream_from_fixed_fmt(chip, fp);
478 if (err < 0) { 478 if (err < 0) {
479 list_del(&fp->list); /* unlink 479 list_del(&fp->list); /* unlink for avoiding double-free */
480 kfree(fp); 480 kfree(fp);
481 return err; 481 return err;
482 } 482 }
483 usb_set_interface(chip->dev, fp->iface 483 usb_set_interface(chip->dev, fp->iface, 0);
484 return 0; 484 return 0;
485 } 485 }
486 486
487 /* 487 /*
488 * Create a standard mixer for the specified i 488 * Create a standard mixer for the specified interface.
489 */ 489 */
490 static int create_standard_mixer_quirk(struct 490 static int create_standard_mixer_quirk(struct snd_usb_audio *chip,
491 struct 491 struct usb_interface *iface,
492 struct 492 struct usb_driver *driver,
493 const s 493 const struct snd_usb_audio_quirk *quirk)
494 { 494 {
495 if (quirk->ifnum < 0) 495 if (quirk->ifnum < 0)
496 return 0; 496 return 0;
497 497
498 return snd_usb_create_mixer(chip, quir 498 return snd_usb_create_mixer(chip, quirk->ifnum);
499 } 499 }
500 500
501 /* 501 /*
502 * audio-interface quirks 502 * audio-interface quirks
503 * 503 *
504 * returns zero if no standard audio/MIDI pars 504 * returns zero if no standard audio/MIDI parsing is needed.
505 * returns a positive value if standard audio/ 505 * returns a positive value if standard audio/midi interfaces are parsed
506 * after this. 506 * after this.
507 * returns a negative value at error. 507 * returns a negative value at error.
508 */ 508 */
509 int snd_usb_create_quirk(struct snd_usb_audio 509 int snd_usb_create_quirk(struct snd_usb_audio *chip,
510 struct usb_interface 510 struct usb_interface *iface,
511 struct usb_driver *dr 511 struct usb_driver *driver,
512 const struct snd_usb_ 512 const struct snd_usb_audio_quirk *quirk)
513 { 513 {
514 typedef int (*quirk_func_t)(struct snd 514 typedef int (*quirk_func_t)(struct snd_usb_audio *,
515 struct usb 515 struct usb_interface *,
516 struct usb 516 struct usb_driver *,
517 const stru 517 const struct snd_usb_audio_quirk *);
518 static const quirk_func_t quirk_funcs[ 518 static const quirk_func_t quirk_funcs[] = {
519 [QUIRK_IGNORE_INTERFACE] = ign 519 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
520 [QUIRK_COMPOSITE] = create_com 520 [QUIRK_COMPOSITE] = create_composite_quirk,
521 [QUIRK_AUTODETECT] = create_au 521 [QUIRK_AUTODETECT] = create_autodetect_quirk,
522 [QUIRK_MIDI_STANDARD_INTERFACE 522 [QUIRK_MIDI_STANDARD_INTERFACE] = create_any_midi_quirk,
523 [QUIRK_MIDI_FIXED_ENDPOINT] = 523 [QUIRK_MIDI_FIXED_ENDPOINT] = create_any_midi_quirk,
524 [QUIRK_MIDI_YAMAHA] = create_a 524 [QUIRK_MIDI_YAMAHA] = create_any_midi_quirk,
525 [QUIRK_MIDI_ROLAND] = create_a 525 [QUIRK_MIDI_ROLAND] = create_any_midi_quirk,
526 [QUIRK_MIDI_MIDIMAN] = create_ 526 [QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk,
527 [QUIRK_MIDI_NOVATION] = create 527 [QUIRK_MIDI_NOVATION] = create_any_midi_quirk,
528 [QUIRK_MIDI_RAW_BYTES] = creat 528 [QUIRK_MIDI_RAW_BYTES] = create_any_midi_quirk,
529 [QUIRK_MIDI_EMAGIC] = create_a 529 [QUIRK_MIDI_EMAGIC] = create_any_midi_quirk,
530 [QUIRK_MIDI_CME] = create_any_ 530 [QUIRK_MIDI_CME] = create_any_midi_quirk,
531 [QUIRK_MIDI_AKAI] = create_any 531 [QUIRK_MIDI_AKAI] = create_any_midi_quirk,
532 [QUIRK_MIDI_FTDI] = create_any 532 [QUIRK_MIDI_FTDI] = create_any_midi_quirk,
533 [QUIRK_MIDI_CH345] = create_an 533 [QUIRK_MIDI_CH345] = create_any_midi_quirk,
534 [QUIRK_AUDIO_STANDARD_INTERFAC 534 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
535 [QUIRK_AUDIO_FIXED_ENDPOINT] = 535 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
536 [QUIRK_AUDIO_EDIROL_UAXX] = cr 536 [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk,
537 [QUIRK_AUDIO_STANDARD_MIXER] = 537 [QUIRK_AUDIO_STANDARD_MIXER] = create_standard_mixer_quirk,
538 }; 538 };
539 539
540 if (quirk->type < QUIRK_TYPE_COUNT) { 540 if (quirk->type < QUIRK_TYPE_COUNT) {
541 return quirk_funcs[quirk->type 541 return quirk_funcs[quirk->type](chip, iface, driver, quirk);
542 } else { 542 } else {
543 usb_audio_err(chip, "invalid q 543 usb_audio_err(chip, "invalid quirk type %d\n", quirk->type);
544 return -ENXIO; 544 return -ENXIO;
545 } 545 }
546 } 546 }
547 547
548 /* 548 /*
549 * boot quirks 549 * boot quirks
550 */ 550 */
551 551
552 #define EXTIGY_FIRMWARE_SIZE_OLD 794 552 #define EXTIGY_FIRMWARE_SIZE_OLD 794
553 #define EXTIGY_FIRMWARE_SIZE_NEW 483 553 #define EXTIGY_FIRMWARE_SIZE_NEW 483
554 554
555 static int snd_usb_extigy_boot_quirk(struct us 555 static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)
556 { 556 {
557 struct usb_host_config *config = dev-> 557 struct usb_host_config *config = dev->actconfig;
558 int err; 558 int err;
559 559
560 if (le16_to_cpu(get_cfg_desc(config)-> 560 if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
561 le16_to_cpu(get_cfg_desc(config)-> 561 le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
562 dev_dbg(&dev->dev, "sending Ex 562 dev_dbg(&dev->dev, "sending Extigy boot sequence...\n");
563 /* Send message to force it to 563 /* Send message to force it to reconnect with full interface. */
564 err = snd_usb_ctl_msg(dev, usb 564 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
565 0x10, 0x 565 0x10, 0x43, 0x0001, 0x000a, NULL, 0);
566 if (err < 0) 566 if (err < 0)
567 dev_dbg(&dev->dev, "er 567 dev_dbg(&dev->dev, "error sending boot message: %d\n", err);
568 err = usb_get_descriptor(dev, 568 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
569 &dev->descript 569 &dev->descriptor, sizeof(dev->descriptor));
570 config = dev->actconfig; 570 config = dev->actconfig;
571 if (err < 0) 571 if (err < 0)
572 dev_dbg(&dev->dev, "er 572 dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);
573 err = usb_reset_configuration( 573 err = usb_reset_configuration(dev);
574 if (err < 0) 574 if (err < 0)
575 dev_dbg(&dev->dev, "er 575 dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);
576 dev_dbg(&dev->dev, "extigy_boo 576 dev_dbg(&dev->dev, "extigy_boot: new boot length = %d\n",
577 le16_to_cpu(get_cf 577 le16_to_cpu(get_cfg_desc(config)->wTotalLength));
578 return -ENODEV; /* quit this a 578 return -ENODEV; /* quit this anyway */
579 } 579 }
580 return 0; 580 return 0;
581 } 581 }
582 582
583 static int snd_usb_audigy2nx_boot_quirk(struct 583 static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
584 { 584 {
585 u8 buf = 1; 585 u8 buf = 1;
586 586
587 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(d 587 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,
588 USB_DIR_IN | USB_TYPE_ 588 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
589 0, 0, &buf, 1); 589 0, 0, &buf, 1);
590 if (buf == 0) { 590 if (buf == 0) {
591 snd_usb_ctl_msg(dev, usb_sndct 591 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,
592 USB_DIR_OUT | 592 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
593 1, 2000, NULL, 593 1, 2000, NULL, 0);
594 return -ENODEV; 594 return -ENODEV;
595 } 595 }
596 return 0; 596 return 0;
597 } 597 }
598 598
599 static int snd_usb_fasttrackpro_boot_quirk(str 599 static int snd_usb_fasttrackpro_boot_quirk(struct usb_device *dev)
600 { 600 {
601 int err; 601 int err;
602 602
603 if (dev->actconfig->desc.bConfiguratio 603 if (dev->actconfig->desc.bConfigurationValue == 1) {
604 dev_info(&dev->dev, 604 dev_info(&dev->dev,
605 "Fast Track Pro swi 605 "Fast Track Pro switching to config #2\n");
606 /* This function has to be ava 606 /* This function has to be available by the usb core module.
607 * if it is not avialable the 607 * if it is not avialable the boot quirk has to be left out
608 * and the configuration has t 608 * and the configuration has to be set by udev or hotplug
609 * rules 609 * rules
610 */ 610 */
611 err = usb_driver_set_configura 611 err = usb_driver_set_configuration(dev, 2);
612 if (err < 0) 612 if (err < 0)
613 dev_dbg(&dev->dev, 613 dev_dbg(&dev->dev,
614 "error usb_dri 614 "error usb_driver_set_configuration: %d\n",
615 err); 615 err);
616 /* Always return an error, so 616 /* Always return an error, so that we stop creating a device
617 that will just be destroyed 617 that will just be destroyed and recreated with a new
618 configuration */ 618 configuration */
619 return -ENODEV; 619 return -ENODEV;
620 } else 620 } else
621 dev_info(&dev->dev, "Fast Trac 621 dev_info(&dev->dev, "Fast Track Pro config OK\n");
622 622
623 return 0; 623 return 0;
624 } 624 }
625 625
626 /* 626 /*
627 * C-Media CM106/CM106+ have four 16-bit inter 627 * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely
628 * documented in the device's data sheet. 628 * documented in the device's data sheet.
629 */ 629 */
630 static int snd_usb_cm106_write_int_reg(struct 630 static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value)
631 { 631 {
632 u8 buf[4]; 632 u8 buf[4];
633 buf[0] = 0x20; 633 buf[0] = 0x20;
634 buf[1] = value & 0xff; 634 buf[1] = value & 0xff;
635 buf[2] = (value >> 8) & 0xff; 635 buf[2] = (value >> 8) & 0xff;
636 buf[3] = reg; 636 buf[3] = reg;
637 return snd_usb_ctl_msg(dev, usb_sndctr 637 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION,
638 USB_DIR_OUT | U 638 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
639 0, 0, &buf, 4); 639 0, 0, &buf, 4);
640 } 640 }
641 641
642 static int snd_usb_cm106_boot_quirk(struct usb 642 static int snd_usb_cm106_boot_quirk(struct usb_device *dev)
643 { 643 {
644 /* 644 /*
645 * Enable line-out driver mode, set he 645 * Enable line-out driver mode, set headphone source to front
646 * channels, enable stereo mic. 646 * channels, enable stereo mic.
647 */ 647 */
648 return snd_usb_cm106_write_int_reg(dev 648 return snd_usb_cm106_write_int_reg(dev, 2, 0x8004);
649 } 649 }
650 650
651 /* 651 /*
652 * CM6206 registers from the CM6206 datasheet 652 * CM6206 registers from the CM6206 datasheet rev 2.1
653 */ 653 */
654 #define CM6206_REG0_DMA_MASTER BIT(15) 654 #define CM6206_REG0_DMA_MASTER BIT(15)
655 #define CM6206_REG0_SPDIFO_RATE_48K (2 << 12) 655 #define CM6206_REG0_SPDIFO_RATE_48K (2 << 12)
656 #define CM6206_REG0_SPDIFO_RATE_96K (7 << 12) 656 #define CM6206_REG0_SPDIFO_RATE_96K (7 << 12)
657 /* Bit 4 thru 11 is the S/PDIF category code * 657 /* Bit 4 thru 11 is the S/PDIF category code */
658 #define CM6206_REG0_SPDIFO_CAT_CODE_GENERAL (0 658 #define CM6206_REG0_SPDIFO_CAT_CODE_GENERAL (0 << 4)
659 #define CM6206_REG0_SPDIFO_EMPHASIS_CD BIT(3) 659 #define CM6206_REG0_SPDIFO_EMPHASIS_CD BIT(3)
660 #define CM6206_REG0_SPDIFO_COPYRIGHT_NA BIT(2) 660 #define CM6206_REG0_SPDIFO_COPYRIGHT_NA BIT(2)
661 #define CM6206_REG0_SPDIFO_NON_AUDIO BIT(1) 661 #define CM6206_REG0_SPDIFO_NON_AUDIO BIT(1)
662 #define CM6206_REG0_SPDIFO_PRO_FORMAT BIT(0) 662 #define CM6206_REG0_SPDIFO_PRO_FORMAT BIT(0)
663 663
664 #define CM6206_REG1_TEST_SEL_CLK BIT(14) 664 #define CM6206_REG1_TEST_SEL_CLK BIT(14)
665 #define CM6206_REG1_PLLBIN_EN BIT(13) 665 #define CM6206_REG1_PLLBIN_EN BIT(13)
666 #define CM6206_REG1_SOFT_MUTE_EN BIT(12) 666 #define CM6206_REG1_SOFT_MUTE_EN BIT(12)
667 #define CM6206_REG1_GPIO4_OUT BIT(11) 667 #define CM6206_REG1_GPIO4_OUT BIT(11)
668 #define CM6206_REG1_GPIO4_OE BIT(10) 668 #define CM6206_REG1_GPIO4_OE BIT(10)
669 #define CM6206_REG1_GPIO3_OUT BIT(9) 669 #define CM6206_REG1_GPIO3_OUT BIT(9)
670 #define CM6206_REG1_GPIO3_OE BIT(8) 670 #define CM6206_REG1_GPIO3_OE BIT(8)
671 #define CM6206_REG1_GPIO2_OUT BIT(7) 671 #define CM6206_REG1_GPIO2_OUT BIT(7)
672 #define CM6206_REG1_GPIO2_OE BIT(6) 672 #define CM6206_REG1_GPIO2_OE BIT(6)
673 #define CM6206_REG1_GPIO1_OUT BIT(5) 673 #define CM6206_REG1_GPIO1_OUT BIT(5)
674 #define CM6206_REG1_GPIO1_OE BIT(4) 674 #define CM6206_REG1_GPIO1_OE BIT(4)
675 #define CM6206_REG1_SPDIFO_INVALID BIT(3) 675 #define CM6206_REG1_SPDIFO_INVALID BIT(3)
676 #define CM6206_REG1_SPDIF_LOOP_EN BIT(2) 676 #define CM6206_REG1_SPDIF_LOOP_EN BIT(2)
677 #define CM6206_REG1_SPDIFO_DIS BIT(1) 677 #define CM6206_REG1_SPDIFO_DIS BIT(1)
678 #define CM6206_REG1_SPDIFI_MIX BIT(0) 678 #define CM6206_REG1_SPDIFI_MIX BIT(0)
679 679
680 #define CM6206_REG2_DRIVER_ON BIT(15) 680 #define CM6206_REG2_DRIVER_ON BIT(15)
681 #define CM6206_REG2_HEADP_SEL_SIDE_CHANNELS (0 681 #define CM6206_REG2_HEADP_SEL_SIDE_CHANNELS (0 << 13)
682 #define CM6206_REG2_HEADP_SEL_SURROUND_CHANNEL 682 #define CM6206_REG2_HEADP_SEL_SURROUND_CHANNELS (1 << 13)
683 #define CM6206_REG2_HEADP_SEL_CENTER_SUBW (2 < 683 #define CM6206_REG2_HEADP_SEL_CENTER_SUBW (2 << 13)
684 #define CM6206_REG2_HEADP_SEL_FRONT_CHANNELS ( 684 #define CM6206_REG2_HEADP_SEL_FRONT_CHANNELS (3 << 13)
685 #define CM6206_REG2_MUTE_HEADPHONE_RIGHT BIT(1 685 #define CM6206_REG2_MUTE_HEADPHONE_RIGHT BIT(12)
686 #define CM6206_REG2_MUTE_HEADPHONE_LEFT BIT(11 686 #define CM6206_REG2_MUTE_HEADPHONE_LEFT BIT(11)
687 #define CM6206_REG2_MUTE_REAR_SURROUND_RIGHT B 687 #define CM6206_REG2_MUTE_REAR_SURROUND_RIGHT BIT(10)
688 #define CM6206_REG2_MUTE_REAR_SURROUND_LEFT BI 688 #define CM6206_REG2_MUTE_REAR_SURROUND_LEFT BIT(9)
689 #define CM6206_REG2_MUTE_SIDE_SURROUND_RIGHT B 689 #define CM6206_REG2_MUTE_SIDE_SURROUND_RIGHT BIT(8)
690 #define CM6206_REG2_MUTE_SIDE_SURROUND_LEFT BI 690 #define CM6206_REG2_MUTE_SIDE_SURROUND_LEFT BIT(7)
691 #define CM6206_REG2_MUTE_SUBWOOFER BIT(6) 691 #define CM6206_REG2_MUTE_SUBWOOFER BIT(6)
692 #define CM6206_REG2_MUTE_CENTER BIT(5) 692 #define CM6206_REG2_MUTE_CENTER BIT(5)
693 #define CM6206_REG2_MUTE_RIGHT_FRONT BIT(3) 693 #define CM6206_REG2_MUTE_RIGHT_FRONT BIT(3)
694 #define CM6206_REG2_MUTE_LEFT_FRONT BIT(3) 694 #define CM6206_REG2_MUTE_LEFT_FRONT BIT(3)
695 #define CM6206_REG2_EN_BTL BIT(2) 695 #define CM6206_REG2_EN_BTL BIT(2)
696 #define CM6206_REG2_MCUCLKSEL_1_5_MHZ (0) 696 #define CM6206_REG2_MCUCLKSEL_1_5_MHZ (0)
697 #define CM6206_REG2_MCUCLKSEL_3_MHZ (1) 697 #define CM6206_REG2_MCUCLKSEL_3_MHZ (1)
698 #define CM6206_REG2_MCUCLKSEL_6_MHZ (2) 698 #define CM6206_REG2_MCUCLKSEL_6_MHZ (2)
699 #define CM6206_REG2_MCUCLKSEL_12_MHZ (3) 699 #define CM6206_REG2_MCUCLKSEL_12_MHZ (3)
700 700
701 /* Bit 11..13 sets the sensitivity to FLY tune 701 /* Bit 11..13 sets the sensitivity to FLY tuner volume control VP/VD signal */
702 #define CM6206_REG3_FLYSPEED_DEFAULT (2 << 11) 702 #define CM6206_REG3_FLYSPEED_DEFAULT (2 << 11)
703 #define CM6206_REG3_VRAP25EN BIT(10) 703 #define CM6206_REG3_VRAP25EN BIT(10)
704 #define CM6206_REG3_MSEL1 BIT(9) 704 #define CM6206_REG3_MSEL1 BIT(9)
705 #define CM6206_REG3_SPDIFI_RATE_44_1K BIT(0 << 705 #define CM6206_REG3_SPDIFI_RATE_44_1K BIT(0 << 7)
706 #define CM6206_REG3_SPDIFI_RATE_48K BIT(2 << 7 706 #define CM6206_REG3_SPDIFI_RATE_48K BIT(2 << 7)
707 #define CM6206_REG3_SPDIFI_RATE_32K BIT(3 << 7 707 #define CM6206_REG3_SPDIFI_RATE_32K BIT(3 << 7)
708 #define CM6206_REG3_PINSEL BIT(6) 708 #define CM6206_REG3_PINSEL BIT(6)
709 #define CM6206_REG3_FOE BIT(5) 709 #define CM6206_REG3_FOE BIT(5)
710 #define CM6206_REG3_ROE BIT(4) 710 #define CM6206_REG3_ROE BIT(4)
711 #define CM6206_REG3_CBOE BIT(3) 711 #define CM6206_REG3_CBOE BIT(3)
712 #define CM6206_REG3_LOSE BIT(2) 712 #define CM6206_REG3_LOSE BIT(2)
713 #define CM6206_REG3_HPOE BIT(1) 713 #define CM6206_REG3_HPOE BIT(1)
714 #define CM6206_REG3_SPDIFI_CANREC BIT(0) 714 #define CM6206_REG3_SPDIFI_CANREC BIT(0)
715 715
716 #define CM6206_REG5_DA_RSTN BIT(13) 716 #define CM6206_REG5_DA_RSTN BIT(13)
717 #define CM6206_REG5_AD_RSTN BIT(12) 717 #define CM6206_REG5_AD_RSTN BIT(12)
718 #define CM6206_REG5_SPDIFO_AD2SPDO BIT(12) 718 #define CM6206_REG5_SPDIFO_AD2SPDO BIT(12)
719 #define CM6206_REG5_SPDIFO_SEL_FRONT (0 << 9) 719 #define CM6206_REG5_SPDIFO_SEL_FRONT (0 << 9)
720 #define CM6206_REG5_SPDIFO_SEL_SIDE_SUR (1 << 720 #define CM6206_REG5_SPDIFO_SEL_SIDE_SUR (1 << 9)
721 #define CM6206_REG5_SPDIFO_SEL_CEN_LFE (2 << 9 721 #define CM6206_REG5_SPDIFO_SEL_CEN_LFE (2 << 9)
722 #define CM6206_REG5_SPDIFO_SEL_REAR_SUR (3 << 722 #define CM6206_REG5_SPDIFO_SEL_REAR_SUR (3 << 9)
723 #define CM6206_REG5_CODECM BIT(8) 723 #define CM6206_REG5_CODECM BIT(8)
724 #define CM6206_REG5_EN_HPF BIT(7) 724 #define CM6206_REG5_EN_HPF BIT(7)
725 #define CM6206_REG5_T_SEL_DSDA4 BIT(6) 725 #define CM6206_REG5_T_SEL_DSDA4 BIT(6)
726 #define CM6206_REG5_T_SEL_DSDA3 BIT(5) 726 #define CM6206_REG5_T_SEL_DSDA3 BIT(5)
727 #define CM6206_REG5_T_SEL_DSDA2 BIT(4) 727 #define CM6206_REG5_T_SEL_DSDA2 BIT(4)
728 #define CM6206_REG5_T_SEL_DSDA1 BIT(3) 728 #define CM6206_REG5_T_SEL_DSDA1 BIT(3)
729 #define CM6206_REG5_T_SEL_DSDAD_NORMAL 0 729 #define CM6206_REG5_T_SEL_DSDAD_NORMAL 0
730 #define CM6206_REG5_T_SEL_DSDAD_FRONT 4 730 #define CM6206_REG5_T_SEL_DSDAD_FRONT 4
731 #define CM6206_REG5_T_SEL_DSDAD_S_SURROUND 5 731 #define CM6206_REG5_T_SEL_DSDAD_S_SURROUND 5
732 #define CM6206_REG5_T_SEL_DSDAD_CEN_LFE 6 732 #define CM6206_REG5_T_SEL_DSDAD_CEN_LFE 6
733 #define CM6206_REG5_T_SEL_DSDAD_R_SURROUND 7 733 #define CM6206_REG5_T_SEL_DSDAD_R_SURROUND 7
734 734
735 static int snd_usb_cm6206_boot_quirk(struct us 735 static int snd_usb_cm6206_boot_quirk(struct usb_device *dev)
736 { 736 {
737 int err = 0, reg; 737 int err = 0, reg;
738 int val[] = { 738 int val[] = {
739 /* 739 /*
740 * Values here are chosen base 740 * Values here are chosen based on sniffing USB traffic
741 * under Windows. 741 * under Windows.
742 * 742 *
743 * REG0: DAC is master, sample 743 * REG0: DAC is master, sample rate 48kHz, no copyright
744 */ 744 */
745 CM6206_REG0_SPDIFO_RATE_48K | 745 CM6206_REG0_SPDIFO_RATE_48K |
746 CM6206_REG0_SPDIFO_COPYRIGHT_N 746 CM6206_REG0_SPDIFO_COPYRIGHT_NA,
747 /* 747 /*
748 * REG1: PLL binary search ena 748 * REG1: PLL binary search enable, soft mute enable.
749 */ 749 */
750 CM6206_REG1_PLLBIN_EN | 750 CM6206_REG1_PLLBIN_EN |
751 CM6206_REG1_SOFT_MUTE_EN, 751 CM6206_REG1_SOFT_MUTE_EN,
752 /* 752 /*
753 * REG2: enable output drivers 753 * REG2: enable output drivers,
754 * select front channels to th 754 * select front channels to the headphone output,
755 * then mute the headphone cha 755 * then mute the headphone channels, run the MCU
756 * at 1.5 MHz. 756 * at 1.5 MHz.
757 */ 757 */
758 CM6206_REG2_DRIVER_ON | 758 CM6206_REG2_DRIVER_ON |
759 CM6206_REG2_HEADP_SEL_FRONT_CH 759 CM6206_REG2_HEADP_SEL_FRONT_CHANNELS |
760 CM6206_REG2_MUTE_HEADPHONE_RIG 760 CM6206_REG2_MUTE_HEADPHONE_RIGHT |
761 CM6206_REG2_MUTE_HEADPHONE_LEF 761 CM6206_REG2_MUTE_HEADPHONE_LEFT,
762 /* 762 /*
763 * REG3: default flyspeed, set 763 * REG3: default flyspeed, set 2.5V mic bias
764 * enable all line out ports a 764 * enable all line out ports and enable SPDIF
765 */ 765 */
766 CM6206_REG3_FLYSPEED_DEFAULT | 766 CM6206_REG3_FLYSPEED_DEFAULT |
767 CM6206_REG3_VRAP25EN | 767 CM6206_REG3_VRAP25EN |
768 CM6206_REG3_FOE | 768 CM6206_REG3_FOE |
769 CM6206_REG3_ROE | 769 CM6206_REG3_ROE |
770 CM6206_REG3_CBOE | 770 CM6206_REG3_CBOE |
771 CM6206_REG3_LOSE | 771 CM6206_REG3_LOSE |
772 CM6206_REG3_HPOE | 772 CM6206_REG3_HPOE |
773 CM6206_REG3_SPDIFI_CANREC, 773 CM6206_REG3_SPDIFI_CANREC,
774 /* REG4 is just a bunch of GPI 774 /* REG4 is just a bunch of GPIO lines */
775 0x0000, 775 0x0000,
776 /* REG5: de-assert AD/DA reset 776 /* REG5: de-assert AD/DA reset signals */
777 CM6206_REG5_DA_RSTN | 777 CM6206_REG5_DA_RSTN |
778 CM6206_REG5_AD_RSTN }; 778 CM6206_REG5_AD_RSTN };
779 779
780 for (reg = 0; reg < ARRAY_SIZE(val); r 780 for (reg = 0; reg < ARRAY_SIZE(val); reg++) {
781 err = snd_usb_cm106_write_int_ 781 err = snd_usb_cm106_write_int_reg(dev, reg, val[reg]);
782 if (err < 0) 782 if (err < 0)
783 return err; 783 return err;
784 } 784 }
785 785
786 return err; 786 return err;
787 } 787 }
788 788
789 /* quirk for Plantronics GameCom 780 with CM63 789 /* quirk for Plantronics GameCom 780 with CM6302 chip */
790 static int snd_usb_gamecon780_boot_quirk(struc 790 static int snd_usb_gamecon780_boot_quirk(struct usb_device *dev)
791 { 791 {
792 /* set the initial volume and don't ch 792 /* set the initial volume and don't change; other values are either
793 * too loud or silent due to firmware 793 * too loud or silent due to firmware bug (bko#65251)
794 */ 794 */
795 u8 buf[2] = { 0x74, 0xe3 }; 795 u8 buf[2] = { 0x74, 0xe3 };
796 return snd_usb_ctl_msg(dev, usb_sndctr 796 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
797 USB_RECIP_INTERFACE | 797 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
798 UAC_FU_VOLUME << 8, 9 798 UAC_FU_VOLUME << 8, 9 << 8, buf, 2);
799 } 799 }
800 800
801 /* 801 /*
802 * Novation Twitch DJ controller 802 * Novation Twitch DJ controller
803 * Focusrite Novation Saffire 6 USB audio card 803 * Focusrite Novation Saffire 6 USB audio card
804 */ 804 */
805 static int snd_usb_novation_boot_quirk(struct 805 static int snd_usb_novation_boot_quirk(struct usb_device *dev)
806 { 806 {
807 /* preemptively set up the device beca 807 /* preemptively set up the device because otherwise the
808 * raw MIDI endpoints are not active * 808 * raw MIDI endpoints are not active */
809 usb_set_interface(dev, 0, 1); 809 usb_set_interface(dev, 0, 1);
810 return 0; 810 return 0;
811 } 811 }
812 812
813 /* 813 /*
814 * This call will put the synth in "USB send" 814 * This call will put the synth in "USB send" mode, i.e it will send MIDI
815 * messages through USB (this is disabled at s 815 * messages through USB (this is disabled at startup). The synth will
816 * acknowledge by sending a sysex on endpoint 816 * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB
817 * sign on its LCD. Values here are chosen bas 817 * sign on its LCD. Values here are chosen based on sniffing USB traffic
818 * under Windows. 818 * under Windows.
819 */ 819 */
820 static int snd_usb_accessmusic_boot_quirk(stru 820 static int snd_usb_accessmusic_boot_quirk(struct usb_device *dev)
821 { 821 {
822 int err, actual_length; 822 int err, actual_length;
823 /* "midi send" enable */ 823 /* "midi send" enable */
824 static const u8 seq[] = { 0x4e, 0x73, 824 static const u8 seq[] = { 0x4e, 0x73, 0x52, 0x01 };
825 void *buf; 825 void *buf;
826 826
827 if (usb_pipe_type_check(dev, usb_sndin 827 if (usb_pipe_type_check(dev, usb_sndintpipe(dev, 0x05)))
828 return -EINVAL; 828 return -EINVAL;
829 buf = kmemdup(seq, ARRAY_SIZE(seq), GF 829 buf = kmemdup(seq, ARRAY_SIZE(seq), GFP_KERNEL);
830 if (!buf) 830 if (!buf)
831 return -ENOMEM; 831 return -ENOMEM;
832 err = usb_interrupt_msg(dev, usb_sndin 832 err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x05), buf,
833 ARRAY_SIZE(seq), &actu 833 ARRAY_SIZE(seq), &actual_length, 1000);
834 kfree(buf); 834 kfree(buf);
835 if (err < 0) 835 if (err < 0)
836 return err; 836 return err;
837 837
838 return 0; 838 return 0;
839 } 839 }
840 840
841 /* 841 /*
842 * Some sound cards from Native Instruments ar 842 * Some sound cards from Native Instruments are in fact compliant to the USB
843 * audio standard of version 2 and other appro 843 * audio standard of version 2 and other approved USB standards, even though
844 * they come up as vendor-specific device when 844 * they come up as vendor-specific device when first connected.
845 * 845 *
846 * However, they can be told to come up with a 846 * However, they can be told to come up with a new set of descriptors
847 * upon their next enumeration, and the interf 847 * upon their next enumeration, and the interfaces announced by the new
848 * descriptors will then be handled by the ker 848 * descriptors will then be handled by the kernel's class drivers. As the
849 * product ID will also change, no further che 849 * product ID will also change, no further checks are required.
850 */ 850 */
851 851
852 static int snd_usb_nativeinstruments_boot_quir 852 static int snd_usb_nativeinstruments_boot_quirk(struct usb_device *dev)
853 { 853 {
854 int ret; 854 int ret;
855 855
856 ret = usb_control_msg(dev, usb_sndctrl 856 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
857 0xaf, USB_TY 857 0xaf, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
858 1, 0, NULL, 858 1, 0, NULL, 0, 1000);
859 859
860 if (ret < 0) 860 if (ret < 0)
861 return ret; 861 return ret;
862 862
863 usb_reset_device(dev); 863 usb_reset_device(dev);
864 864
865 /* return -EAGAIN, so the creation of 865 /* return -EAGAIN, so the creation of an audio interface for this
866 * temporary device is aborted. The de 866 * temporary device is aborted. The device will reconnect with a
867 * new product ID */ 867 * new product ID */
868 return -EAGAIN; 868 return -EAGAIN;
869 } 869 }
870 870
871 static void mbox2_setup_48_24_magic(struct usb 871 static void mbox2_setup_48_24_magic(struct usb_device *dev)
872 { 872 {
873 u8 srate[3]; 873 u8 srate[3];
874 u8 temp[12]; 874 u8 temp[12];
875 875
876 /* Choose 48000Hz permanently */ 876 /* Choose 48000Hz permanently */
877 srate[0] = 0x80; 877 srate[0] = 0x80;
878 srate[1] = 0xbb; 878 srate[1] = 0xbb;
879 srate[2] = 0x00; 879 srate[2] = 0x00;
880 880
881 /* Send the magic! */ 881 /* Send the magic! */
882 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(d 882 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
883 0x01, 0x22, 0x0100, 0x0085, &t 883 0x01, 0x22, 0x0100, 0x0085, &temp, 0x0003);
884 snd_usb_ctl_msg(dev, usb_sndctrlpipe(d 884 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
885 0x81, 0xa2, 0x0100, 0x0085, &s 885 0x81, 0xa2, 0x0100, 0x0085, &srate, 0x0003);
886 snd_usb_ctl_msg(dev, usb_sndctrlpipe(d 886 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
887 0x81, 0xa2, 0x0100, 0x0086, &s 887 0x81, 0xa2, 0x0100, 0x0086, &srate, 0x0003);
888 snd_usb_ctl_msg(dev, usb_sndctrlpipe(d 888 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
889 0x81, 0xa2, 0x0100, 0x0003, &s 889 0x81, 0xa2, 0x0100, 0x0003, &srate, 0x0003);
890 return; 890 return;
891 } 891 }
892 892
893 /* Digidesign Mbox 2 needs to load firmware on 893 /* Digidesign Mbox 2 needs to load firmware onboard
894 * and driver must wait a few seconds for init 894 * and driver must wait a few seconds for initialisation.
895 */ 895 */
896 896
897 #define MBOX2_FIRMWARE_SIZE 646 897 #define MBOX2_FIRMWARE_SIZE 646
898 #define MBOX2_BOOT_LOADING 0x01 /* Hard co 898 #define MBOX2_BOOT_LOADING 0x01 /* Hard coded into the device */
899 #define MBOX2_BOOT_READY 0x02 /* Hard co 899 #define MBOX2_BOOT_READY 0x02 /* Hard coded into the device */
900 900
901 static int snd_usb_mbox2_boot_quirk(struct usb 901 static int snd_usb_mbox2_boot_quirk(struct usb_device *dev)
902 { 902 {
903 struct usb_host_config *config = dev-> 903 struct usb_host_config *config = dev->actconfig;
904 int err; 904 int err;
905 u8 bootresponse[0x12]; 905 u8 bootresponse[0x12];
906 int fwsize; 906 int fwsize;
907 int count; 907 int count;
908 908
909 fwsize = le16_to_cpu(get_cfg_desc(conf 909 fwsize = le16_to_cpu(get_cfg_desc(config)->wTotalLength);
910 910
911 if (fwsize != MBOX2_FIRMWARE_SIZE) { 911 if (fwsize != MBOX2_FIRMWARE_SIZE) {
912 dev_err(&dev->dev, "Invalid fi 912 dev_err(&dev->dev, "Invalid firmware size=%d.\n", fwsize);
913 return -ENODEV; 913 return -ENODEV;
914 } 914 }
915 915
916 dev_dbg(&dev->dev, "Sending Digidesign 916 dev_dbg(&dev->dev, "Sending Digidesign Mbox 2 boot sequence...\n");
917 917
918 count = 0; 918 count = 0;
919 bootresponse[0] = MBOX2_BOOT_LOADING; 919 bootresponse[0] = MBOX2_BOOT_LOADING;
920 while ((bootresponse[0] == MBOX2_BOOT_ 920 while ((bootresponse[0] == MBOX2_BOOT_LOADING) && (count < 10)) {
921 msleep(500); /* 0.5 second del 921 msleep(500); /* 0.5 second delay */
922 snd_usb_ctl_msg(dev, usb_rcvct 922 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
923 /* Control magic - loa 923 /* Control magic - load onboard firmware */
924 0x85, 0xc0, 0x0001, 0x 924 0x85, 0xc0, 0x0001, 0x0000, &bootresponse, 0x0012);
925 if (bootresponse[0] == MBOX2_B 925 if (bootresponse[0] == MBOX2_BOOT_READY)
926 break; 926 break;
927 dev_dbg(&dev->dev, "device not 927 dev_dbg(&dev->dev, "device not ready, resending boot sequence...\n");
928 count++; 928 count++;
929 } 929 }
930 930
931 if (bootresponse[0] != MBOX2_BOOT_READ 931 if (bootresponse[0] != MBOX2_BOOT_READY) {
932 dev_err(&dev->dev, "Unknown bo 932 dev_err(&dev->dev, "Unknown bootresponse=%d, or timed out, ignoring device.\n", bootresponse[0]);
933 return -ENODEV; 933 return -ENODEV;
934 } 934 }
935 935
936 dev_dbg(&dev->dev, "device initialised 936 dev_dbg(&dev->dev, "device initialised!\n");
937 937
938 err = usb_get_descriptor(dev, USB_DT_D 938 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
939 &dev->descriptor, sizeof(dev-> 939 &dev->descriptor, sizeof(dev->descriptor));
940 config = dev->actconfig; 940 config = dev->actconfig;
941 if (err < 0) 941 if (err < 0)
942 dev_dbg(&dev->dev, "error usb_ 942 dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);
943 943
944 err = usb_reset_configuration(dev); 944 err = usb_reset_configuration(dev);
945 if (err < 0) 945 if (err < 0)
946 dev_dbg(&dev->dev, "error usb_ 946 dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);
947 dev_dbg(&dev->dev, "mbox2_boot: new bo 947 dev_dbg(&dev->dev, "mbox2_boot: new boot length = %d\n",
948 le16_to_cpu(get_cfg_desc(confi 948 le16_to_cpu(get_cfg_desc(config)->wTotalLength));
949 949
950 mbox2_setup_48_24_magic(dev); 950 mbox2_setup_48_24_magic(dev);
951 951
952 dev_info(&dev->dev, "Digidesign Mbox 2 952 dev_info(&dev->dev, "Digidesign Mbox 2: 24bit 48kHz");
953 953
954 return 0; /* Successful boot */ 954 return 0; /* Successful boot */
955 } 955 }
956 956
957 static int snd_usb_axefx3_boot_quirk(struct us 957 static int snd_usb_axefx3_boot_quirk(struct usb_device *dev)
958 { 958 {
959 int err; 959 int err;
960 960
961 dev_dbg(&dev->dev, "Waiting for Axe-Fx 961 dev_dbg(&dev->dev, "Waiting for Axe-Fx III to boot up...\n");
962 962
963 /* If the Axe-Fx III has not fully boo 963 /* If the Axe-Fx III has not fully booted, it will timeout when trying
964 * to enable the audio streaming inter 964 * to enable the audio streaming interface. A more generous timeout is
965 * used here to detect when the Axe-Fx 965 * used here to detect when the Axe-Fx III has finished booting as the
966 * set interface message will be acked 966 * set interface message will be acked once it has
967 */ 967 */
968 err = usb_control_msg(dev, usb_sndctrl 968 err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
969 USB_REQ_SET_IN 969 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
970 1, 1, NULL, 0, 970 1, 1, NULL, 0, 120000);
971 if (err < 0) { 971 if (err < 0) {
972 dev_err(&dev->dev, 972 dev_err(&dev->dev,
973 "failed waiting for Ax 973 "failed waiting for Axe-Fx III to boot: %d\n", err);
974 return err; 974 return err;
975 } 975 }
976 976
977 dev_dbg(&dev->dev, "Axe-Fx III is now 977 dev_dbg(&dev->dev, "Axe-Fx III is now ready\n");
978 978
979 err = usb_set_interface(dev, 1, 0); 979 err = usb_set_interface(dev, 1, 0);
980 if (err < 0) 980 if (err < 0)
981 dev_dbg(&dev->dev, 981 dev_dbg(&dev->dev,
982 "error stopping Axe-Fx 982 "error stopping Axe-Fx III interface: %d\n", err);
983 983
984 return 0; 984 return 0;
985 } 985 }
986 986
987 static void mbox3_setup_defaults(struct usb_de 987 static void mbox3_setup_defaults(struct usb_device *dev)
988 { 988 {
989 /* The Mbox 3 is "little endian" */ 989 /* The Mbox 3 is "little endian" */
990 /* max volume is: 0x0000. */ 990 /* max volume is: 0x0000. */
991 /* min volume is: 0x0080 (shown in lit 991 /* min volume is: 0x0080 (shown in little endian form) */
992 992
993 u8 com_buff[2]; 993 u8 com_buff[2];
994 994
995 /* Deactivate Tuner */ 995 /* Deactivate Tuner */
996 /* on = 0x01*/ 996 /* on = 0x01*/
997 /* off = 0x00*/ 997 /* off = 0x00*/
998 com_buff[0] = 0x00; 998 com_buff[0] = 0x00;
999 snd_usb_ctl_msg(dev, usb_sndctrlpipe(d 999 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1000 0x01, 0x21, 0x0003, 0x2001, & 1000 0x01, 0x21, 0x0003, 0x2001, &com_buff, 1);
1001 1001
1002 /* Set clock source to Internal (as o 1002 /* Set clock source to Internal (as opposed to S/PDIF) */
1003 /* Internal = 0x01*/ 1003 /* Internal = 0x01*/
1004 /* S/PDIF = 0x02*/ 1004 /* S/PDIF = 0x02*/
1005 com_buff[0] = 0x01; 1005 com_buff[0] = 0x01;
1006 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1006 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1007 1, 0x21, 0x0100, 0x80 1007 1, 0x21, 0x0100, 0x8001, &com_buff, 1);
1008 1008
1009 /* Mute the hardware loopbacks to sta 1009 /* Mute the hardware loopbacks to start the device in a known state. */
1010 com_buff[0] = 0x00; 1010 com_buff[0] = 0x00;
1011 com_buff[1] = 0x80; 1011 com_buff[1] = 0x80;
1012 /* Analogue input 1 left channel: */ 1012 /* Analogue input 1 left channel: */
1013 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1013 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1014 1, 0x21, 0x0110, 0x40 1014 1, 0x21, 0x0110, 0x4001, &com_buff, 2);
1015 /* Analogue input 1 right channel: */ 1015 /* Analogue input 1 right channel: */
1016 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1016 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1017 1, 0x21, 0x0111, 0x40 1017 1, 0x21, 0x0111, 0x4001, &com_buff, 2);
1018 /* Analogue input 2 left channel: */ 1018 /* Analogue input 2 left channel: */
1019 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1019 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1020 1, 0x21, 0x0114, 0x40 1020 1, 0x21, 0x0114, 0x4001, &com_buff, 2);
1021 /* Analogue input 2 right channel: */ 1021 /* Analogue input 2 right channel: */
1022 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1022 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1023 1, 0x21, 0x0115, 0x40 1023 1, 0x21, 0x0115, 0x4001, &com_buff, 2);
1024 /* Analogue input 3 left channel: */ 1024 /* Analogue input 3 left channel: */
1025 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1025 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1026 1, 0x21, 0x0118, 0x40 1026 1, 0x21, 0x0118, 0x4001, &com_buff, 2);
1027 /* Analogue input 3 right channel: */ 1027 /* Analogue input 3 right channel: */
1028 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1028 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1029 1, 0x21, 0x0119, 0x40 1029 1, 0x21, 0x0119, 0x4001, &com_buff, 2);
1030 /* Analogue input 4 left channel: */ 1030 /* Analogue input 4 left channel: */
1031 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1031 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1032 1, 0x21, 0x011c, 0x40 1032 1, 0x21, 0x011c, 0x4001, &com_buff, 2);
1033 /* Analogue input 4 right channel: */ 1033 /* Analogue input 4 right channel: */
1034 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1034 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1035 1, 0x21, 0x011d, 0x40 1035 1, 0x21, 0x011d, 0x4001, &com_buff, 2);
1036 1036
1037 /* Set software sends to output */ 1037 /* Set software sends to output */
1038 com_buff[0] = 0x00; 1038 com_buff[0] = 0x00;
1039 com_buff[1] = 0x00; 1039 com_buff[1] = 0x00;
1040 /* Analogue software return 1 left ch 1040 /* Analogue software return 1 left channel: */
1041 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1041 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1042 1, 0x21, 0x0100, 0x40 1042 1, 0x21, 0x0100, 0x4001, &com_buff, 2);
1043 com_buff[0] = 0x00; 1043 com_buff[0] = 0x00;
1044 com_buff[1] = 0x80; 1044 com_buff[1] = 0x80;
1045 /* Analogue software return 1 right c 1045 /* Analogue software return 1 right channel: */
1046 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1046 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1047 1, 0x21, 0x0101, 0x40 1047 1, 0x21, 0x0101, 0x4001, &com_buff, 2);
1048 com_buff[0] = 0x00; 1048 com_buff[0] = 0x00;
1049 com_buff[1] = 0x80; 1049 com_buff[1] = 0x80;
1050 /* Analogue software return 2 left ch 1050 /* Analogue software return 2 left channel: */
1051 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1051 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1052 1, 0x21, 0x0104, 0x40 1052 1, 0x21, 0x0104, 0x4001, &com_buff, 2);
1053 com_buff[0] = 0x00; 1053 com_buff[0] = 0x00;
1054 com_buff[1] = 0x00; 1054 com_buff[1] = 0x00;
1055 /* Analogue software return 2 right c 1055 /* Analogue software return 2 right channel: */
1056 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1056 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1057 1, 0x21, 0x0105, 0x40 1057 1, 0x21, 0x0105, 0x4001, &com_buff, 2);
1058 1058
1059 com_buff[0] = 0x00; 1059 com_buff[0] = 0x00;
1060 com_buff[1] = 0x80; 1060 com_buff[1] = 0x80;
1061 /* Analogue software return 3 left ch 1061 /* Analogue software return 3 left channel: */
1062 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1062 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1063 1, 0x21, 0x0108, 0x40 1063 1, 0x21, 0x0108, 0x4001, &com_buff, 2);
1064 /* Analogue software return 3 right c 1064 /* Analogue software return 3 right channel: */
1065 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1065 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1066 1, 0x21, 0x0109, 0x40 1066 1, 0x21, 0x0109, 0x4001, &com_buff, 2);
1067 /* Analogue software return 4 left ch 1067 /* Analogue software return 4 left channel: */
1068 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1068 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1069 1, 0x21, 0x010c, 0x40 1069 1, 0x21, 0x010c, 0x4001, &com_buff, 2);
1070 /* Analogue software return 4 right c 1070 /* Analogue software return 4 right channel: */
1071 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1071 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1072 1, 0x21, 0x010d, 0x40 1072 1, 0x21, 0x010d, 0x4001, &com_buff, 2);
1073 1073
1074 /* Return to muting sends */ 1074 /* Return to muting sends */
1075 com_buff[0] = 0x00; 1075 com_buff[0] = 0x00;
1076 com_buff[1] = 0x80; 1076 com_buff[1] = 0x80;
1077 /* Analogue fx return left channel: * 1077 /* Analogue fx return left channel: */
1078 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1078 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1079 1, 0x21, 0x0120, 0x40 1079 1, 0x21, 0x0120, 0x4001, &com_buff, 2);
1080 /* Analogue fx return right channel: 1080 /* Analogue fx return right channel: */
1081 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1081 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1082 1, 0x21, 0x0121, 0x40 1082 1, 0x21, 0x0121, 0x4001, &com_buff, 2);
1083 1083
1084 /* Analogue software input 1 fx send: 1084 /* Analogue software input 1 fx send: */
1085 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1085 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1086 1, 0x21, 0x0100, 0x42 1086 1, 0x21, 0x0100, 0x4201, &com_buff, 2);
1087 /* Analogue software input 2 fx send: 1087 /* Analogue software input 2 fx send: */
1088 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1088 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1089 1, 0x21, 0x0101, 0x42 1089 1, 0x21, 0x0101, 0x4201, &com_buff, 2);
1090 /* Analogue software input 3 fx send: 1090 /* Analogue software input 3 fx send: */
1091 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1091 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1092 1, 0x21, 0x0102, 0x42 1092 1, 0x21, 0x0102, 0x4201, &com_buff, 2);
1093 /* Analogue software input 4 fx send: 1093 /* Analogue software input 4 fx send: */
1094 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1094 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1095 1, 0x21, 0x0103, 0x42 1095 1, 0x21, 0x0103, 0x4201, &com_buff, 2);
1096 /* Analogue input 1 fx send: */ 1096 /* Analogue input 1 fx send: */
1097 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1097 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1098 1, 0x21, 0x0104, 0x42 1098 1, 0x21, 0x0104, 0x4201, &com_buff, 2);
1099 /* Analogue input 2 fx send: */ 1099 /* Analogue input 2 fx send: */
1100 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1100 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1101 1, 0x21, 0x0105, 0x42 1101 1, 0x21, 0x0105, 0x4201, &com_buff, 2);
1102 /* Analogue input 3 fx send: */ 1102 /* Analogue input 3 fx send: */
1103 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1103 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1104 1, 0x21, 0x0106, 0x42 1104 1, 0x21, 0x0106, 0x4201, &com_buff, 2);
1105 /* Analogue input 4 fx send: */ 1105 /* Analogue input 4 fx send: */
1106 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1106 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1107 1, 0x21, 0x0107, 0x42 1107 1, 0x21, 0x0107, 0x4201, &com_buff, 2);
1108 1108
1109 /* Toggle allowing host control */ 1109 /* Toggle allowing host control */
1110 /* Not needed 1110 /* Not needed
1111 com_buff[0] = 0x02; 1111 com_buff[0] = 0x02;
1112 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1112 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1113 3, 0x21, 0x0000, 0x20 1113 3, 0x21, 0x0000, 0x2001, &com_buff, 1);
1114 */ 1114 */
1115 1115
1116 /* Do not dim fx returns */ 1116 /* Do not dim fx returns */
1117 com_buff[0] = 0x00; 1117 com_buff[0] = 0x00;
1118 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1118 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1119 3, 0x21, 0x0002, 0x20 1119 3, 0x21, 0x0002, 0x2001, &com_buff, 1);
1120 1120
1121 /* Do not set fx returns to mono */ 1121 /* Do not set fx returns to mono */
1122 com_buff[0] = 0x00; 1122 com_buff[0] = 0x00;
1123 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1123 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1124 3, 0x21, 0x0001, 0x20 1124 3, 0x21, 0x0001, 0x2001, &com_buff, 1);
1125 1125
1126 /* Mute the S/PDIF hardware loopback 1126 /* Mute the S/PDIF hardware loopback
1127 * same odd volume logic here as abov 1127 * same odd volume logic here as above
1128 */ 1128 */
1129 com_buff[0] = 0x00; 1129 com_buff[0] = 0x00;
1130 com_buff[1] = 0x80; 1130 com_buff[1] = 0x80;
1131 /* S/PDIF hardware input 1 left chann 1131 /* S/PDIF hardware input 1 left channel */
1132 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1132 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1133 1, 0x21, 0x0112, 0x40 1133 1, 0x21, 0x0112, 0x4001, &com_buff, 2);
1134 /* S/PDIF hardware input 1 right chan 1134 /* S/PDIF hardware input 1 right channel */
1135 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1135 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1136 1, 0x21, 0x0113, 0x40 1136 1, 0x21, 0x0113, 0x4001, &com_buff, 2);
1137 /* S/PDIF hardware input 2 left chann 1137 /* S/PDIF hardware input 2 left channel */
1138 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1138 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1139 1, 0x21, 0x0116, 0x40 1139 1, 0x21, 0x0116, 0x4001, &com_buff, 2);
1140 /* S/PDIF hardware input 2 right chan 1140 /* S/PDIF hardware input 2 right channel */
1141 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1141 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1142 1, 0x21, 0x0117, 0x40 1142 1, 0x21, 0x0117, 0x4001, &com_buff, 2);
1143 /* S/PDIF hardware input 3 left chann 1143 /* S/PDIF hardware input 3 left channel */
1144 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1144 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1145 1, 0x21, 0x011a, 0x40 1145 1, 0x21, 0x011a, 0x4001, &com_buff, 2);
1146 /* S/PDIF hardware input 3 right chan 1146 /* S/PDIF hardware input 3 right channel */
1147 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1147 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1148 1, 0x21, 0x011b, 0x40 1148 1, 0x21, 0x011b, 0x4001, &com_buff, 2);
1149 /* S/PDIF hardware input 4 left chann 1149 /* S/PDIF hardware input 4 left channel */
1150 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1150 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1151 1, 0x21, 0x011e, 0x40 1151 1, 0x21, 0x011e, 0x4001, &com_buff, 2);
1152 /* S/PDIF hardware input 4 right chan 1152 /* S/PDIF hardware input 4 right channel */
1153 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1153 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1154 1, 0x21, 0x011f, 0x40 1154 1, 0x21, 0x011f, 0x4001, &com_buff, 2);
1155 /* S/PDIF software return 1 left chan 1155 /* S/PDIF software return 1 left channel */
1156 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1156 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1157 1, 0x21, 0x0102, 0x40 1157 1, 0x21, 0x0102, 0x4001, &com_buff, 2);
1158 /* S/PDIF software return 1 right cha 1158 /* S/PDIF software return 1 right channel */
1159 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1159 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1160 1, 0x21, 0x0103, 0x40 1160 1, 0x21, 0x0103, 0x4001, &com_buff, 2);
1161 /* S/PDIF software return 2 left chan 1161 /* S/PDIF software return 2 left channel */
1162 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1162 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1163 1, 0x21, 0x0106, 0x40 1163 1, 0x21, 0x0106, 0x4001, &com_buff, 2);
1164 /* S/PDIF software return 2 right cha 1164 /* S/PDIF software return 2 right channel */
1165 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1165 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1166 1, 0x21, 0x0107, 0x40 1166 1, 0x21, 0x0107, 0x4001, &com_buff, 2);
1167 1167
1168 com_buff[0] = 0x00; 1168 com_buff[0] = 0x00;
1169 com_buff[1] = 0x00; 1169 com_buff[1] = 0x00;
1170 /* S/PDIF software return 3 left chan 1170 /* S/PDIF software return 3 left channel */
1171 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1171 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1172 1, 0x21, 0x010a, 0x40 1172 1, 0x21, 0x010a, 0x4001, &com_buff, 2);
1173 1173
1174 com_buff[0] = 0x00; 1174 com_buff[0] = 0x00;
1175 com_buff[1] = 0x80; 1175 com_buff[1] = 0x80;
1176 /* S/PDIF software return 3 right cha 1176 /* S/PDIF software return 3 right channel */
1177 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1177 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1178 1, 0x21, 0x010b, 0x40 1178 1, 0x21, 0x010b, 0x4001, &com_buff, 2);
1179 /* S/PDIF software return 4 left chan 1179 /* S/PDIF software return 4 left channel */
1180 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1180 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1181 1, 0x21, 0x010e, 0x40 1181 1, 0x21, 0x010e, 0x4001, &com_buff, 2);
1182 1182
1183 com_buff[0] = 0x00; 1183 com_buff[0] = 0x00;
1184 com_buff[1] = 0x00; 1184 com_buff[1] = 0x00;
1185 /* S/PDIF software return 4 right cha 1185 /* S/PDIF software return 4 right channel */
1186 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1186 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1187 1, 0x21, 0x010f, 0x40 1187 1, 0x21, 0x010f, 0x4001, &com_buff, 2);
1188 1188
1189 com_buff[0] = 0x00; 1189 com_buff[0] = 0x00;
1190 com_buff[1] = 0x80; 1190 com_buff[1] = 0x80;
1191 /* S/PDIF fx returns left channel */ 1191 /* S/PDIF fx returns left channel */
1192 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1192 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1193 1, 0x21, 0x0122, 0x40 1193 1, 0x21, 0x0122, 0x4001, &com_buff, 2);
1194 /* S/PDIF fx returns right channel */ 1194 /* S/PDIF fx returns right channel */
1195 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1195 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1196 1, 0x21, 0x0123, 0x40 1196 1, 0x21, 0x0123, 0x4001, &com_buff, 2);
1197 1197
1198 /* Set the dropdown "Effect" to the f 1198 /* Set the dropdown "Effect" to the first option */
1199 /* Room1 = 0x00 */ 1199 /* Room1 = 0x00 */
1200 /* Room2 = 0x01 */ 1200 /* Room2 = 0x01 */
1201 /* Room3 = 0x02 */ 1201 /* Room3 = 0x02 */
1202 /* Hall 1 = 0x03 */ 1202 /* Hall 1 = 0x03 */
1203 /* Hall 2 = 0x04 */ 1203 /* Hall 2 = 0x04 */
1204 /* Plate = 0x05 */ 1204 /* Plate = 0x05 */
1205 /* Delay = 0x06 */ 1205 /* Delay = 0x06 */
1206 /* Echo = 0x07 */ 1206 /* Echo = 0x07 */
1207 com_buff[0] = 0x00; 1207 com_buff[0] = 0x00;
1208 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1208 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1209 1, 0x21, 0x0200, 0x43 1209 1, 0x21, 0x0200, 0x4301, &com_buff, 1); /* max is 0xff */
1210 /* min is 0x00 */ 1210 /* min is 0x00 */
1211 1211
1212 1212
1213 /* Set the effect duration to 0 */ 1213 /* Set the effect duration to 0 */
1214 /* max is 0xffff */ 1214 /* max is 0xffff */
1215 /* min is 0x0000 */ 1215 /* min is 0x0000 */
1216 com_buff[0] = 0x00; 1216 com_buff[0] = 0x00;
1217 com_buff[1] = 0x00; 1217 com_buff[1] = 0x00;
1218 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1218 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1219 1, 0x21, 0x0400, 0x43 1219 1, 0x21, 0x0400, 0x4301, &com_buff, 2);
1220 1220
1221 /* Set the effect volume and feedback 1221 /* Set the effect volume and feedback to 0 */
1222 /* max is 0xff */ 1222 /* max is 0xff */
1223 /* min is 0x00 */ 1223 /* min is 0x00 */
1224 com_buff[0] = 0x00; 1224 com_buff[0] = 0x00;
1225 /* feedback: */ 1225 /* feedback: */
1226 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1226 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1227 1, 0x21, 0x0500, 0x43 1227 1, 0x21, 0x0500, 0x4301, &com_buff, 1);
1228 /* volume: */ 1228 /* volume: */
1229 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1229 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1230 1, 0x21, 0x0300, 0x43 1230 1, 0x21, 0x0300, 0x4301, &com_buff, 1);
1231 1231
1232 /* Set soft button hold duration */ 1232 /* Set soft button hold duration */
1233 /* 0x03 = 250ms */ 1233 /* 0x03 = 250ms */
1234 /* 0x05 = 500ms DEFAULT */ 1234 /* 0x05 = 500ms DEFAULT */
1235 /* 0x08 = 750ms */ 1235 /* 0x08 = 750ms */
1236 /* 0x0a = 1sec */ 1236 /* 0x0a = 1sec */
1237 com_buff[0] = 0x05; 1237 com_buff[0] = 0x05;
1238 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1238 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1239 3, 0x21, 0x0005, 0x20 1239 3, 0x21, 0x0005, 0x2001, &com_buff, 1);
1240 1240
1241 /* Use dim LEDs for button of state * 1241 /* Use dim LEDs for button of state */
1242 com_buff[0] = 0x00; 1242 com_buff[0] = 0x00;
1243 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1243 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1244 3, 0x21, 0x0004, 0x20 1244 3, 0x21, 0x0004, 0x2001, &com_buff, 1);
1245 } 1245 }
1246 1246
1247 #define MBOX3_DESCRIPTOR_SIZE 464 1247 #define MBOX3_DESCRIPTOR_SIZE 464
1248 1248
1249 static int snd_usb_mbox3_boot_quirk(struct us 1249 static int snd_usb_mbox3_boot_quirk(struct usb_device *dev)
1250 { 1250 {
1251 struct usb_host_config *config = dev- 1251 struct usb_host_config *config = dev->actconfig;
1252 int err; 1252 int err;
1253 int descriptor_size; 1253 int descriptor_size;
1254 1254
1255 descriptor_size = le16_to_cpu(get_cfg 1255 descriptor_size = le16_to_cpu(get_cfg_desc(config)->wTotalLength);
1256 1256
1257 if (descriptor_size != MBOX3_DESCRIPT 1257 if (descriptor_size != MBOX3_DESCRIPTOR_SIZE) {
1258 dev_err(&dev->dev, "MBOX3: In 1258 dev_err(&dev->dev, "MBOX3: Invalid descriptor size=%d.\n", descriptor_size);
1259 return -ENODEV; 1259 return -ENODEV;
1260 } 1260 }
1261 1261
1262 dev_dbg(&dev->dev, "MBOX3: device ini 1262 dev_dbg(&dev->dev, "MBOX3: device initialised!\n");
1263 1263
1264 err = usb_get_descriptor(dev, USB_DT_ 1264 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
1265 &dev->descriptor, sizeof(dev- 1265 &dev->descriptor, sizeof(dev->descriptor));
1266 config = dev->actconfig; 1266 config = dev->actconfig;
1267 if (err < 0) 1267 if (err < 0)
1268 dev_dbg(&dev->dev, "MBOX3: er 1268 dev_dbg(&dev->dev, "MBOX3: error usb_get_descriptor: %d\n", err);
1269 1269
1270 err = usb_reset_configuration(dev); 1270 err = usb_reset_configuration(dev);
1271 if (err < 0) 1271 if (err < 0)
1272 dev_dbg(&dev->dev, "MBOX3: er 1272 dev_dbg(&dev->dev, "MBOX3: error usb_reset_configuration: %d\n", err);
1273 1273
1274 dev_dbg(&dev->dev, "MBOX3: new boot l 1274 dev_dbg(&dev->dev, "MBOX3: new boot length = %d\n",
1275 le16_to_cpu(get_cfg_desc(conf 1275 le16_to_cpu(get_cfg_desc(config)->wTotalLength));
1276 1276
1277 mbox3_setup_defaults(dev); 1277 mbox3_setup_defaults(dev);
1278 dev_info(&dev->dev, "MBOX3: Initializ 1278 dev_info(&dev->dev, "MBOX3: Initialized.");
1279 1279
1280 return 0; /* Successful boot */ 1280 return 0; /* Successful boot */
1281 } 1281 }
1282 1282
1283 #define MICROBOOK_BUF_SIZE 128 1283 #define MICROBOOK_BUF_SIZE 128
1284 1284
1285 static int snd_usb_motu_microbookii_communica 1285 static int snd_usb_motu_microbookii_communicate(struct usb_device *dev, u8 *buf,
1286 1286 int buf_size, int *length)
1287 { 1287 {
1288 int err, actual_length; 1288 int err, actual_length;
1289 1289
1290 if (usb_pipe_type_check(dev, usb_sndi 1290 if (usb_pipe_type_check(dev, usb_sndintpipe(dev, 0x01)))
1291 return -EINVAL; 1291 return -EINVAL;
1292 err = usb_interrupt_msg(dev, usb_sndi 1292 err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x01), buf, *length,
1293 &actual_lengt 1293 &actual_length, 1000);
1294 if (err < 0) 1294 if (err < 0)
1295 return err; 1295 return err;
1296 1296
1297 print_hex_dump(KERN_DEBUG, "MicroBook 1297 print_hex_dump(KERN_DEBUG, "MicroBookII snd: ", DUMP_PREFIX_NONE, 16, 1,
1298 buf, actual_length, fa 1298 buf, actual_length, false);
1299 1299
1300 memset(buf, 0, buf_size); 1300 memset(buf, 0, buf_size);
1301 1301
1302 if (usb_pipe_type_check(dev, usb_rcvi 1302 if (usb_pipe_type_check(dev, usb_rcvintpipe(dev, 0x82)))
1303 return -EINVAL; 1303 return -EINVAL;
1304 err = usb_interrupt_msg(dev, usb_rcvi 1304 err = usb_interrupt_msg(dev, usb_rcvintpipe(dev, 0x82), buf, buf_size,
1305 &actual_lengt 1305 &actual_length, 1000);
1306 if (err < 0) 1306 if (err < 0)
1307 return err; 1307 return err;
1308 1308
1309 print_hex_dump(KERN_DEBUG, "MicroBook 1309 print_hex_dump(KERN_DEBUG, "MicroBookII rcv: ", DUMP_PREFIX_NONE, 16, 1,
1310 buf, actual_length, fa 1310 buf, actual_length, false);
1311 1311
1312 *length = actual_length; 1312 *length = actual_length;
1313 return 0; 1313 return 0;
1314 } 1314 }
1315 1315
1316 static int snd_usb_motu_microbookii_boot_quir 1316 static int snd_usb_motu_microbookii_boot_quirk(struct usb_device *dev)
1317 { 1317 {
1318 int err, actual_length, poll_attempts 1318 int err, actual_length, poll_attempts = 0;
1319 static const u8 set_samplerate_seq[] 1319 static const u8 set_samplerate_seq[] = { 0x00, 0x00, 0x00, 0x00,
1320 1320 0x00, 0x00, 0x0b, 0x14,
1321 1321 0x00, 0x00, 0x00, 0x01 };
1322 static const u8 poll_ready_seq[] = { 1322 static const u8 poll_ready_seq[] = { 0x00, 0x04, 0x00, 0x00,
1323 1323 0x00, 0x00, 0x0b, 0x18 };
1324 u8 *buf = kzalloc(MICROBOOK_BUF_SIZE, 1324 u8 *buf = kzalloc(MICROBOOK_BUF_SIZE, GFP_KERNEL);
1325 1325
1326 if (!buf) 1326 if (!buf)
1327 return -ENOMEM; 1327 return -ENOMEM;
1328 1328
1329 dev_info(&dev->dev, "Waiting for MOTU 1329 dev_info(&dev->dev, "Waiting for MOTU Microbook II to boot up...\n");
1330 1330
1331 /* First we tell the device which sam 1331 /* First we tell the device which sample rate to use. */
1332 memcpy(buf, set_samplerate_seq, sizeo 1332 memcpy(buf, set_samplerate_seq, sizeof(set_samplerate_seq));
1333 actual_length = sizeof(set_samplerate 1333 actual_length = sizeof(set_samplerate_seq);
1334 err = snd_usb_motu_microbookii_commun 1334 err = snd_usb_motu_microbookii_communicate(dev, buf, MICROBOOK_BUF_SIZE,
1335 1335 &actual_length);
1336 1336
1337 if (err < 0) { 1337 if (err < 0) {
1338 dev_err(&dev->dev, 1338 dev_err(&dev->dev,
1339 "failed setting the s 1339 "failed setting the sample rate for Motu MicroBook II: %d\n",
1340 err); 1340 err);
1341 goto free_buf; 1341 goto free_buf;
1342 } 1342 }
1343 1343
1344 /* Then we poll every 100 ms until th 1344 /* Then we poll every 100 ms until the device informs of its readiness. */
1345 while (true) { 1345 while (true) {
1346 if (++poll_attempts > 100) { 1346 if (++poll_attempts > 100) {
1347 dev_err(&dev->dev, 1347 dev_err(&dev->dev,
1348 "failed booti 1348 "failed booting Motu MicroBook II: timeout\n");
1349 err = -ENODEV; 1349 err = -ENODEV;
1350 goto free_buf; 1350 goto free_buf;
1351 } 1351 }
1352 1352
1353 memset(buf, 0, MICROBOOK_BUF_ 1353 memset(buf, 0, MICROBOOK_BUF_SIZE);
1354 memcpy(buf, poll_ready_seq, s 1354 memcpy(buf, poll_ready_seq, sizeof(poll_ready_seq));
1355 1355
1356 actual_length = sizeof(poll_r 1356 actual_length = sizeof(poll_ready_seq);
1357 err = snd_usb_motu_microbooki 1357 err = snd_usb_motu_microbookii_communicate(
1358 dev, buf, MICROBOOK_B 1358 dev, buf, MICROBOOK_BUF_SIZE, &actual_length);
1359 if (err < 0) { 1359 if (err < 0) {
1360 dev_err(&dev->dev, 1360 dev_err(&dev->dev,
1361 "failed booti 1361 "failed booting Motu MicroBook II: communication error %d\n",
1362 err); 1362 err);
1363 goto free_buf; 1363 goto free_buf;
1364 } 1364 }
1365 1365
1366 /* the device signals its rea 1366 /* the device signals its readiness through a message of the
1367 * form 1367 * form
1368 * XX 06 00 00 00 0 1368 * XX 06 00 00 00 00 0b 18 00 00 00 01
1369 * If the device is not yet r 1369 * If the device is not yet ready to accept audio data, the
1370 * last byte of that sequence 1370 * last byte of that sequence is 00.
1371 */ 1371 */
1372 if (actual_length == 12 && bu 1372 if (actual_length == 12 && buf[actual_length - 1] == 1)
1373 break; 1373 break;
1374 1374
1375 msleep(100); 1375 msleep(100);
1376 } 1376 }
1377 1377
1378 dev_info(&dev->dev, "MOTU MicroBook I 1378 dev_info(&dev->dev, "MOTU MicroBook II ready\n");
1379 1379
1380 free_buf: 1380 free_buf:
1381 kfree(buf); 1381 kfree(buf);
1382 return err; 1382 return err;
1383 } 1383 }
1384 1384
1385 static int snd_usb_motu_m_series_boot_quirk(s 1385 static int snd_usb_motu_m_series_boot_quirk(struct usb_device *dev)
1386 { 1386 {
1387 msleep(4000); 1387 msleep(4000);
1388 1388
1389 return 0; 1389 return 0;
1390 } 1390 }
1391 1391
1392 static int snd_usb_rme_digiface_boot_quirk(st 1392 static int snd_usb_rme_digiface_boot_quirk(struct usb_device *dev)
1393 { 1393 {
1394 /* Disable mixer, internal clock, all 1394 /* Disable mixer, internal clock, all outputs ADAT, 48kHz, TMS off */
1395 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1395 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1396 16, 0x40, 0x2410, 0x7 1396 16, 0x40, 0x2410, 0x7fff, NULL, 0);
1397 snd_usb_ctl_msg(dev, usb_sndctrlpipe( 1397 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1398 18, 0x40, 0x0104, 0xf 1398 18, 0x40, 0x0104, 0xffff, NULL, 0);
1399 1399
1400 /* Disable loopback for all inputs */ 1400 /* Disable loopback for all inputs */
1401 for (int ch = 0; ch < 32; ch++) 1401 for (int ch = 0; ch < 32; ch++)
1402 snd_usb_ctl_msg(dev, usb_sndc 1402 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1403 22, 0x40, 0x4 1403 22, 0x40, 0x400, ch, NULL, 0);
1404 1404
1405 /* Unity gain for all outputs */ 1405 /* Unity gain for all outputs */
1406 for (int ch = 0; ch < 34; ch++) 1406 for (int ch = 0; ch < 34; ch++)
1407 snd_usb_ctl_msg(dev, usb_sndc 1407 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1408 21, 0x40, 0x9 1408 21, 0x40, 0x9000, 0x100 + ch, NULL, 0);
1409 1409
1410 return 0; 1410 return 0;
1411 } 1411 }
1412 1412
1413 /* 1413 /*
1414 * Setup quirks 1414 * Setup quirks
1415 */ 1415 */
1416 #define MAUDIO_SET 0x01 /* parse 1416 #define MAUDIO_SET 0x01 /* parse device_setup */
1417 #define MAUDIO_SET_COMPATIBLE 0x80 /* use o 1417 #define MAUDIO_SET_COMPATIBLE 0x80 /* use only "win-compatible" interfaces */
1418 #define MAUDIO_SET_DTS 0x02 /* enabl 1418 #define MAUDIO_SET_DTS 0x02 /* enable DTS Digital Output */
1419 #define MAUDIO_SET_96K 0x04 /* 48-96 1419 #define MAUDIO_SET_96K 0x04 /* 48-96kHz rate if set, 8-48kHz otherwise */
1420 #define MAUDIO_SET_24B 0x08 /* 24bit 1420 #define MAUDIO_SET_24B 0x08 /* 24bits sample if set, 16bits otherwise */
1421 #define MAUDIO_SET_DI 0x10 /* enabl 1421 #define MAUDIO_SET_DI 0x10 /* enable Digital Input */
1422 #define MAUDIO_SET_MASK 0x1f /* bit m 1422 #define MAUDIO_SET_MASK 0x1f /* bit mask for setup value */
1423 #define MAUDIO_SET_24B_48K_DI 0x19 /* 24bi 1423 #define MAUDIO_SET_24B_48K_DI 0x19 /* 24bits+48kHz+Digital Input */
1424 #define MAUDIO_SET_24B_48K_NOTDI 0x09 /* 24bi 1424 #define MAUDIO_SET_24B_48K_NOTDI 0x09 /* 24bits+48kHz+No Digital Input */
1425 #define MAUDIO_SET_16B_48K_DI 0x11 /* 16bi 1425 #define MAUDIO_SET_16B_48K_DI 0x11 /* 16bits+48kHz+Digital Input */
1426 #define MAUDIO_SET_16B_48K_NOTDI 0x01 /* 16bi 1426 #define MAUDIO_SET_16B_48K_NOTDI 0x01 /* 16bits+48kHz+No Digital Input */
1427 1427
1428 static int quattro_skip_setting_quirk(struct 1428 static int quattro_skip_setting_quirk(struct snd_usb_audio *chip,
1429 int ifa 1429 int iface, int altno)
1430 { 1430 {
1431 /* Reset ALL ifaces to 0 altsetting. 1431 /* Reset ALL ifaces to 0 altsetting.
1432 * Call it for every possible altsett 1432 * Call it for every possible altsetting of every interface.
1433 */ 1433 */
1434 usb_set_interface(chip->dev, iface, 0 1434 usb_set_interface(chip->dev, iface, 0);
1435 if (chip->setup & MAUDIO_SET) { 1435 if (chip->setup & MAUDIO_SET) {
1436 if (chip->setup & MAUDIO_SET_ 1436 if (chip->setup & MAUDIO_SET_COMPATIBLE) {
1437 if (iface != 1 && ifa 1437 if (iface != 1 && iface != 2)
1438 return 1; /* 1438 return 1; /* skip all interfaces but 1 and 2 */
1439 } else { 1439 } else {
1440 unsigned int mask; 1440 unsigned int mask;
1441 if (iface == 1 || ifa 1441 if (iface == 1 || iface == 2)
1442 return 1; /* 1442 return 1; /* skip interfaces 1 and 2 */
1443 if ((chip->setup & MA 1443 if ((chip->setup & MAUDIO_SET_96K) && altno != 1)
1444 return 1; /* 1444 return 1; /* skip this altsetting */
1445 mask = chip->setup & 1445 mask = chip->setup & MAUDIO_SET_MASK;
1446 if (mask == MAUDIO_SE 1446 if (mask == MAUDIO_SET_24B_48K_DI && altno != 2)
1447 return 1; /* 1447 return 1; /* skip this altsetting */
1448 if (mask == MAUDIO_SE 1448 if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3)
1449 return 1; /* 1449 return 1; /* skip this altsetting */
1450 if (mask == MAUDIO_SE 1450 if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 4)
1451 return 1; /* 1451 return 1; /* skip this altsetting */
1452 } 1452 }
1453 } 1453 }
1454 usb_audio_dbg(chip, 1454 usb_audio_dbg(chip,
1455 "using altsetting %d for 1455 "using altsetting %d for interface %d config %d\n",
1456 altno, iface, chip->setup 1456 altno, iface, chip->setup);
1457 return 0; /* keep this altsetting */ 1457 return 0; /* keep this altsetting */
1458 } 1458 }
1459 1459
1460 static int audiophile_skip_setting_quirk(stru 1460 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
1461 int 1461 int iface,
1462 int 1462 int altno)
1463 { 1463 {
1464 /* Reset ALL ifaces to 0 altsetting. 1464 /* Reset ALL ifaces to 0 altsetting.
1465 * Call it for every possible altsett 1465 * Call it for every possible altsetting of every interface.
1466 */ 1466 */
1467 usb_set_interface(chip->dev, iface, 0 1467 usb_set_interface(chip->dev, iface, 0);
1468 1468
1469 if (chip->setup & MAUDIO_SET) { 1469 if (chip->setup & MAUDIO_SET) {
1470 unsigned int mask; 1470 unsigned int mask;
1471 if ((chip->setup & MAUDIO_SET 1471 if ((chip->setup & MAUDIO_SET_DTS) && altno != 6)
1472 return 1; /* skip thi 1472 return 1; /* skip this altsetting */
1473 if ((chip->setup & MAUDIO_SET 1473 if ((chip->setup & MAUDIO_SET_96K) && altno != 1)
1474 return 1; /* skip thi 1474 return 1; /* skip this altsetting */
1475 mask = chip->setup & MAUDIO_S 1475 mask = chip->setup & MAUDIO_SET_MASK;
1476 if (mask == MAUDIO_SET_24B_48 1476 if (mask == MAUDIO_SET_24B_48K_DI && altno != 2)
1477 return 1; /* skip thi 1477 return 1; /* skip this altsetting */
1478 if (mask == MAUDIO_SET_24B_48 1478 if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3)
1479 return 1; /* skip thi 1479 return 1; /* skip this altsetting */
1480 if (mask == MAUDIO_SET_16B_48 1480 if (mask == MAUDIO_SET_16B_48K_DI && altno != 4)
1481 return 1; /* skip thi 1481 return 1; /* skip this altsetting */
1482 if (mask == MAUDIO_SET_16B_48 1482 if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 5)
1483 return 1; /* skip thi 1483 return 1; /* skip this altsetting */
1484 } 1484 }
1485 1485
1486 return 0; /* keep this altsetting */ 1486 return 0; /* keep this altsetting */
1487 } 1487 }
1488 1488
1489 static int fasttrackpro_skip_setting_quirk(st 1489 static int fasttrackpro_skip_setting_quirk(struct snd_usb_audio *chip,
1490 in 1490 int iface, int altno)
1491 { 1491 {
1492 /* Reset ALL ifaces to 0 altsetting. 1492 /* Reset ALL ifaces to 0 altsetting.
1493 * Call it for every possible altsett 1493 * Call it for every possible altsetting of every interface.
1494 */ 1494 */
1495 usb_set_interface(chip->dev, iface, 0 1495 usb_set_interface(chip->dev, iface, 0);
1496 1496
1497 /* possible configuration where both 1497 /* possible configuration where both inputs and only one output is
1498 *used is not supported by the curren 1498 *used is not supported by the current setup
1499 */ 1499 */
1500 if (chip->setup & (MAUDIO_SET | MAUDI 1500 if (chip->setup & (MAUDIO_SET | MAUDIO_SET_24B)) {
1501 if (chip->setup & MAUDIO_SET_ 1501 if (chip->setup & MAUDIO_SET_96K) {
1502 if (altno != 3 && alt 1502 if (altno != 3 && altno != 6)
1503 return 1; 1503 return 1;
1504 } else if (chip->setup & MAUD 1504 } else if (chip->setup & MAUDIO_SET_DI) {
1505 if (iface == 4) 1505 if (iface == 4)
1506 return 1; /* 1506 return 1; /* no analog input */
1507 if (altno != 2 && alt 1507 if (altno != 2 && altno != 5)
1508 return 1; /* 1508 return 1; /* enable only altsets 2 and 5 */
1509 } else { 1509 } else {
1510 if (iface == 5) 1510 if (iface == 5)
1511 return 1; /* 1511 return 1; /* disable digialt input */
1512 if (altno != 2 && alt 1512 if (altno != 2 && altno != 5)
1513 return 1; /* 1513 return 1; /* enalbe only altsets 2 and 5 */
1514 } 1514 }
1515 } else { 1515 } else {
1516 /* keep only 16-Bit mode */ 1516 /* keep only 16-Bit mode */
1517 if (altno != 1) 1517 if (altno != 1)
1518 return 1; 1518 return 1;
1519 } 1519 }
1520 1520
1521 usb_audio_dbg(chip, 1521 usb_audio_dbg(chip,
1522 "using altsetting %d for 1522 "using altsetting %d for interface %d config %d\n",
1523 altno, iface, chip->setup 1523 altno, iface, chip->setup);
1524 return 0; /* keep this altsetting */ 1524 return 0; /* keep this altsetting */
1525 } 1525 }
1526 1526
1527 static int s1810c_skip_setting_quirk(struct s 1527 static int s1810c_skip_setting_quirk(struct snd_usb_audio *chip,
1528 in 1528 int iface, int altno)
1529 { 1529 {
1530 /* 1530 /*
1531 * Altno settings: 1531 * Altno settings:
1532 * 1532 *
1533 * Playback (Interface 1): 1533 * Playback (Interface 1):
1534 * 1: 6 Analog + 2 S/PDIF 1534 * 1: 6 Analog + 2 S/PDIF
1535 * 2: 6 Analog + 2 S/PDIF 1535 * 2: 6 Analog + 2 S/PDIF
1536 * 3: 6 Analog 1536 * 3: 6 Analog
1537 * 1537 *
1538 * Capture (Interface 2): 1538 * Capture (Interface 2):
1539 * 1: 8 Analog + 2 S/PDIF + 8 ADAT 1539 * 1: 8 Analog + 2 S/PDIF + 8 ADAT
1540 * 2: 8 Analog + 2 S/PDIF + 4 ADAT 1540 * 2: 8 Analog + 2 S/PDIF + 4 ADAT
1541 * 3: 8 Analog 1541 * 3: 8 Analog
1542 */ 1542 */
1543 1543
1544 /* 1544 /*
1545 * I'll leave 2 as the default one an 1545 * I'll leave 2 as the default one and
1546 * use device_setup to switch to the 1546 * use device_setup to switch to the
1547 * other two. 1547 * other two.
1548 */ 1548 */
1549 if ((chip->setup == 0 || chip->setup 1549 if ((chip->setup == 0 || chip->setup > 2) && altno != 2)
1550 return 1; 1550 return 1;
1551 else if (chip->setup == 1 && altno != 1551 else if (chip->setup == 1 && altno != 1)
1552 return 1; 1552 return 1;
1553 else if (chip->setup == 2 && altno != 1553 else if (chip->setup == 2 && altno != 3)
1554 return 1; 1554 return 1;
1555 1555
1556 return 0; 1556 return 0;
1557 } 1557 }
1558 1558
1559 int snd_usb_apply_interface_quirk(struct snd_ 1559 int snd_usb_apply_interface_quirk(struct snd_usb_audio *chip,
1560 int iface, 1560 int iface,
1561 int altno) 1561 int altno)
1562 { 1562 {
1563 /* audiophile usb: skip altsets incom 1563 /* audiophile usb: skip altsets incompatible with device_setup */
1564 if (chip->usb_id == USB_ID(0x0763, 0x 1564 if (chip->usb_id == USB_ID(0x0763, 0x2003))
1565 return audiophile_skip_settin 1565 return audiophile_skip_setting_quirk(chip, iface, altno);
1566 /* quattro usb: skip altsets incompat 1566 /* quattro usb: skip altsets incompatible with device_setup */
1567 if (chip->usb_id == USB_ID(0x0763, 0x 1567 if (chip->usb_id == USB_ID(0x0763, 0x2001))
1568 return quattro_skip_setting_q 1568 return quattro_skip_setting_quirk(chip, iface, altno);
1569 /* fasttrackpro usb: skip altsets inc 1569 /* fasttrackpro usb: skip altsets incompatible with device_setup */
1570 if (chip->usb_id == USB_ID(0x0763, 0x 1570 if (chip->usb_id == USB_ID(0x0763, 0x2012))
1571 return fasttrackpro_skip_sett 1571 return fasttrackpro_skip_setting_quirk(chip, iface, altno);
1572 /* presonus studio 1810c: skip altset 1572 /* presonus studio 1810c: skip altsets incompatible with device_setup */
1573 if (chip->usb_id == USB_ID(0x194f, 0x 1573 if (chip->usb_id == USB_ID(0x194f, 0x010c))
1574 return s1810c_skip_setting_qu 1574 return s1810c_skip_setting_quirk(chip, iface, altno);
1575 1575
1576 1576
1577 return 0; 1577 return 0;
1578 } 1578 }
1579 1579
1580 int snd_usb_apply_boot_quirk(struct usb_devic 1580 int snd_usb_apply_boot_quirk(struct usb_device *dev,
1581 struct usb_inter 1581 struct usb_interface *intf,
1582 const struct snd 1582 const struct snd_usb_audio_quirk *quirk,
1583 unsigned int id) 1583 unsigned int id)
1584 { 1584 {
1585 switch (id) { 1585 switch (id) {
1586 case USB_ID(0x041e, 0x3000): 1586 case USB_ID(0x041e, 0x3000):
1587 /* SB Extigy needs special bo 1587 /* SB Extigy needs special boot-up sequence */
1588 /* if more models come, this 1588 /* if more models come, this will go to the quirk list. */
1589 return snd_usb_extigy_boot_qu 1589 return snd_usb_extigy_boot_quirk(dev, intf);
1590 1590
1591 case USB_ID(0x041e, 0x3020): 1591 case USB_ID(0x041e, 0x3020):
1592 /* SB Audigy 2 NX needs its o 1592 /* SB Audigy 2 NX needs its own boot-up magic, too */
1593 return snd_usb_audigy2nx_boot 1593 return snd_usb_audigy2nx_boot_quirk(dev);
1594 1594
1595 case USB_ID(0x10f5, 0x0200): 1595 case USB_ID(0x10f5, 0x0200):
1596 /* C-Media CM106 / Turtle Bea 1596 /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */
1597 return snd_usb_cm106_boot_qui 1597 return snd_usb_cm106_boot_quirk(dev);
1598 1598
1599 case USB_ID(0x0d8c, 0x0102): 1599 case USB_ID(0x0d8c, 0x0102):
1600 /* C-Media CM6206 / CM106-Lik 1600 /* C-Media CM6206 / CM106-Like Sound Device */
1601 case USB_ID(0x0ccd, 0x00b1): /* Terra 1601 case USB_ID(0x0ccd, 0x00b1): /* Terratec Aureon 7.1 USB */
1602 return snd_usb_cm6206_boot_qu 1602 return snd_usb_cm6206_boot_quirk(dev);
1603 1603
1604 case USB_ID(0x0dba, 0x3000): 1604 case USB_ID(0x0dba, 0x3000):
1605 /* Digidesign Mbox 2 */ 1605 /* Digidesign Mbox 2 */
1606 return snd_usb_mbox2_boot_qui 1606 return snd_usb_mbox2_boot_quirk(dev);
1607 case USB_ID(0x0dba, 0x5000): 1607 case USB_ID(0x0dba, 0x5000):
1608 /* Digidesign Mbox 3 */ 1608 /* Digidesign Mbox 3 */
1609 return snd_usb_mbox3_boot_qui 1609 return snd_usb_mbox3_boot_quirk(dev);
1610 1610
1611 1611
1612 case USB_ID(0x1235, 0x0010): /* Focus 1612 case USB_ID(0x1235, 0x0010): /* Focusrite Novation Saffire 6 USB */
1613 case USB_ID(0x1235, 0x0018): /* Focus 1613 case USB_ID(0x1235, 0x0018): /* Focusrite Novation Twitch */
1614 return snd_usb_novation_boot_ 1614 return snd_usb_novation_boot_quirk(dev);
1615 1615
1616 case USB_ID(0x133e, 0x0815): 1616 case USB_ID(0x133e, 0x0815):
1617 /* Access Music VirusTI Deskt 1617 /* Access Music VirusTI Desktop */
1618 return snd_usb_accessmusic_bo 1618 return snd_usb_accessmusic_boot_quirk(dev);
1619 1619
1620 case USB_ID(0x17cc, 0x1000): /* Kompl 1620 case USB_ID(0x17cc, 0x1000): /* Komplete Audio 6 */
1621 case USB_ID(0x17cc, 0x1010): /* Trakt 1621 case USB_ID(0x17cc, 0x1010): /* Traktor Audio 6 */
1622 case USB_ID(0x17cc, 0x1020): /* Trakt 1622 case USB_ID(0x17cc, 0x1020): /* Traktor Audio 10 */
1623 return snd_usb_nativeinstrume 1623 return snd_usb_nativeinstruments_boot_quirk(dev);
1624 case USB_ID(0x0763, 0x2012): /* M-Au 1624 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */
1625 return snd_usb_fasttrackpro_b 1625 return snd_usb_fasttrackpro_boot_quirk(dev);
1626 case USB_ID(0x047f, 0xc010): /* Plant 1626 case USB_ID(0x047f, 0xc010): /* Plantronics Gamecom 780 */
1627 return snd_usb_gamecon780_boo 1627 return snd_usb_gamecon780_boot_quirk(dev);
1628 case USB_ID(0x2466, 0x8010): /* Fract 1628 case USB_ID(0x2466, 0x8010): /* Fractal Audio Axe-Fx 3 */
1629 return snd_usb_axefx3_boot_qu 1629 return snd_usb_axefx3_boot_quirk(dev);
1630 case USB_ID(0x07fd, 0x0004): /* MOTU 1630 case USB_ID(0x07fd, 0x0004): /* MOTU MicroBook II */
1631 /* 1631 /*
1632 * For some reason interface 1632 * For some reason interface 3 with vendor-spec class is
1633 * detected on MicroBook IIc. 1633 * detected on MicroBook IIc.
1634 */ 1634 */
1635 if (get_iface_desc(intf->alts 1635 if (get_iface_desc(intf->altsetting)->bInterfaceClass ==
1636 USB_CLASS_VENDOR_SPEC && 1636 USB_CLASS_VENDOR_SPEC &&
1637 get_iface_desc(intf->alts 1637 get_iface_desc(intf->altsetting)->bInterfaceNumber < 3)
1638 return snd_usb_motu_m 1638 return snd_usb_motu_microbookii_boot_quirk(dev);
1639 break; 1639 break;
1640 case USB_ID(0x2a39, 0x3f8c): /* RME D 1640 case USB_ID(0x2a39, 0x3f8c): /* RME Digiface USB */
1641 return snd_usb_rme_digiface_b 1641 return snd_usb_rme_digiface_boot_quirk(dev);
1642 } 1642 }
1643 1643
1644 return 0; 1644 return 0;
1645 } 1645 }
1646 1646
1647 int snd_usb_apply_boot_quirk_once(struct usb_ 1647 int snd_usb_apply_boot_quirk_once(struct usb_device *dev,
1648 struct usb_ 1648 struct usb_interface *intf,
1649 const struc 1649 const struct snd_usb_audio_quirk *quirk,
1650 unsigned in 1650 unsigned int id)
1651 { 1651 {
1652 switch (id) { 1652 switch (id) {
1653 case USB_ID(0x07fd, 0x0008): /* MOTU 1653 case USB_ID(0x07fd, 0x0008): /* MOTU M Series, 1st hardware version */
1654 return snd_usb_motu_m_series_ 1654 return snd_usb_motu_m_series_boot_quirk(dev);
1655 } 1655 }
1656 1656
1657 return 0; 1657 return 0;
1658 } 1658 }
1659 1659
1660 /* 1660 /*
1661 * check if the device uses big-endian sample 1661 * check if the device uses big-endian samples
1662 */ 1662 */
1663 int snd_usb_is_big_endian_format(struct snd_u 1663 int snd_usb_is_big_endian_format(struct snd_usb_audio *chip,
1664 const struct 1664 const struct audioformat *fp)
1665 { 1665 {
1666 /* it depends on altsetting whether t 1666 /* it depends on altsetting whether the device is big-endian or not */
1667 switch (chip->usb_id) { 1667 switch (chip->usb_id) {
1668 case USB_ID(0x0763, 0x2001): /* M-Aud 1668 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
1669 if (fp->altsetting == 2 || fp 1669 if (fp->altsetting == 2 || fp->altsetting == 3 ||
1670 fp->altsetting == 5 | 1670 fp->altsetting == 5 || fp->altsetting == 6)
1671 return 1; 1671 return 1;
1672 break; 1672 break;
1673 case USB_ID(0x0763, 0x2003): /* M-Aud 1673 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
1674 if (chip->setup == 0x00 || 1674 if (chip->setup == 0x00 ||
1675 fp->altsetting == 1 | 1675 fp->altsetting == 1 || fp->altsetting == 2 ||
1676 fp->altsetting == 3) 1676 fp->altsetting == 3)
1677 return 1; 1677 return 1;
1678 break; 1678 break;
1679 case USB_ID(0x0763, 0x2012): /* M-Aud 1679 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro */
1680 if (fp->altsetting == 2 || fp 1680 if (fp->altsetting == 2 || fp->altsetting == 3 ||
1681 fp->altsetting == 5 | 1681 fp->altsetting == 5 || fp->altsetting == 6)
1682 return 1; 1682 return 1;
1683 break; 1683 break;
1684 } 1684 }
1685 return 0; 1685 return 0;
1686 } 1686 }
1687 1687
1688 /* 1688 /*
1689 * For E-Mu 0404USB/0202USB/TrackerPre/0204 s 1689 * For E-Mu 0404USB/0202USB/TrackerPre/0204 sample rate should be set for device,
1690 * not for interface. 1690 * not for interface.
1691 */ 1691 */
1692 1692
1693 enum { 1693 enum {
1694 EMU_QUIRK_SR_44100HZ = 0, 1694 EMU_QUIRK_SR_44100HZ = 0,
1695 EMU_QUIRK_SR_48000HZ, 1695 EMU_QUIRK_SR_48000HZ,
1696 EMU_QUIRK_SR_88200HZ, 1696 EMU_QUIRK_SR_88200HZ,
1697 EMU_QUIRK_SR_96000HZ, 1697 EMU_QUIRK_SR_96000HZ,
1698 EMU_QUIRK_SR_176400HZ, 1698 EMU_QUIRK_SR_176400HZ,
1699 EMU_QUIRK_SR_192000HZ 1699 EMU_QUIRK_SR_192000HZ
1700 }; 1700 };
1701 1701
1702 static void set_format_emu_quirk(struct snd_u 1702 static void set_format_emu_quirk(struct snd_usb_substream *subs,
1703 const struct 1703 const struct audioformat *fmt)
1704 { 1704 {
1705 unsigned char emu_samplerate_id = 0; 1705 unsigned char emu_samplerate_id = 0;
1706 1706
1707 /* When capture is active 1707 /* When capture is active
1708 * sample rate shouldn't be changed 1708 * sample rate shouldn't be changed
1709 * by playback substream 1709 * by playback substream
1710 */ 1710 */
1711 if (subs->direction == SNDRV_PCM_STRE 1711 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
1712 if (subs->stream->substream[S 1712 if (subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE].cur_audiofmt)
1713 return; 1713 return;
1714 } 1714 }
1715 1715
1716 switch (fmt->rate_min) { 1716 switch (fmt->rate_min) {
1717 case 48000: 1717 case 48000:
1718 emu_samplerate_id = EMU_QUIRK 1718 emu_samplerate_id = EMU_QUIRK_SR_48000HZ;
1719 break; 1719 break;
1720 case 88200: 1720 case 88200:
1721 emu_samplerate_id = EMU_QUIRK 1721 emu_samplerate_id = EMU_QUIRK_SR_88200HZ;
1722 break; 1722 break;
1723 case 96000: 1723 case 96000:
1724 emu_samplerate_id = EMU_QUIRK 1724 emu_samplerate_id = EMU_QUIRK_SR_96000HZ;
1725 break; 1725 break;
1726 case 176400: 1726 case 176400:
1727 emu_samplerate_id = EMU_QUIRK 1727 emu_samplerate_id = EMU_QUIRK_SR_176400HZ;
1728 break; 1728 break;
1729 case 192000: 1729 case 192000:
1730 emu_samplerate_id = EMU_QUIRK 1730 emu_samplerate_id = EMU_QUIRK_SR_192000HZ;
1731 break; 1731 break;
1732 default: 1732 default:
1733 emu_samplerate_id = EMU_QUIRK 1733 emu_samplerate_id = EMU_QUIRK_SR_44100HZ;
1734 break; 1734 break;
1735 } 1735 }
1736 snd_emuusb_set_samplerate(subs->strea 1736 snd_emuusb_set_samplerate(subs->stream->chip, emu_samplerate_id);
1737 subs->pkt_offset_adj = (emu_samplerat 1737 subs->pkt_offset_adj = (emu_samplerate_id >= EMU_QUIRK_SR_176400HZ) ? 4 : 0;
1738 } 1738 }
1739 1739
1740 static int pioneer_djm_set_format_quirk(struc 1740 static int pioneer_djm_set_format_quirk(struct snd_usb_substream *subs,
1741 u16 w 1741 u16 windex)
1742 { 1742 {
1743 unsigned int cur_rate = subs->data_en 1743 unsigned int cur_rate = subs->data_endpoint->cur_rate;
1744 u8 sr[3]; 1744 u8 sr[3];
1745 // Convert to little endian 1745 // Convert to little endian
1746 sr[0] = cur_rate & 0xff; 1746 sr[0] = cur_rate & 0xff;
1747 sr[1] = (cur_rate >> 8) & 0xff; 1747 sr[1] = (cur_rate >> 8) & 0xff;
1748 sr[2] = (cur_rate >> 16) & 0xff; 1748 sr[2] = (cur_rate >> 16) & 0xff;
1749 usb_set_interface(subs->dev, 0, 1); 1749 usb_set_interface(subs->dev, 0, 1);
1750 // we should derive windex from fmt-s 1750 // we should derive windex from fmt-sync_ep but it's not set
1751 snd_usb_ctl_msg(subs->stream->chip->d 1751 snd_usb_ctl_msg(subs->stream->chip->dev,
1752 usb_sndctrlpipe(subs->stream- 1752 usb_sndctrlpipe(subs->stream->chip->dev, 0),
1753 0x01, 0x22, 0x0100, windex, & 1753 0x01, 0x22, 0x0100, windex, &sr, 0x0003);
1754 return 0; 1754 return 0;
1755 } 1755 }
1756 1756
1757 static void mbox3_set_format_quirk(struct snd 1757 static void mbox3_set_format_quirk(struct snd_usb_substream *subs,
1758 const struct 1758 const struct audioformat *fmt)
1759 { 1759 {
1760 __le32 buff4 = 0; 1760 __le32 buff4 = 0;
1761 u8 buff1 = 0x01; 1761 u8 buff1 = 0x01;
1762 u32 new_rate = subs->data_endpoint->c 1762 u32 new_rate = subs->data_endpoint->cur_rate;
1763 u32 current_rate; 1763 u32 current_rate;
1764 1764
1765 // Get current rate from card and che 1765 // Get current rate from card and check if changing it is needed
1766 snd_usb_ctl_msg(subs->dev, usb_rcvctr 1766 snd_usb_ctl_msg(subs->dev, usb_rcvctrlpipe(subs->dev, 0),
1767 0x01, 1767 0x01, 0x21 | USB_DIR_IN, 0x0100, 0x8101, &buff4, 4);
1768 current_rate = le32_to_cpu(buff4); 1768 current_rate = le32_to_cpu(buff4);
1769 dev_dbg(&subs->dev->dev, 1769 dev_dbg(&subs->dev->dev,
1770 "MBOX3: Current conf 1770 "MBOX3: Current configured sample rate: %d", current_rate);
1771 if (current_rate == new_rate) { 1771 if (current_rate == new_rate) {
1772 dev_dbg(&subs->dev->dev, 1772 dev_dbg(&subs->dev->dev,
1773 "MBOX3: No change nee 1773 "MBOX3: No change needed (current rate:%d == new rate:%d)",
1774 current_rate, new_rat 1774 current_rate, new_rate);
1775 return; 1775 return;
1776 } 1776 }
1777 1777
1778 // Set new rate 1778 // Set new rate
1779 dev_info(&subs->dev->dev, 1779 dev_info(&subs->dev->dev,
1780 "MBOX3: Changing sam 1780 "MBOX3: Changing sample rate to: %d", new_rate);
1781 buff4 = cpu_to_le32(new_rate); 1781 buff4 = cpu_to_le32(new_rate);
1782 snd_usb_ctl_msg(subs->dev, usb_sndctr 1782 snd_usb_ctl_msg(subs->dev, usb_sndctrlpipe(subs->dev, 0),
1783 0x01, 1783 0x01, 0x21, 0x0100, 0x8101, &buff4, 4);
1784 1784
1785 // Set clock source to Internal 1785 // Set clock source to Internal
1786 snd_usb_ctl_msg(subs->dev, usb_sndctr 1786 snd_usb_ctl_msg(subs->dev, usb_sndctrlpipe(subs->dev, 0),
1787 0x01, 1787 0x01, 0x21, 0x0100, 0x8001, &buff1, 1);
1788 1788
1789 // Check whether the change was succe 1789 // Check whether the change was successful
1790 buff4 = 0; 1790 buff4 = 0;
1791 snd_usb_ctl_msg(subs->dev, usb_rcvctr 1791 snd_usb_ctl_msg(subs->dev, usb_rcvctrlpipe(subs->dev, 0),
1792 0x01, 1792 0x01, 0x21 | USB_DIR_IN, 0x0100, 0x8101, &buff4, 4);
1793 if (new_rate != le32_to_cpu(buff4)) 1793 if (new_rate != le32_to_cpu(buff4))
1794 dev_warn(&subs->dev->dev, "MB 1794 dev_warn(&subs->dev->dev, "MBOX3: Couldn't set the sample rate");
1795 } 1795 }
1796 1796
1797 static const int rme_digiface_rate_table[] = 1797 static const int rme_digiface_rate_table[] = {
1798 32000, 44100, 48000, 0, 1798 32000, 44100, 48000, 0,
1799 64000, 88200, 96000, 0, 1799 64000, 88200, 96000, 0,
1800 128000, 176400, 192000, 0, 1800 128000, 176400, 192000, 0,
1801 }; 1801 };
1802 1802
1803 static int rme_digiface_set_format_quirk(stru 1803 static int rme_digiface_set_format_quirk(struct snd_usb_substream *subs)
1804 { 1804 {
1805 unsigned int cur_rate = subs->data_en 1805 unsigned int cur_rate = subs->data_endpoint->cur_rate;
1806 u16 val; 1806 u16 val;
1807 int speed_mode; 1807 int speed_mode;
1808 int id; 1808 int id;
1809 1809
1810 for (id = 0; id < ARRAY_SIZE(rme_digi 1810 for (id = 0; id < ARRAY_SIZE(rme_digiface_rate_table); id++) {
1811 if (rme_digiface_rate_table[i 1811 if (rme_digiface_rate_table[id] == cur_rate)
1812 break; 1812 break;
1813 } 1813 }
1814 1814
1815 if (id >= ARRAY_SIZE(rme_digiface_rat 1815 if (id >= ARRAY_SIZE(rme_digiface_rate_table))
1816 return -EINVAL; 1816 return -EINVAL;
1817 1817
1818 /* 2, 3, 4 for 1x, 2x, 4x */ 1818 /* 2, 3, 4 for 1x, 2x, 4x */
1819 speed_mode = (id >> 2) + 2; 1819 speed_mode = (id >> 2) + 2;
1820 val = (id << 3) | (speed_mode << 12); 1820 val = (id << 3) | (speed_mode << 12);
1821 1821
1822 /* Set the sample rate */ 1822 /* Set the sample rate */
1823 snd_usb_ctl_msg(subs->stream->chip->d 1823 snd_usb_ctl_msg(subs->stream->chip->dev,
1824 usb_sndctrlpipe(subs->stream- 1824 usb_sndctrlpipe(subs->stream->chip->dev, 0),
1825 16, 0x40, val, 0x7078, NULL, 1825 16, 0x40, val, 0x7078, NULL, 0);
1826 return 0; 1826 return 0;
1827 } 1827 }
1828 1828
1829 void snd_usb_set_format_quirk(struct snd_usb_ 1829 void snd_usb_set_format_quirk(struct snd_usb_substream *subs,
1830 const struct au 1830 const struct audioformat *fmt)
1831 { 1831 {
1832 switch (subs->stream->chip->usb_id) { 1832 switch (subs->stream->chip->usb_id) {
1833 case USB_ID(0x041e, 0x3f02): /* E-Mu 1833 case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
1834 case USB_ID(0x041e, 0x3f04): /* E-Mu 1834 case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
1835 case USB_ID(0x041e, 0x3f0a): /* E-Mu 1835 case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
1836 case USB_ID(0x041e, 0x3f19): /* E-Mu 1836 case USB_ID(0x041e, 0x3f19): /* E-Mu 0204 USB */
1837 set_format_emu_quirk(subs, fm 1837 set_format_emu_quirk(subs, fmt);
1838 break; 1838 break;
1839 case USB_ID(0x534d, 0x0021): /* Macro 1839 case USB_ID(0x534d, 0x0021): /* MacroSilicon MS2100/MS2106 */
1840 case USB_ID(0x534d, 0x2109): /* Macro 1840 case USB_ID(0x534d, 0x2109): /* MacroSilicon MS2109 */
1841 subs->stream_offset_adj = 2; 1841 subs->stream_offset_adj = 2;
1842 break; 1842 break;
1843 case USB_ID(0x2b73, 0x0013): /* Pione 1843 case USB_ID(0x2b73, 0x0013): /* Pioneer DJM-450 */
1844 pioneer_djm_set_format_quirk( 1844 pioneer_djm_set_format_quirk(subs, 0x0082);
1845 break; 1845 break;
1846 case USB_ID(0x08e4, 0x017f): /* Pione 1846 case USB_ID(0x08e4, 0x017f): /* Pioneer DJM-750 */
1847 case USB_ID(0x08e4, 0x0163): /* Pione 1847 case USB_ID(0x08e4, 0x0163): /* Pioneer DJM-850 */
1848 pioneer_djm_set_format_quirk( 1848 pioneer_djm_set_format_quirk(subs, 0x0086);
1849 break; 1849 break;
1850 case USB_ID(0x0dba, 0x5000): 1850 case USB_ID(0x0dba, 0x5000):
1851 mbox3_set_format_quirk(subs, 1851 mbox3_set_format_quirk(subs, fmt); /* Digidesign Mbox 3 */
1852 break; 1852 break;
1853 case USB_ID(0x2a39, 0x3f8c): /* RME D 1853 case USB_ID(0x2a39, 0x3f8c): /* RME Digiface USB */
1854 rme_digiface_set_format_quirk 1854 rme_digiface_set_format_quirk(subs);
1855 break; 1855 break;
1856 } 1856 }
1857 } 1857 }
1858 1858
1859 int snd_usb_select_mode_quirk(struct snd_usb_ 1859 int snd_usb_select_mode_quirk(struct snd_usb_audio *chip,
1860 const struct au 1860 const struct audioformat *fmt)
1861 { 1861 {
1862 struct usb_device *dev = chip->dev; 1862 struct usb_device *dev = chip->dev;
1863 int err; 1863 int err;
1864 1864
1865 if (chip->quirk_flags & QUIRK_FLAG_IT 1865 if (chip->quirk_flags & QUIRK_FLAG_ITF_USB_DSD_DAC) {
1866 /* First switch to alt set 0, 1866 /* First switch to alt set 0, otherwise the mode switch cmd
1867 * will not be accepted by th 1867 * will not be accepted by the DAC
1868 */ 1868 */
1869 err = usb_set_interface(dev, 1869 err = usb_set_interface(dev, fmt->iface, 0);
1870 if (err < 0) 1870 if (err < 0)
1871 return err; 1871 return err;
1872 1872
1873 msleep(20); /* Delay needed a 1873 msleep(20); /* Delay needed after setting the interface */
1874 1874
1875 /* Vendor mode switch cmd is 1875 /* Vendor mode switch cmd is required. */
1876 if (fmt->formats & SNDRV_PCM_ 1876 if (fmt->formats & SNDRV_PCM_FMTBIT_DSD_U32_BE) {
1877 /* DSD mode (DSD_U32) 1877 /* DSD mode (DSD_U32) requested */
1878 err = snd_usb_ctl_msg 1878 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,
1879 1879 USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
1880 1880 1, 1, NULL, 0);
1881 if (err < 0) 1881 if (err < 0)
1882 return err; 1882 return err;
1883 1883
1884 } else { 1884 } else {
1885 /* PCM or DOP mode (S 1885 /* PCM or DOP mode (S32) requested */
1886 /* PCM mode (S16) req 1886 /* PCM mode (S16) requested */
1887 err = snd_usb_ctl_msg 1887 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,
1888 1888 USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
1889 1889 0, 1, NULL, 0);
1890 if (err < 0) 1890 if (err < 0)
1891 return err; 1891 return err;
1892 1892
1893 } 1893 }
1894 msleep(20); 1894 msleep(20);
1895 } 1895 }
1896 return 0; 1896 return 0;
1897 } 1897 }
1898 1898
1899 void snd_usb_endpoint_start_quirk(struct snd_ 1899 void snd_usb_endpoint_start_quirk(struct snd_usb_endpoint *ep)
1900 { 1900 {
1901 /* 1901 /*
1902 * "Playback Design" products send bo 1902 * "Playback Design" products send bogus feedback data at the start
1903 * of the stream. Ignore them. 1903 * of the stream. Ignore them.
1904 */ 1904 */
1905 if (USB_ID_VENDOR(ep->chip->usb_id) = 1905 if (USB_ID_VENDOR(ep->chip->usb_id) == 0x23ba &&
1906 ep->type == SND_USB_ENDPOINT_TYPE 1906 ep->type == SND_USB_ENDPOINT_TYPE_SYNC)
1907 ep->skip_packets = 4; 1907 ep->skip_packets = 4;
1908 1908
1909 /* 1909 /*
1910 * M-Audio Fast Track C400/C600 - whe 1910 * M-Audio Fast Track C400/C600 - when packets are not skipped, real
1911 * world latency varies by approx. +/ 1911 * world latency varies by approx. +/- 50 frames (at 96kHz) each time
1912 * the stream is (re)started. When sk 1912 * the stream is (re)started. When skipping packets 16 at endpoint
1913 * start up, the real world latency i 1913 * start up, the real world latency is stable within +/- 1 frame (also
1914 * across power cycles). 1914 * across power cycles).
1915 */ 1915 */
1916 if ((ep->chip->usb_id == USB_ID(0x076 1916 if ((ep->chip->usb_id == USB_ID(0x0763, 0x2030) ||
1917 ep->chip->usb_id == USB_ID(0x076 1917 ep->chip->usb_id == USB_ID(0x0763, 0x2031)) &&
1918 ep->type == SND_USB_ENDPOINT_TYPE 1918 ep->type == SND_USB_ENDPOINT_TYPE_DATA)
1919 ep->skip_packets = 16; 1919 ep->skip_packets = 16;
1920 1920
1921 /* Work around devices that report un 1921 /* Work around devices that report unreasonable feedback data */
1922 if ((ep->chip->usb_id == USB_ID(0x064 1922 if ((ep->chip->usb_id == USB_ID(0x0644, 0x8038) || /* TEAC UD-H01 */
1923 ep->chip->usb_id == USB_ID(0x185 1923 ep->chip->usb_id == USB_ID(0x1852, 0x5034)) && /* T+A Dac8 */
1924 ep->syncmaxsize == 4) 1924 ep->syncmaxsize == 4)
1925 ep->tenor_fb_quirk = 1; 1925 ep->tenor_fb_quirk = 1;
1926 } 1926 }
1927 1927
1928 /* quirk applied after snd_usb_ctl_msg(); not 1928 /* quirk applied after snd_usb_ctl_msg(); not applied during boot quirks */
1929 void snd_usb_ctl_msg_quirk(struct usb_device 1929 void snd_usb_ctl_msg_quirk(struct usb_device *dev, unsigned int pipe,
1930 __u8 request, __u8 1930 __u8 request, __u8 requesttype, __u16 value,
1931 __u16 index, void 1931 __u16 index, void *data, __u16 size)
1932 { 1932 {
1933 struct snd_usb_audio *chip = dev_get_ 1933 struct snd_usb_audio *chip = dev_get_drvdata(&dev->dev);
1934 1934
1935 if (!chip || (requesttype & USB_TYPE_ 1935 if (!chip || (requesttype & USB_TYPE_MASK) != USB_TYPE_CLASS)
1936 return; 1936 return;
1937 1937
1938 if (chip->quirk_flags & QUIRK_FLAG_CT 1938 if (chip->quirk_flags & QUIRK_FLAG_CTL_MSG_DELAY)
1939 msleep(20); 1939 msleep(20);
1940 else if (chip->quirk_flags & QUIRK_FL 1940 else if (chip->quirk_flags & QUIRK_FLAG_CTL_MSG_DELAY_1M)
1941 usleep_range(1000, 2000); 1941 usleep_range(1000, 2000);
1942 else if (chip->quirk_flags & QUIRK_FL 1942 else if (chip->quirk_flags & QUIRK_FLAG_CTL_MSG_DELAY_5M)
1943 usleep_range(5000, 6000); 1943 usleep_range(5000, 6000);
1944 } 1944 }
1945 1945
1946 /* 1946 /*
1947 * snd_usb_interface_dsd_format_quirks() is c 1947 * snd_usb_interface_dsd_format_quirks() is called from format.c to
1948 * augment the PCM format bit-field for DSD t 1948 * augment the PCM format bit-field for DSD types. The UAC standards
1949 * don't have a designated bit field to denot 1949 * don't have a designated bit field to denote DSD-capable interfaces,
1950 * hence all hardware that is known to suppor 1950 * hence all hardware that is known to support this format has to be
1951 * listed here. 1951 * listed here.
1952 */ 1952 */
1953 u64 snd_usb_interface_dsd_format_quirks(struc 1953 u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip,
1954 struc 1954 struct audioformat *fp,
1955 unsig 1955 unsigned int sample_bytes)
1956 { 1956 {
1957 struct usb_interface *iface; 1957 struct usb_interface *iface;
1958 1958
1959 /* Playback Designs */ 1959 /* Playback Designs */
1960 if (USB_ID_VENDOR(chip->usb_id) == 0x 1960 if (USB_ID_VENDOR(chip->usb_id) == 0x23ba &&
1961 USB_ID_PRODUCT(chip->usb_id) < 0x 1961 USB_ID_PRODUCT(chip->usb_id) < 0x0110) {
1962 switch (fp->altsetting) { 1962 switch (fp->altsetting) {
1963 case 1: 1963 case 1:
1964 fp->dsd_dop = true; 1964 fp->dsd_dop = true;
1965 return SNDRV_PCM_FMTB 1965 return SNDRV_PCM_FMTBIT_DSD_U16_LE;
1966 case 2: 1966 case 2:
1967 fp->dsd_bitrev = true 1967 fp->dsd_bitrev = true;
1968 return SNDRV_PCM_FMTB 1968 return SNDRV_PCM_FMTBIT_DSD_U8;
1969 case 3: 1969 case 3:
1970 fp->dsd_bitrev = true 1970 fp->dsd_bitrev = true;
1971 return SNDRV_PCM_FMTB 1971 return SNDRV_PCM_FMTBIT_DSD_U16_LE;
1972 } 1972 }
1973 } 1973 }
1974 1974
1975 /* XMOS based USB DACs */ 1975 /* XMOS based USB DACs */
1976 switch (chip->usb_id) { 1976 switch (chip->usb_id) {
1977 case USB_ID(0x139f, 0x5504): /* Nagra 1977 case USB_ID(0x139f, 0x5504): /* Nagra DAC */
1978 case USB_ID(0x20b1, 0x3089): /* Mola- 1978 case USB_ID(0x20b1, 0x3089): /* Mola-Mola DAC */
1979 case USB_ID(0x2522, 0x0007): /* LH La 1979 case USB_ID(0x2522, 0x0007): /* LH Labs Geek Out 1V5 */
1980 case USB_ID(0x2522, 0x0009): /* LH La 1980 case USB_ID(0x2522, 0x0009): /* LH Labs Geek Pulse X Inifinity 2V0 */
1981 case USB_ID(0x2522, 0x0012): /* LH La 1981 case USB_ID(0x2522, 0x0012): /* LH Labs VI DAC Infinity */
1982 case USB_ID(0x2772, 0x0230): /* Pro-J 1982 case USB_ID(0x2772, 0x0230): /* Pro-Ject Pre Box S2 Digital */
1983 if (fp->altsetting == 2) 1983 if (fp->altsetting == 2)
1984 return SNDRV_PCM_FMTB 1984 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1985 break; 1985 break;
1986 1986
1987 case USB_ID(0x0d8c, 0x0316): /* Hegel 1987 case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */
1988 case USB_ID(0x10cb, 0x0103): /* The B 1988 case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */
1989 case USB_ID(0x16d0, 0x06b2): /* NuPri 1989 case USB_ID(0x16d0, 0x06b2): /* NuPrime DAC-10 */
1990 case USB_ID(0x16d0, 0x06b4): /* NuPri 1990 case USB_ID(0x16d0, 0x06b4): /* NuPrime Audio HD-AVP/AVA */
1991 case USB_ID(0x16d0, 0x0733): /* Furut 1991 case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */
1992 case USB_ID(0x16d0, 0x09d8): /* NuPri 1992 case USB_ID(0x16d0, 0x09d8): /* NuPrime IDA-8 */
1993 case USB_ID(0x16d0, 0x09db): /* NuPri 1993 case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */
1994 case USB_ID(0x16d0, 0x09dd): /* Encor 1994 case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */
1995 case USB_ID(0x1db5, 0x0003): /* Bryst 1995 case USB_ID(0x1db5, 0x0003): /* Bryston BDA3 */
1996 case USB_ID(0x20a0, 0x4143): /* WaveI 1996 case USB_ID(0x20a0, 0x4143): /* WaveIO USB Audio 2.0 */
1997 case USB_ID(0x22e1, 0xca01): /* HDTA 1997 case USB_ID(0x22e1, 0xca01): /* HDTA Serenade DSD */
1998 case USB_ID(0x249c, 0x9326): /* M2Tec 1998 case USB_ID(0x249c, 0x9326): /* M2Tech Young MkIII */
1999 case USB_ID(0x2616, 0x0106): /* PS Au 1999 case USB_ID(0x2616, 0x0106): /* PS Audio NuWave DAC */
2000 case USB_ID(0x2622, 0x0041): /* Audio 2000 case USB_ID(0x2622, 0x0041): /* Audiolab M-DAC+ */
2001 case USB_ID(0x278b, 0x5100): /* Rotel 2001 case USB_ID(0x278b, 0x5100): /* Rotel RC-1590 */
2002 case USB_ID(0x27f7, 0x3002): /* W4S D 2002 case USB_ID(0x27f7, 0x3002): /* W4S DAC-2v2SE */
2003 case USB_ID(0x29a2, 0x0086): /* Mutec 2003 case USB_ID(0x29a2, 0x0086): /* Mutec MC3+ USB */
2004 case USB_ID(0x6b42, 0x0042): /* MSB T 2004 case USB_ID(0x6b42, 0x0042): /* MSB Technology */
2005 if (fp->altsetting == 3) 2005 if (fp->altsetting == 3)
2006 return SNDRV_PCM_FMTB 2006 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
2007 break; 2007 break;
2008 2008
2009 /* Amanero Combo384 USB based DACs wi 2009 /* Amanero Combo384 USB based DACs with native DSD support */
2010 case USB_ID(0x16d0, 0x071a): /* Aman 2010 case USB_ID(0x16d0, 0x071a): /* Amanero - Combo384 */
2011 if (fp->altsetting == 2) { 2011 if (fp->altsetting == 2) {
2012 switch (le16_to_cpu(c 2012 switch (le16_to_cpu(chip->dev->descriptor.bcdDevice)) {
2013 case 0x199: 2013 case 0x199:
2014 return SNDRV_ 2014 return SNDRV_PCM_FMTBIT_DSD_U32_LE;
2015 case 0x19b: 2015 case 0x19b:
2016 case 0x203: 2016 case 0x203:
2017 return SNDRV_ 2017 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
2018 default: 2018 default:
2019 break; 2019 break;
2020 } 2020 }
2021 } 2021 }
2022 break; 2022 break;
2023 case USB_ID(0x16d0, 0x0a23): 2023 case USB_ID(0x16d0, 0x0a23):
2024 if (fp->altsetting == 2) 2024 if (fp->altsetting == 2)
2025 return SNDRV_PCM_FMTB 2025 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
2026 break; 2026 break;
2027 2027
2028 default: 2028 default:
2029 break; 2029 break;
2030 } 2030 }
2031 2031
2032 /* ITF-USB DSD based DACs */ 2032 /* ITF-USB DSD based DACs */
2033 if (chip->quirk_flags & QUIRK_FLAG_IT 2033 if (chip->quirk_flags & QUIRK_FLAG_ITF_USB_DSD_DAC) {
2034 iface = usb_ifnum_to_if(chip- 2034 iface = usb_ifnum_to_if(chip->dev, fp->iface);
2035 2035
2036 /* Altsetting 2 support nativ 2036 /* Altsetting 2 support native DSD if the num of altsets is
2037 * three (0-2), 2037 * three (0-2),
2038 * Altsetting 3 support nativ 2038 * Altsetting 3 support native DSD if the num of altsets is
2039 * four (0-3). 2039 * four (0-3).
2040 */ 2040 */
2041 if (fp->altsetting == iface-> 2041 if (fp->altsetting == iface->num_altsetting - 1)
2042 return SNDRV_PCM_FMTB 2042 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
2043 } 2043 }
2044 2044
2045 /* Mostly generic method to detect ma 2045 /* Mostly generic method to detect many DSD-capable implementations */
2046 if ((chip->quirk_flags & QUIRK_FLAG_D 2046 if ((chip->quirk_flags & QUIRK_FLAG_DSD_RAW) && fp->dsd_raw)
2047 return SNDRV_PCM_FMTBIT_DSD_U 2047 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
2048 2048
2049 return 0; 2049 return 0;
2050 } 2050 }
2051 2051
2052 void snd_usb_audioformat_attributes_quirk(str 2052 void snd_usb_audioformat_attributes_quirk(struct snd_usb_audio *chip,
2053 str 2053 struct audioformat *fp,
2054 int 2054 int stream)
2055 { 2055 {
2056 switch (chip->usb_id) { 2056 switch (chip->usb_id) {
2057 case USB_ID(0x0a92, 0x0053): /* Audio 2057 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
2058 /* Optoplay sets the sample r 2058 /* Optoplay sets the sample rate attribute although
2059 * it seems not supporting it 2059 * it seems not supporting it in fact.
2060 */ 2060 */
2061 fp->attributes &= ~UAC_EP_CS_ 2061 fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE;
2062 break; 2062 break;
2063 case USB_ID(0x041e, 0x3020): /* Creat 2063 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
2064 case USB_ID(0x0763, 0x2003): /* M-Aud 2064 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2065 /* doesn't set the sample rat 2065 /* doesn't set the sample rate attribute, but supports it */
2066 fp->attributes |= UAC_EP_CS_A 2066 fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE;
2067 break; 2067 break;
2068 case USB_ID(0x0763, 0x2001): /* M-Au 2068 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro USB */
2069 case USB_ID(0x0763, 0x2012): /* M-Au 2069 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */
2070 case USB_ID(0x047f, 0x0ca1): /* plant 2070 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
2071 case USB_ID(0x077d, 0x07af): /* Griff 2071 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
2072 an ol 2072 an older model 77d:223) */
2073 /* 2073 /*
2074 * plantronics headset and Griffin iM 2074 * plantronics headset and Griffin iMic have set adaptive-in
2075 * although it's really not... 2075 * although it's really not...
2076 */ 2076 */
2077 fp->ep_attr &= ~USB_ENDPOINT_ 2077 fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE;
2078 if (stream == SNDRV_PCM_STREA 2078 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
2079 fp->ep_attr |= USB_EN 2079 fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE;
2080 else 2080 else
2081 fp->ep_attr |= USB_EN 2081 fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC;
2082 break; 2082 break;
2083 case USB_ID(0x07fd, 0x0004): /* MOTU 2083 case USB_ID(0x07fd, 0x0004): /* MOTU MicroBook IIc */
2084 /* 2084 /*
2085 * MaxPacketsOnly attribute i 2085 * MaxPacketsOnly attribute is erroneously set in endpoint
2086 * descriptors. As a result t 2086 * descriptors. As a result this card produces noise with
2087 * all sample rates other tha 2087 * all sample rates other than 96 kHz.
2088 */ 2088 */
2089 fp->attributes &= ~UAC_EP_CS_ 2089 fp->attributes &= ~UAC_EP_CS_ATTR_FILL_MAX;
2090 break; 2090 break;
2091 case USB_ID(0x1224, 0x2a25): /* Jiel 2091 case USB_ID(0x1224, 0x2a25): /* Jieli Technology USB PHY 2.0 */
2092 /* mic works only when ep pac 2092 /* mic works only when ep packet size is set to wMaxPacketSize */
2093 fp->attributes |= UAC_EP_CS_A 2093 fp->attributes |= UAC_EP_CS_ATTR_FILL_MAX;
2094 break; 2094 break;
2095 case USB_ID(0x3511, 0x2b1e): /* Openc 2095 case USB_ID(0x3511, 0x2b1e): /* Opencomm2 UC USB Bluetooth dongle */
2096 /* mic works only when ep pit 2096 /* mic works only when ep pitch control is not set */
2097 if (stream == SNDRV_PCM_STREA 2097 if (stream == SNDRV_PCM_STREAM_CAPTURE)
2098 fp->attributes &= ~UA 2098 fp->attributes &= ~UAC_EP_CS_ATTR_PITCH_CONTROL;
2099 break; 2099 break;
2100 } 2100 }
2101 } 2101 }
2102 2102
2103 /* 2103 /*
2104 * driver behavior quirk flags 2104 * driver behavior quirk flags
2105 */ 2105 */
2106 struct usb_audio_quirk_flags_table { 2106 struct usb_audio_quirk_flags_table {
2107 u32 id; 2107 u32 id;
2108 u32 flags; 2108 u32 flags;
2109 }; 2109 };
2110 2110
2111 #define DEVICE_FLG(vid, pid, _flags) \ 2111 #define DEVICE_FLG(vid, pid, _flags) \
2112 { .id = USB_ID(vid, pid), .flags = (_ 2112 { .id = USB_ID(vid, pid), .flags = (_flags) }
2113 #define VENDOR_FLG(vid, _flags) DEVICE_FLG(vi 2113 #define VENDOR_FLG(vid, _flags) DEVICE_FLG(vid, 0, _flags)
2114 2114
2115 static const struct usb_audio_quirk_flags_tab 2115 static const struct usb_audio_quirk_flags_table quirk_flags_table[] = {
2116 /* Device matches */ 2116 /* Device matches */
2117 DEVICE_FLG(0x041e, 0x3000, /* Creativ 2117 DEVICE_FLG(0x041e, 0x3000, /* Creative SB Extigy */
2118 QUIRK_FLAG_IGNORE_CTL_ERRO 2118 QUIRK_FLAG_IGNORE_CTL_ERROR),
2119 DEVICE_FLG(0x041e, 0x4080, /* Creativ 2119 DEVICE_FLG(0x041e, 0x4080, /* Creative Live Cam VF0610 */
2120 QUIRK_FLAG_GET_SAMPLE_RATE 2120 QUIRK_FLAG_GET_SAMPLE_RATE),
2121 DEVICE_FLG(0x045e, 0x083c, /* MS USB 2121 DEVICE_FLG(0x045e, 0x083c, /* MS USB Link headset */
2122 QUIRK_FLAG_GET_SAMPLE_RATE 2122 QUIRK_FLAG_GET_SAMPLE_RATE | QUIRK_FLAG_CTL_MSG_DELAY |
2123 QUIRK_FLAG_DISABLE_AUTOSUS 2123 QUIRK_FLAG_DISABLE_AUTOSUSPEND),
2124 DEVICE_FLG(0x046d, 0x084c, /* Logitec 2124 DEVICE_FLG(0x046d, 0x084c, /* Logitech ConferenceCam Connect */
2125 QUIRK_FLAG_GET_SAMPLE_RATE 2125 QUIRK_FLAG_GET_SAMPLE_RATE | QUIRK_FLAG_CTL_MSG_DELAY_1M),
2126 DEVICE_FLG(0x046d, 0x0991, /* Logitec 2126 DEVICE_FLG(0x046d, 0x0991, /* Logitech QuickCam Pro */
2127 QUIRK_FLAG_CTL_MSG_DELAY_1 2127 QUIRK_FLAG_CTL_MSG_DELAY_1M | QUIRK_FLAG_IGNORE_CTL_ERROR),
2128 DEVICE_FLG(0x046d, 0x09a4, /* Logitec 2128 DEVICE_FLG(0x046d, 0x09a4, /* Logitech QuickCam E 3500 */
2129 QUIRK_FLAG_CTL_MSG_DELAY_1 2129 QUIRK_FLAG_CTL_MSG_DELAY_1M | QUIRK_FLAG_IGNORE_CTL_ERROR),
2130 DEVICE_FLG(0x0499, 0x1509, /* Steinbe 2130 DEVICE_FLG(0x0499, 0x1509, /* Steinberg UR22 */
2131 QUIRK_FLAG_GENERIC_IMPLICI 2131 QUIRK_FLAG_GENERIC_IMPLICIT_FB),
2132 DEVICE_FLG(0x0499, 0x3108, /* Yamaha 2132 DEVICE_FLG(0x0499, 0x3108, /* Yamaha YIT-W12TX */
2133 QUIRK_FLAG_GET_SAMPLE_RATE 2133 QUIRK_FLAG_GET_SAMPLE_RATE),
2134 DEVICE_FLG(0x04d8, 0xfeea, /* Benchma 2134 DEVICE_FLG(0x04d8, 0xfeea, /* Benchmark DAC1 Pre */
2135 QUIRK_FLAG_GET_SAMPLE_RATE 2135 QUIRK_FLAG_GET_SAMPLE_RATE),
2136 DEVICE_FLG(0x04e8, 0xa051, /* Samsung 2136 DEVICE_FLG(0x04e8, 0xa051, /* Samsung USBC Headset (AKG) */
2137 QUIRK_FLAG_SKIP_CLOCK_SELE 2137 QUIRK_FLAG_SKIP_CLOCK_SELECTOR | QUIRK_FLAG_CTL_MSG_DELAY_5M),
2138 DEVICE_FLG(0x0525, 0xa4ad, /* Hamedal 2138 DEVICE_FLG(0x0525, 0xa4ad, /* Hamedal C20 usb camero */
2139 QUIRK_FLAG_IFACE_SKIP_CLOS 2139 QUIRK_FLAG_IFACE_SKIP_CLOSE),
2140 DEVICE_FLG(0x054c, 0x0b8c, /* Sony WA 2140 DEVICE_FLG(0x054c, 0x0b8c, /* Sony WALKMAN NW-A45 DAC */
2141 QUIRK_FLAG_SET_IFACE_FIRST 2141 QUIRK_FLAG_SET_IFACE_FIRST),
2142 DEVICE_FLG(0x0556, 0x0014, /* Phoenix 2142 DEVICE_FLG(0x0556, 0x0014, /* Phoenix Audio TMX320VC */
2143 QUIRK_FLAG_GET_SAMPLE_RATE 2143 QUIRK_FLAG_GET_SAMPLE_RATE),
2144 DEVICE_FLG(0x05a3, 0x9420, /* ELP HD 2144 DEVICE_FLG(0x05a3, 0x9420, /* ELP HD USB Camera */
2145 QUIRK_FLAG_GET_SAMPLE_RATE 2145 QUIRK_FLAG_GET_SAMPLE_RATE),
2146 DEVICE_FLG(0x05a7, 0x1020, /* Bose Co 2146 DEVICE_FLG(0x05a7, 0x1020, /* Bose Companion 5 */
2147 QUIRK_FLAG_GET_SAMPLE_RATE 2147 QUIRK_FLAG_GET_SAMPLE_RATE),
2148 DEVICE_FLG(0x05e1, 0x0408, /* Syntek 2148 DEVICE_FLG(0x05e1, 0x0408, /* Syntek STK1160 */
2149 QUIRK_FLAG_ALIGN_TRANSFER) 2149 QUIRK_FLAG_ALIGN_TRANSFER),
2150 DEVICE_FLG(0x05e1, 0x0480, /* Hauppau 2150 DEVICE_FLG(0x05e1, 0x0480, /* Hauppauge Woodbury */
2151 QUIRK_FLAG_SHARE_MEDIA_DEV 2151 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2152 DEVICE_FLG(0x0644, 0x8043, /* TEAC UD 2152 DEVICE_FLG(0x0644, 0x8043, /* TEAC UD-501/UD-501V2/UD-503/NT-503 */
2153 QUIRK_FLAG_ITF_USB_DSD_DAC 2153 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY |
2154 QUIRK_FLAG_IFACE_DELAY), 2154 QUIRK_FLAG_IFACE_DELAY),
2155 DEVICE_FLG(0x0644, 0x8044, /* Esoteri 2155 DEVICE_FLG(0x0644, 0x8044, /* Esoteric D-05X */
2156 QUIRK_FLAG_ITF_USB_DSD_DAC 2156 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY |
2157 QUIRK_FLAG_IFACE_DELAY), 2157 QUIRK_FLAG_IFACE_DELAY),
2158 DEVICE_FLG(0x0644, 0x804a, /* TEAC UD 2158 DEVICE_FLG(0x0644, 0x804a, /* TEAC UD-301 */
2159 QUIRK_FLAG_ITF_USB_DSD_DAC 2159 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY |
2160 QUIRK_FLAG_IFACE_DELAY), 2160 QUIRK_FLAG_IFACE_DELAY),
2161 DEVICE_FLG(0x0644, 0x805f, /* TEAC Mo 2161 DEVICE_FLG(0x0644, 0x805f, /* TEAC Model 12 */
2162 QUIRK_FLAG_FORCE_IFACE_RES 2162 QUIRK_FLAG_FORCE_IFACE_RESET),
2163 DEVICE_FLG(0x0644, 0x806b, /* TEAC UD 2163 DEVICE_FLG(0x0644, 0x806b, /* TEAC UD-701 */
2164 QUIRK_FLAG_ITF_USB_DSD_DAC 2164 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY |
2165 QUIRK_FLAG_IFACE_DELAY), 2165 QUIRK_FLAG_IFACE_DELAY),
2166 DEVICE_FLG(0x06f8, 0xb000, /* Hercule 2166 DEVICE_FLG(0x06f8, 0xb000, /* Hercules DJ Console (Windows Edition) */
2167 QUIRK_FLAG_IGNORE_CTL_ERRO 2167 QUIRK_FLAG_IGNORE_CTL_ERROR),
2168 DEVICE_FLG(0x06f8, 0xd002, /* Hercule 2168 DEVICE_FLG(0x06f8, 0xd002, /* Hercules DJ Console (Macintosh Edition) */
2169 QUIRK_FLAG_IGNORE_CTL_ERRO 2169 QUIRK_FLAG_IGNORE_CTL_ERROR),
2170 DEVICE_FLG(0x0711, 0x5800, /* MCT Tri 2170 DEVICE_FLG(0x0711, 0x5800, /* MCT Trigger 5 USB-to-HDMI */
2171 QUIRK_FLAG_GET_SAMPLE_RATE 2171 QUIRK_FLAG_GET_SAMPLE_RATE),
2172 DEVICE_FLG(0x074d, 0x3553, /* Outlaw 2172 DEVICE_FLG(0x074d, 0x3553, /* Outlaw RR2150 (Micronas UAC3553B) */
2173 QUIRK_FLAG_GET_SAMPLE_RATE 2173 QUIRK_FLAG_GET_SAMPLE_RATE),
2174 DEVICE_FLG(0x0763, 0x2030, /* M-Audio 2174 DEVICE_FLG(0x0763, 0x2030, /* M-Audio Fast Track C400 */
2175 QUIRK_FLAG_GENERIC_IMPLICI 2175 QUIRK_FLAG_GENERIC_IMPLICIT_FB),
2176 DEVICE_FLG(0x0763, 0x2031, /* M-Audio 2176 DEVICE_FLG(0x0763, 0x2031, /* M-Audio Fast Track C600 */
2177 QUIRK_FLAG_GENERIC_IMPLICI 2177 QUIRK_FLAG_GENERIC_IMPLICIT_FB),
2178 DEVICE_FLG(0x07fd, 0x000b, /* MOTU M 2178 DEVICE_FLG(0x07fd, 0x000b, /* MOTU M Series 2nd hardware revision */
2179 QUIRK_FLAG_CTL_MSG_DELAY_1 2179 QUIRK_FLAG_CTL_MSG_DELAY_1M),
2180 DEVICE_FLG(0x08bb, 0x2702, /* LineX F 2180 DEVICE_FLG(0x08bb, 0x2702, /* LineX FM Transmitter */
2181 QUIRK_FLAG_IGNORE_CTL_ERRO 2181 QUIRK_FLAG_IGNORE_CTL_ERROR),
2182 DEVICE_FLG(0x0951, 0x16ad, /* Kingsto 2182 DEVICE_FLG(0x0951, 0x16ad, /* Kingston HyperX */
2183 QUIRK_FLAG_CTL_MSG_DELAY_1 2183 QUIRK_FLAG_CTL_MSG_DELAY_1M),
2184 DEVICE_FLG(0x0b0e, 0x0349, /* Jabra 5 2184 DEVICE_FLG(0x0b0e, 0x0349, /* Jabra 550a */
2185 QUIRK_FLAG_CTL_MSG_DELAY_1 2185 QUIRK_FLAG_CTL_MSG_DELAY_1M),
2186 DEVICE_FLG(0x0c45, 0x6340, /* Sonix H 2186 DEVICE_FLG(0x0c45, 0x6340, /* Sonix HD USB Camera */
2187 QUIRK_FLAG_GET_SAMPLE_RATE 2187 QUIRK_FLAG_GET_SAMPLE_RATE),
2188 DEVICE_FLG(0x0ecb, 0x205c, /* JBL Qua 2188 DEVICE_FLG(0x0ecb, 0x205c, /* JBL Quantum610 Wireless */
2189 QUIRK_FLAG_FIXED_RATE), 2189 QUIRK_FLAG_FIXED_RATE),
2190 DEVICE_FLG(0x0ecb, 0x2069, /* JBL Qua 2190 DEVICE_FLG(0x0ecb, 0x2069, /* JBL Quantum810 Wireless */
2191 QUIRK_FLAG_FIXED_RATE), 2191 QUIRK_FLAG_FIXED_RATE),
2192 DEVICE_FLG(0x0fd9, 0x0008, /* Hauppau 2192 DEVICE_FLG(0x0fd9, 0x0008, /* Hauppauge HVR-950Q */
2193 QUIRK_FLAG_SHARE_MEDIA_DEV 2193 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2194 DEVICE_FLG(0x1224, 0x2a25, /* Jieli T 2194 DEVICE_FLG(0x1224, 0x2a25, /* Jieli Technology USB PHY 2.0 */
2195 QUIRK_FLAG_GET_SAMPLE_RATE 2195 QUIRK_FLAG_GET_SAMPLE_RATE),
2196 DEVICE_FLG(0x1395, 0x740a, /* Sennhei 2196 DEVICE_FLG(0x1395, 0x740a, /* Sennheiser DECT */
2197 QUIRK_FLAG_GET_SAMPLE_RATE 2197 QUIRK_FLAG_GET_SAMPLE_RATE),
2198 DEVICE_FLG(0x1397, 0x0507, /* Behring 2198 DEVICE_FLG(0x1397, 0x0507, /* Behringer UMC202HD */
2199 QUIRK_FLAG_PLAYBACK_FIRST 2199 QUIRK_FLAG_PLAYBACK_FIRST | QUIRK_FLAG_GENERIC_IMPLICIT_FB),
2200 DEVICE_FLG(0x1397, 0x0508, /* Behring 2200 DEVICE_FLG(0x1397, 0x0508, /* Behringer UMC204HD */
2201 QUIRK_FLAG_PLAYBACK_FIRST 2201 QUIRK_FLAG_PLAYBACK_FIRST | QUIRK_FLAG_GENERIC_IMPLICIT_FB),
2202 DEVICE_FLG(0x1397, 0x0509, /* Behring 2202 DEVICE_FLG(0x1397, 0x0509, /* Behringer UMC404HD */
2203 QUIRK_FLAG_PLAYBACK_FIRST 2203 QUIRK_FLAG_PLAYBACK_FIRST | QUIRK_FLAG_GENERIC_IMPLICIT_FB),
2204 DEVICE_FLG(0x13e5, 0x0001, /* Serato 2204 DEVICE_FLG(0x13e5, 0x0001, /* Serato Phono */
2205 QUIRK_FLAG_IGNORE_CTL_ERRO 2205 QUIRK_FLAG_IGNORE_CTL_ERROR),
2206 DEVICE_FLG(0x154e, 0x1002, /* Denon D 2206 DEVICE_FLG(0x154e, 0x1002, /* Denon DCD-1500RE */
2207 QUIRK_FLAG_ITF_USB_DSD_DAC 2207 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY),
2208 DEVICE_FLG(0x154e, 0x1003, /* Denon D 2208 DEVICE_FLG(0x154e, 0x1003, /* Denon DA-300USB */
2209 QUIRK_FLAG_ITF_USB_DSD_DAC 2209 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY),
2210 DEVICE_FLG(0x154e, 0x3005, /* Marantz 2210 DEVICE_FLG(0x154e, 0x3005, /* Marantz HD-DAC1 */
2211 QUIRK_FLAG_ITF_USB_DSD_DAC 2211 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY),
2212 DEVICE_FLG(0x154e, 0x3006, /* Marantz 2212 DEVICE_FLG(0x154e, 0x3006, /* Marantz SA-14S1 */
2213 QUIRK_FLAG_ITF_USB_DSD_DAC 2213 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY),
2214 DEVICE_FLG(0x154e, 0x300b, /* Marantz 2214 DEVICE_FLG(0x154e, 0x300b, /* Marantz SA-KI RUBY / SA-12 */
2215 QUIRK_FLAG_DSD_RAW), 2215 QUIRK_FLAG_DSD_RAW),
2216 DEVICE_FLG(0x154e, 0x500e, /* Denon D 2216 DEVICE_FLG(0x154e, 0x500e, /* Denon DN-X1600 */
2217 QUIRK_FLAG_IGNORE_CLOCK_SO 2217 QUIRK_FLAG_IGNORE_CLOCK_SOURCE),
2218 DEVICE_FLG(0x1686, 0x00dd, /* Zoom R1 2218 DEVICE_FLG(0x1686, 0x00dd, /* Zoom R16/24 */
2219 QUIRK_FLAG_TX_LENGTH | QUI 2219 QUIRK_FLAG_TX_LENGTH | QUIRK_FLAG_CTL_MSG_DELAY_1M),
2220 DEVICE_FLG(0x17aa, 0x1046, /* Lenovo 2220 DEVICE_FLG(0x17aa, 0x1046, /* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */
2221 QUIRK_FLAG_DISABLE_AUTOSUS 2221 QUIRK_FLAG_DISABLE_AUTOSUSPEND),
2222 DEVICE_FLG(0x17aa, 0x104d, /* Lenovo 2222 DEVICE_FLG(0x17aa, 0x104d, /* Lenovo ThinkStation P620 Internal Speaker + Front Headset */
2223 QUIRK_FLAG_DISABLE_AUTOSUS 2223 QUIRK_FLAG_DISABLE_AUTOSUSPEND),
2224 DEVICE_FLG(0x1852, 0x5062, /* Luxman 2224 DEVICE_FLG(0x1852, 0x5062, /* Luxman D-08u */
2225 QUIRK_FLAG_ITF_USB_DSD_DAC 2225 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY),
2226 DEVICE_FLG(0x1852, 0x5065, /* Luxman 2226 DEVICE_FLG(0x1852, 0x5065, /* Luxman DA-06 */
2227 QUIRK_FLAG_ITF_USB_DSD_DAC 2227 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY),
2228 DEVICE_FLG(0x1901, 0x0191, /* GE B850 2228 DEVICE_FLG(0x1901, 0x0191, /* GE B850V3 CP2114 audio interface */
2229 QUIRK_FLAG_GET_SAMPLE_RATE 2229 QUIRK_FLAG_GET_SAMPLE_RATE),
2230 DEVICE_FLG(0x19f7, 0x0035, /* RODE NT 2230 DEVICE_FLG(0x19f7, 0x0035, /* RODE NT-USB+ */
2231 QUIRK_FLAG_GET_SAMPLE_RATE 2231 QUIRK_FLAG_GET_SAMPLE_RATE),
2232 DEVICE_FLG(0x1bcf, 0x2281, /* HD Webc 2232 DEVICE_FLG(0x1bcf, 0x2281, /* HD Webcam */
2233 QUIRK_FLAG_GET_SAMPLE_RATE 2233 QUIRK_FLAG_GET_SAMPLE_RATE),
2234 DEVICE_FLG(0x1bcf, 0x2283, /* NexiGo 2234 DEVICE_FLG(0x1bcf, 0x2283, /* NexiGo N930AF FHD Webcam */
2235 QUIRK_FLAG_GET_SAMPLE_RATE 2235 QUIRK_FLAG_GET_SAMPLE_RATE),
2236 DEVICE_FLG(0x2040, 0x7200, /* Hauppau 2236 DEVICE_FLG(0x2040, 0x7200, /* Hauppauge HVR-950Q */
2237 QUIRK_FLAG_SHARE_MEDIA_DEV 2237 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2238 DEVICE_FLG(0x2040, 0x7201, /* Hauppau 2238 DEVICE_FLG(0x2040, 0x7201, /* Hauppauge HVR-950Q-MXL */
2239 QUIRK_FLAG_SHARE_MEDIA_DEV 2239 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2240 DEVICE_FLG(0x2040, 0x7210, /* Hauppau 2240 DEVICE_FLG(0x2040, 0x7210, /* Hauppauge HVR-950Q */
2241 QUIRK_FLAG_SHARE_MEDIA_DEV 2241 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2242 DEVICE_FLG(0x2040, 0x7211, /* Hauppau 2242 DEVICE_FLG(0x2040, 0x7211, /* Hauppauge HVR-950Q-MXL */
2243 QUIRK_FLAG_SHARE_MEDIA_DEV 2243 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2244 DEVICE_FLG(0x2040, 0x7213, /* Hauppau 2244 DEVICE_FLG(0x2040, 0x7213, /* Hauppauge HVR-950Q */
2245 QUIRK_FLAG_SHARE_MEDIA_DEV 2245 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2246 DEVICE_FLG(0x2040, 0x7217, /* Hauppau 2246 DEVICE_FLG(0x2040, 0x7217, /* Hauppauge HVR-950Q */
2247 QUIRK_FLAG_SHARE_MEDIA_DEV 2247 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2248 DEVICE_FLG(0x2040, 0x721b, /* Hauppau 2248 DEVICE_FLG(0x2040, 0x721b, /* Hauppauge HVR-950Q */
2249 QUIRK_FLAG_SHARE_MEDIA_DEV 2249 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2250 DEVICE_FLG(0x2040, 0x721e, /* Hauppau 2250 DEVICE_FLG(0x2040, 0x721e, /* Hauppauge HVR-950Q */
2251 QUIRK_FLAG_SHARE_MEDIA_DEV 2251 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2252 DEVICE_FLG(0x2040, 0x721f, /* Hauppau 2252 DEVICE_FLG(0x2040, 0x721f, /* Hauppauge HVR-950Q */
2253 QUIRK_FLAG_SHARE_MEDIA_DEV 2253 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2254 DEVICE_FLG(0x2040, 0x7240, /* Hauppau 2254 DEVICE_FLG(0x2040, 0x7240, /* Hauppauge HVR-850 */
2255 QUIRK_FLAG_SHARE_MEDIA_DEV 2255 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2256 DEVICE_FLG(0x2040, 0x7260, /* Hauppau 2256 DEVICE_FLG(0x2040, 0x7260, /* Hauppauge HVR-950Q */
2257 QUIRK_FLAG_SHARE_MEDIA_DEV 2257 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2258 DEVICE_FLG(0x2040, 0x7270, /* Hauppau 2258 DEVICE_FLG(0x2040, 0x7270, /* Hauppauge HVR-950Q */
2259 QUIRK_FLAG_SHARE_MEDIA_DEV 2259 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2260 DEVICE_FLG(0x2040, 0x7280, /* Hauppau 2260 DEVICE_FLG(0x2040, 0x7280, /* Hauppauge HVR-950Q */
2261 QUIRK_FLAG_SHARE_MEDIA_DEV 2261 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2262 DEVICE_FLG(0x2040, 0x7281, /* Hauppau 2262 DEVICE_FLG(0x2040, 0x7281, /* Hauppauge HVR-950Q-MXL */
2263 QUIRK_FLAG_SHARE_MEDIA_DEV 2263 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2264 DEVICE_FLG(0x2040, 0x8200, /* Hauppau 2264 DEVICE_FLG(0x2040, 0x8200, /* Hauppauge Woodbury */
2265 QUIRK_FLAG_SHARE_MEDIA_DEV 2265 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),
2266 DEVICE_FLG(0x21b4, 0x0081, /* AudioQu 2266 DEVICE_FLG(0x21b4, 0x0081, /* AudioQuest DragonFly */
2267 QUIRK_FLAG_GET_SAMPLE_RATE 2267 QUIRK_FLAG_GET_SAMPLE_RATE),
2268 DEVICE_FLG(0x21b4, 0x0230, /* Ayre QB 2268 DEVICE_FLG(0x21b4, 0x0230, /* Ayre QB-9 Twenty */
2269 QUIRK_FLAG_DSD_RAW), 2269 QUIRK_FLAG_DSD_RAW),
2270 DEVICE_FLG(0x21b4, 0x0232, /* Ayre QX 2270 DEVICE_FLG(0x21b4, 0x0232, /* Ayre QX-5 Twenty */
2271 QUIRK_FLAG_DSD_RAW), 2271 QUIRK_FLAG_DSD_RAW),
2272 DEVICE_FLG(0x2522, 0x0007, /* LH Labs 2272 DEVICE_FLG(0x2522, 0x0007, /* LH Labs Geek Out HD Audio 1V5 */
2273 QUIRK_FLAG_SET_IFACE_FIRST 2273 QUIRK_FLAG_SET_IFACE_FIRST),
2274 DEVICE_FLG(0x2708, 0x0002, /* Audient 2274 DEVICE_FLG(0x2708, 0x0002, /* Audient iD14 */
2275 QUIRK_FLAG_IGNORE_CTL_ERRO 2275 QUIRK_FLAG_IGNORE_CTL_ERROR),
2276 DEVICE_FLG(0x2912, 0x30c8, /* Audioen 2276 DEVICE_FLG(0x2912, 0x30c8, /* Audioengine D1 */
2277 QUIRK_FLAG_GET_SAMPLE_RATE 2277 QUIRK_FLAG_GET_SAMPLE_RATE),
2278 DEVICE_FLG(0x2b53, 0x0023, /* Fiero S 2278 DEVICE_FLG(0x2b53, 0x0023, /* Fiero SC-01 (firmware v1.0.0 @ 48 kHz) */
2279 QUIRK_FLAG_GENERIC_IMPLICI 2279 QUIRK_FLAG_GENERIC_IMPLICIT_FB),
2280 DEVICE_FLG(0x2b53, 0x0024, /* Fiero S 2280 DEVICE_FLG(0x2b53, 0x0024, /* Fiero SC-01 (firmware v1.0.0 @ 96 kHz) */
2281 QUIRK_FLAG_GENERIC_IMPLICI 2281 QUIRK_FLAG_GENERIC_IMPLICIT_FB),
2282 DEVICE_FLG(0x2b53, 0x0031, /* Fiero S 2282 DEVICE_FLG(0x2b53, 0x0031, /* Fiero SC-01 (firmware v1.1.0) */
2283 QUIRK_FLAG_GENERIC_IMPLICI 2283 QUIRK_FLAG_GENERIC_IMPLICIT_FB),
2284 DEVICE_FLG(0x2d95, 0x8011, /* VIVO US 2284 DEVICE_FLG(0x2d95, 0x8011, /* VIVO USB-C HEADSET */
2285 QUIRK_FLAG_CTL_MSG_DELAY_1 2285 QUIRK_FLAG_CTL_MSG_DELAY_1M),
2286 DEVICE_FLG(0x2d95, 0x8021, /* VIVO US 2286 DEVICE_FLG(0x2d95, 0x8021, /* VIVO USB-C-XE710 HEADSET */
2287 QUIRK_FLAG_CTL_MSG_DELAY_1 2287 QUIRK_FLAG_CTL_MSG_DELAY_1M),
2288 DEVICE_FLG(0x30be, 0x0101, /* Schiit 2288 DEVICE_FLG(0x30be, 0x0101, /* Schiit Hel */
2289 QUIRK_FLAG_IGNORE_CTL_ERRO 2289 QUIRK_FLAG_IGNORE_CTL_ERROR),
2290 DEVICE_FLG(0x413c, 0xa506, /* Dell AE 2290 DEVICE_FLG(0x413c, 0xa506, /* Dell AE515 sound bar */
2291 QUIRK_FLAG_GET_SAMPLE_RATE 2291 QUIRK_FLAG_GET_SAMPLE_RATE),
2292 DEVICE_FLG(0x534d, 0x0021, /* MacroSi 2292 DEVICE_FLG(0x534d, 0x0021, /* MacroSilicon MS2100/MS2106 */
2293 QUIRK_FLAG_ALIGN_TRANSFER) 2293 QUIRK_FLAG_ALIGN_TRANSFER),
2294 DEVICE_FLG(0x534d, 0x2109, /* MacroSi 2294 DEVICE_FLG(0x534d, 0x2109, /* MacroSilicon MS2109 */
2295 QUIRK_FLAG_ALIGN_TRANSFER) 2295 QUIRK_FLAG_ALIGN_TRANSFER),
2296 2296
2297 /* Vendor matches */ 2297 /* Vendor matches */
2298 VENDOR_FLG(0x045e, /* MS Lifecam */ 2298 VENDOR_FLG(0x045e, /* MS Lifecam */
2299 QUIRK_FLAG_GET_SAMPLE_RATE 2299 QUIRK_FLAG_GET_SAMPLE_RATE),
2300 VENDOR_FLG(0x046d, /* Logitech */ 2300 VENDOR_FLG(0x046d, /* Logitech */
2301 QUIRK_FLAG_CTL_MSG_DELAY_1 2301 QUIRK_FLAG_CTL_MSG_DELAY_1M),
2302 VENDOR_FLG(0x047f, /* Plantronics */ 2302 VENDOR_FLG(0x047f, /* Plantronics */
2303 QUIRK_FLAG_GET_SAMPLE_RATE 2303 QUIRK_FLAG_GET_SAMPLE_RATE | QUIRK_FLAG_CTL_MSG_DELAY),
2304 VENDOR_FLG(0x0644, /* TEAC Corp. */ 2304 VENDOR_FLG(0x0644, /* TEAC Corp. */
2305 QUIRK_FLAG_CTL_MSG_DELAY | 2305 QUIRK_FLAG_CTL_MSG_DELAY | QUIRK_FLAG_IFACE_DELAY),
2306 VENDOR_FLG(0x07fd, /* MOTU */ 2306 VENDOR_FLG(0x07fd, /* MOTU */
2307 QUIRK_FLAG_VALIDATE_RATES) 2307 QUIRK_FLAG_VALIDATE_RATES),
2308 VENDOR_FLG(0x1235, /* Focusrite Novat 2308 VENDOR_FLG(0x1235, /* Focusrite Novation */
2309 QUIRK_FLAG_VALIDATE_RATES) 2309 QUIRK_FLAG_VALIDATE_RATES),
2310 VENDOR_FLG(0x1511, /* AURALiC */ 2310 VENDOR_FLG(0x1511, /* AURALiC */
2311 QUIRK_FLAG_DSD_RAW), 2311 QUIRK_FLAG_DSD_RAW),
2312 VENDOR_FLG(0x152a, /* Thesycon device 2312 VENDOR_FLG(0x152a, /* Thesycon devices */
2313 QUIRK_FLAG_DSD_RAW), 2313 QUIRK_FLAG_DSD_RAW),
2314 VENDOR_FLG(0x18d1, /* iBasso devices 2314 VENDOR_FLG(0x18d1, /* iBasso devices */
2315 QUIRK_FLAG_DSD_RAW), 2315 QUIRK_FLAG_DSD_RAW),
2316 VENDOR_FLG(0x1de7, /* Phoenix Audio * 2316 VENDOR_FLG(0x1de7, /* Phoenix Audio */
2317 QUIRK_FLAG_GET_SAMPLE_RATE 2317 QUIRK_FLAG_GET_SAMPLE_RATE),
2318 VENDOR_FLG(0x20b1, /* XMOS based devi 2318 VENDOR_FLG(0x20b1, /* XMOS based devices */
2319 QUIRK_FLAG_DSD_RAW), 2319 QUIRK_FLAG_DSD_RAW),
2320 VENDOR_FLG(0x21ed, /* Accuphase Labor 2320 VENDOR_FLG(0x21ed, /* Accuphase Laboratory */
2321 QUIRK_FLAG_DSD_RAW), 2321 QUIRK_FLAG_DSD_RAW),
2322 VENDOR_FLG(0x22d9, /* Oppo */ 2322 VENDOR_FLG(0x22d9, /* Oppo */
2323 QUIRK_FLAG_DSD_RAW), 2323 QUIRK_FLAG_DSD_RAW),
2324 VENDOR_FLG(0x23ba, /* Playback Design 2324 VENDOR_FLG(0x23ba, /* Playback Design */
2325 QUIRK_FLAG_CTL_MSG_DELAY | 2325 QUIRK_FLAG_CTL_MSG_DELAY | QUIRK_FLAG_IFACE_DELAY |
2326 QUIRK_FLAG_DSD_RAW), 2326 QUIRK_FLAG_DSD_RAW),
2327 VENDOR_FLG(0x25ce, /* Mytek devices * 2327 VENDOR_FLG(0x25ce, /* Mytek devices */
2328 QUIRK_FLAG_DSD_RAW), 2328 QUIRK_FLAG_DSD_RAW),
2329 VENDOR_FLG(0x278b, /* Rotel? */ 2329 VENDOR_FLG(0x278b, /* Rotel? */
2330 QUIRK_FLAG_DSD_RAW), 2330 QUIRK_FLAG_DSD_RAW),
2331 VENDOR_FLG(0x292b, /* Gustard/Ess bas 2331 VENDOR_FLG(0x292b, /* Gustard/Ess based devices */
2332 QUIRK_FLAG_DSD_RAW), 2332 QUIRK_FLAG_DSD_RAW),
2333 VENDOR_FLG(0x2972, /* FiiO devices */ 2333 VENDOR_FLG(0x2972, /* FiiO devices */
2334 QUIRK_FLAG_DSD_RAW), 2334 QUIRK_FLAG_DSD_RAW),
2335 VENDOR_FLG(0x2ab6, /* T+A devices */ 2335 VENDOR_FLG(0x2ab6, /* T+A devices */
2336 QUIRK_FLAG_DSD_RAW), 2336 QUIRK_FLAG_DSD_RAW),
2337 VENDOR_FLG(0x2afd, /* McIntosh Labora 2337 VENDOR_FLG(0x2afd, /* McIntosh Laboratory, Inc. */
2338 QUIRK_FLAG_DSD_RAW), 2338 QUIRK_FLAG_DSD_RAW),
2339 VENDOR_FLG(0x2d87, /* Cayin device */ 2339 VENDOR_FLG(0x2d87, /* Cayin device */
2340 QUIRK_FLAG_DSD_RAW), 2340 QUIRK_FLAG_DSD_RAW),
2341 VENDOR_FLG(0x3336, /* HEM devices */ 2341 VENDOR_FLG(0x3336, /* HEM devices */
2342 QUIRK_FLAG_DSD_RAW), 2342 QUIRK_FLAG_DSD_RAW),
2343 VENDOR_FLG(0x3353, /* Khadas devices 2343 VENDOR_FLG(0x3353, /* Khadas devices */
2344 QUIRK_FLAG_DSD_RAW), 2344 QUIRK_FLAG_DSD_RAW),
2345 VENDOR_FLG(0x35f4, /* MSB Technology 2345 VENDOR_FLG(0x35f4, /* MSB Technology */
2346 QUIRK_FLAG_DSD_RAW), 2346 QUIRK_FLAG_DSD_RAW),
2347 VENDOR_FLG(0x3842, /* EVGA */ 2347 VENDOR_FLG(0x3842, /* EVGA */
2348 QUIRK_FLAG_DSD_RAW), 2348 QUIRK_FLAG_DSD_RAW),
2349 VENDOR_FLG(0xc502, /* HiBy devices */ 2349 VENDOR_FLG(0xc502, /* HiBy devices */
2350 QUIRK_FLAG_DSD_RAW), 2350 QUIRK_FLAG_DSD_RAW),
2351 2351
2352 {} /* terminator */ 2352 {} /* terminator */
2353 }; 2353 };
2354 2354
2355 void snd_usb_init_quirk_flags(struct snd_usb_ 2355 void snd_usb_init_quirk_flags(struct snd_usb_audio *chip)
2356 { 2356 {
2357 const struct usb_audio_quirk_flags_ta 2357 const struct usb_audio_quirk_flags_table *p;
2358 2358
2359 for (p = quirk_flags_table; p->id; p+ 2359 for (p = quirk_flags_table; p->id; p++) {
2360 if (chip->usb_id == p->id || 2360 if (chip->usb_id == p->id ||
2361 (!USB_ID_PRODUCT(p->id) & 2361 (!USB_ID_PRODUCT(p->id) &&
2362 USB_ID_VENDOR(chip->usb_ 2362 USB_ID_VENDOR(chip->usb_id) == USB_ID_VENDOR(p->id))) {
2363 usb_audio_dbg(chip, 2363 usb_audio_dbg(chip,
2364 "Set qu 2364 "Set quirk_flags 0x%x for device %04x:%04x\n",
2365 p->flag 2365 p->flags, USB_ID_VENDOR(chip->usb_id),
2366 USB_ID_ 2366 USB_ID_PRODUCT(chip->usb_id));
2367 chip->quirk_flags |= 2367 chip->quirk_flags |= p->flags;
2368 return; 2368 return;
2369 } 2369 }
2370 } 2370 }
2371 } 2371 }
2372 2372
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.