projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: usb-audio: Sanity checks for each pipe and EP types
[linux-2.6-block.git] / sound / usb / quirks.c
CommitLineData
e5779998
DM		 1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 */
16
17#include <linux/init.h>
36db0456 18#include <linux/slab.h>
e5779998
DM		 19#include <linux/usb.h>
20#include <linux/usb/audio.h>
aafe77cc 21#include <linux/usb/midi.h>
ad43d528 22#include <linux/bits.h>
e5779998 23
9e38658f 24#include <sound/control.h>
e5779998
DM		 25#include <sound/core.h>
26#include <sound/info.h>
27#include <sound/pcm.h>
28
29#include "usbaudio.h"
30#include "card.h"
f0b5e634 31#include "mixer.h"
7b1eda22 32#include "mixer_quirks.h"
e5779998
DM		 33#include "midi.h"
34#include "quirks.h"
35#include "helper.h"
36#include "endpoint.h"
37#include "pcm.h"
3d8d4dcf 38#include "clock.h"
e8e8babf 39#include "stream.h"
e5779998
DM		 40
41/*
42 * handle the quirks for the contained interfaces
43 */
44static int create_composite_quirk(struct snd_usb_audio *chip,
45 struct usb_interface *iface,
46 struct usb_driver *driver,
85a81813 47 const struct snd_usb_audio_quirk *quirk_comp)
e5779998
DM		 48{
49 int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
85a81813 50 const struct snd_usb_audio_quirk *quirk;
e5779998
DM		 51 int err;
52
85a81813 53 for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) {
e5779998
DM		 54 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
55 if (!iface)
56 continue;
57 if (quirk->ifnum != probed_ifnum &&
58 usb_interface_claimed(iface))
59 continue;
60 err = snd_usb_create_quirk(chip, iface, driver, quirk);
61 if (err < 0)
62 return err;
d4b8fc66
TI		 63 }
64
85a81813 65 for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) {
d4b8fc66
TI		 66 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
67 if (!iface)
68 continue;
69 if (quirk->ifnum != probed_ifnum &&
70 !usb_interface_claimed(iface))
e5779998
DM		 71 usb_driver_claim_interface(driver, iface, (void *)-1L);
72 }
d4b8fc66 73
e5779998
DM		 74 return 0;
75}
76
77static int ignore_interface_quirk(struct snd_usb_audio *chip,
78 struct usb_interface *iface,
79 struct usb_driver *driver,
80 const struct snd_usb_audio_quirk *quirk)
81{
82 return 0;
83}
84
85
86/*
87 * Allow alignment on audio sub-slot (channel samples) rather than
88 * on audio slots (audio frames)
89 */
90static int create_align_transfer_quirk(struct snd_usb_audio *chip,
91 struct usb_interface *iface,
92 struct usb_driver *driver,
93 const struct snd_usb_audio_quirk *quirk)
94{
95 chip->txfr_quirk = 1;
96 return 1; /* Continue with creating streams and mixer */
97}
98
99static int create_any_midi_quirk(struct snd_usb_audio *chip,
100 struct usb_interface *intf,
101 struct usb_driver *driver,
102 const struct snd_usb_audio_quirk *quirk)
103{
104 return snd_usbmidi_create(chip->card, intf, &chip->midi_list, quirk);
105}
106
107/*
108 * create a stream for an interface with proper descriptors
109 */
110static int create_standard_audio_quirk(struct snd_usb_audio *chip,
111 struct usb_interface *iface,
112 struct usb_driver *driver,
113 const struct snd_usb_audio_quirk *quirk)
114{
115 struct usb_host_interface *alts;
116 struct usb_interface_descriptor *altsd;
117 int err;
118
e0570446
RW		 119 if (chip->usb_id == USB_ID(0x1686, 0x00dd)) /* Zoom R16/24 */
120 chip->tx_length_quirk = 1;
121
e5779998
DM		 122 alts = &iface->altsetting[0];
123 altsd = get_iface_desc(alts);
e8e8babf 124 err = snd_usb_parse_audio_interface(chip, altsd->bInterfaceNumber);
e5779998 125 if (err < 0) {
0ba41d91 126 usb_audio_err(chip, "cannot setup if %d: error %d\n",
e5779998
DM		 127 altsd->bInterfaceNumber, err);
128 return err;
129 }
130 /* reset the current interface */
131 usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0);
132 return 0;
133}
134
135/*
136 * create a stream for an endpoint/altsetting without proper descriptors
137 */
138static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
139 struct usb_interface *iface,
140 struct usb_driver *driver,
141 const struct snd_usb_audio_quirk *quirk)
142{
143 struct audioformat *fp;
144 struct usb_host_interface *alts;
42d4ab83 145 struct usb_interface_descriptor *altsd;
e5779998
DM		 146 int stream, err;
147 unsigned *rate_table = NULL;
148
149 fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
9ecb2406 150 if (!fp)
e5779998 151 return -ENOMEM;
9ecb2406 152
836b34a9 153 INIT_LIST_HEAD(&fp->list);
8866f405
XW		 154 if (fp->nr_rates > MAX_NR_RATES) {
155 kfree(fp);
156 return -EINVAL;
157 }
e5779998 158 if (fp->nr_rates > 0) {
43df2a57
TM		 159 rate_table = kmemdup(fp->rate_table,
160 sizeof(int) * fp->nr_rates, GFP_KERNEL);
e5779998
DM		 161 if (!rate_table) {
162 kfree(fp);
163 return -ENOMEM;
164 }
e5779998
DM		 165 fp->rate_table = rate_table;
166 }
167
168 stream = (fp->endpoint & USB_DIR_IN)
169 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
e8e8babf 170 err = snd_usb_add_audio_stream(chip, stream, fp);
902eb7fd
TI		 171 if (err < 0)
172 goto error;
e5779998
DM		 173 if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||
174 fp->altset_idx >= iface->num_altsetting) {
902eb7fd
TI		 175 err = -EINVAL;
176 goto error;
e5779998
DM		 177 }
178 alts = &iface->altsetting[fp->altset_idx];
42d4ab83 179 altsd = get_iface_desc(alts);
0f886ca1 180 if (altsd->bNumEndpoints < 1) {
902eb7fd
TI		 181 err = -EINVAL;
182 goto error;
0f886ca1
TI		 183 }
184
42d4ab83
EZ		 185 fp->protocol = altsd->bInterfaceProtocol;
186
59ea586f
MH		 187 if (fp->datainterval == 0)
188 fp->datainterval = snd_usb_parse_datainterval(chip, alts);
189 if (fp->maxpacksize == 0)
190 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
e5779998 191 usb_set_interface(chip->dev, fp->iface, 0);
767d75ad
DM		 192 snd_usb_init_pitch(chip, fp->iface, alts, fp);
193 snd_usb_init_sample_rate(chip, fp->iface, alts, fp, fp->rate_max);
e5779998 194 return 0;
902eb7fd
TI		 195
196 error:
836b34a9 197 list_del(&fp->list); /* unlink for avoiding double-free */
902eb7fd
TI		 198 kfree(fp);
199 kfree(rate_table);
200 return err;
e5779998
DM		 201}
202
aafe77cc
CL		 203static int create_auto_pcm_quirk(struct snd_usb_audio *chip,
204 struct usb_interface *iface,
205 struct usb_driver *driver)
206{
207 struct usb_host_interface *alts;
208 struct usb_interface_descriptor *altsd;
209 struct usb_endpoint_descriptor *epd;
210 struct uac1_as_header_descriptor *ashd;
211 struct uac_format_type_i_discrete_descriptor *fmtd;
212
213 /*
214 * Most Roland/Yamaha audio streaming interfaces have more or less
215 * standard descriptors, but older devices might lack descriptors, and
216 * future ones might change, so ensure that we fail silently if the
217 * interface doesn't look exactly right.
218 */
219
220 /* must have a non-zero altsetting for streaming */
221 if (iface->num_altsetting < 2)
222 return -ENODEV;
223 alts = &iface->altsetting[1];
224 altsd = get_iface_desc(alts);
225
226 /* must have an isochronous endpoint for streaming */
227 if (altsd->bNumEndpoints < 1)
228 return -ENODEV;
229 epd = get_endpoint(alts, 0);
230 if (!usb_endpoint_xfer_isoc(epd))
231 return -ENODEV;
232
233 /* must have format descriptors */
234 ashd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
235 UAC_AS_GENERAL);
236 fmtd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
237 UAC_FORMAT_TYPE);
238 if (!ashd || ashd->bLength < 7 ||
239 !fmtd || fmtd->bLength < 8)
240 return -ENODEV;
241
242 return create_standard_audio_quirk(chip, iface, driver, NULL);
243}
244
245static int create_yamaha_midi_quirk(struct snd_usb_audio *chip,
246 struct usb_interface *iface,
247 struct usb_driver *driver,
248 struct usb_host_interface *alts)
249{
250 static const struct snd_usb_audio_quirk yamaha_midi_quirk = {
251 .type = QUIRK_MIDI_YAMAHA
252 };
253 struct usb_midi_in_jack_descriptor *injd;
254 struct usb_midi_out_jack_descriptor *outjd;
255
256 /* must have some valid jack descriptors */
257 injd = snd_usb_find_csint_desc(alts->extra, alts->extralen,
258 NULL, USB_MS_MIDI_IN_JACK);
259 outjd = snd_usb_find_csint_desc(alts->extra, alts->extralen,
260 NULL, USB_MS_MIDI_OUT_JACK);
261 if (!injd && !outjd)
262 return -ENODEV;
263 if (injd && (injd->bLength < 5 ||
264 (injd->bJackType != USB_MS_EMBEDDED &&
265 injd->bJackType != USB_MS_EXTERNAL)))
266 return -ENODEV;
267 if (outjd && (outjd->bLength < 6 ||
268 (outjd->bJackType != USB_MS_EMBEDDED &&
269 outjd->bJackType != USB_MS_EXTERNAL)))
270 return -ENODEV;
271 return create_any_midi_quirk(chip, iface, driver, &yamaha_midi_quirk);
272}
273
274static int create_roland_midi_quirk(struct snd_usb_audio *chip,
275 struct usb_interface *iface,
276 struct usb_driver *driver,
277 struct usb_host_interface *alts)
278{
279 static const struct snd_usb_audio_quirk roland_midi_quirk = {
280 .type = QUIRK_MIDI_ROLAND
281 };
282 u8 *roland_desc = NULL;
283
284 /* might have a vendor-specific descriptor <06 24 F1 02 ...> */
285 for (;;) {
286 roland_desc = snd_usb_find_csint_desc(alts->extra,
287 alts->extralen,
288 roland_desc, 0xf1);
289 if (!roland_desc)
290 return -ENODEV;
291 if (roland_desc[0] < 6 || roland_desc[3] != 2)
292 continue;
293 return create_any_midi_quirk(chip, iface, driver,
294 &roland_midi_quirk);
295 }
296}
297
298static int create_std_midi_quirk(struct snd_usb_audio *chip,
299 struct usb_interface *iface,
300 struct usb_driver *driver,
301 struct usb_host_interface *alts)
302{
303 struct usb_ms_header_descriptor *mshd;
304 struct usb_ms_endpoint_descriptor *msepd;
305
306 /* must have the MIDIStreaming interface header descriptor*/
307 mshd = (struct usb_ms_header_descriptor *)alts->extra;
308 if (alts->extralen < 7 ||
309 mshd->bLength < 7 ||
310 mshd->bDescriptorType != USB_DT_CS_INTERFACE ||
311 mshd->bDescriptorSubtype != USB_MS_HEADER)
312 return -ENODEV;
313 /* must have the MIDIStreaming endpoint descriptor*/
314 msepd = (struct usb_ms_endpoint_descriptor *)alts->endpoint[0].extra;
315 if (alts->endpoint[0].extralen < 4 ||
316 msepd->bLength < 4 ||
317 msepd->bDescriptorType != USB_DT_CS_ENDPOINT ||
318 msepd->bDescriptorSubtype != UAC_MS_GENERAL ||
319 msepd->bNumEmbMIDIJack < 1 ||
320 msepd->bNumEmbMIDIJack > 16)
321 return -ENODEV;
322
323 return create_any_midi_quirk(chip, iface, driver, NULL);
324}
325
326static int create_auto_midi_quirk(struct snd_usb_audio *chip,
327 struct usb_interface *iface,
328 struct usb_driver *driver)
329{
330 struct usb_host_interface *alts;
331 struct usb_interface_descriptor *altsd;
332 struct usb_endpoint_descriptor *epd;
333 int err;
334
335 alts = &iface->altsetting[0];
336 altsd = get_iface_desc(alts);
337
338 /* must have at least one bulk/interrupt endpoint for streaming */
339 if (altsd->bNumEndpoints < 1)
340 return -ENODEV;
341 epd = get_endpoint(alts, 0);
aa773bfe 342 if (!usb_endpoint_xfer_bulk(epd) &&
aafe77cc
CL		 343 !usb_endpoint_xfer_int(epd))
344 return -ENODEV;
345
346 switch (USB_ID_VENDOR(chip->usb_id)) {
347 case 0x0499: /* Yamaha */
348 err = create_yamaha_midi_quirk(chip, iface, driver, alts);
aa773bfe 349 if (err != -ENODEV)
aafe77cc
CL		 350 return err;
351 break;
352 case 0x0582: /* Roland */
353 err = create_roland_midi_quirk(chip, iface, driver, alts);
aa773bfe 354 if (err != -ENODEV)
aafe77cc
CL		 355 return err;
356 break;
357 }
358
359 return create_std_midi_quirk(chip, iface, driver, alts);
360}
361
362static int create_autodetect_quirk(struct snd_usb_audio *chip,
363 struct usb_interface *iface,
b1ce7ba6 364 struct usb_driver *driver)
aafe77cc
CL		 365{
366 int err;
367
368 err = create_auto_pcm_quirk(chip, iface, driver);
369 if (err == -ENODEV)
370 err = create_auto_midi_quirk(chip, iface, driver);
371 return err;
372}
373
b1ce7ba6
CL		 374static int create_autodetect_quirks(struct snd_usb_audio *chip,
375 struct usb_interface *iface,
376 struct usb_driver *driver,
377 const struct snd_usb_audio_quirk *quirk)
378{
379 int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
380 int ifcount, ifnum, err;
381
382 err = create_autodetect_quirk(chip, iface, driver);
383 if (err < 0)
384 return err;
385
386 /*
387 * ALSA PCM playback/capture devices cannot be registered in two steps,
388 * so we have to claim the other corresponding interface here.
389 */
390 ifcount = chip->dev->actconfig->desc.bNumInterfaces;
391 for (ifnum = 0; ifnum < ifcount; ifnum++) {
392 if (ifnum == probed_ifnum || quirk->ifnum >= 0)
393 continue;
394 iface = usb_ifnum_to_if(chip->dev, ifnum);
395 if (!iface ||
396 usb_interface_claimed(iface) ||
397 get_iface_desc(iface->altsetting)->bInterfaceClass !=
398 USB_CLASS_VENDOR_SPEC)
399 continue;
400
401 err = create_autodetect_quirk(chip, iface, driver);
402 if (err >= 0)
403 usb_driver_claim_interface(driver, iface, (void *)-1L);
404 }
405
406 return 0;
407}
408
e5779998
DM		 409/*
410 * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface.
411 * The only way to detect the sample rate is by looking at wMaxPacketSize.
412 */
413static int create_uaxx_quirk(struct snd_usb_audio *chip,
414 struct usb_interface *iface,
415 struct usb_driver *driver,
416 const struct snd_usb_audio_quirk *quirk)
417{
418 static const struct audioformat ua_format = {
015eb0b0 419 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
e5779998
DM		 420 .channels = 2,
421 .fmt_type = UAC_FORMAT_TYPE_I,
422 .altsetting = 1,
423 .altset_idx = 1,
424 .rates = SNDRV_PCM_RATE_CONTINUOUS,
425 };
426 struct usb_host_interface *alts;
427 struct usb_interface_descriptor *altsd;
428 struct audioformat *fp;
429 int stream, err;
430
431 /* both PCM and MIDI interfaces have 2 or more altsettings */
432 if (iface->num_altsetting < 2)
433 return -ENXIO;
434 alts = &iface->altsetting[1];
435 altsd = get_iface_desc(alts);
436
437 if (altsd->bNumEndpoints == 2) {
438 static const struct snd_usb_midi_endpoint_info ua700_ep = {
439 .out_cables = 0x0003,
440 .in_cables = 0x0003
441 };
442 static const struct snd_usb_audio_quirk ua700_quirk = {
443 .type = QUIRK_MIDI_FIXED_ENDPOINT,
444 .data = &ua700_ep
445 };
446 static const struct snd_usb_midi_endpoint_info uaxx_ep = {
447 .out_cables = 0x0001,
448 .in_cables = 0x0001
449 };
450 static const struct snd_usb_audio_quirk uaxx_quirk = {
451 .type = QUIRK_MIDI_FIXED_ENDPOINT,
452 .data = &uaxx_ep
453 };
454 const struct snd_usb_audio_quirk *quirk =
455 chip->usb_id == USB_ID(0x0582, 0x002b)
456 ? &ua700_quirk : &uaxx_quirk;
79289e24
TI		 457 return __snd_usbmidi_create(chip->card, iface,
458 &chip->midi_list, quirk,
459 chip->usb_id);
e5779998
DM		 460 }
461
462 if (altsd->bNumEndpoints != 1)
463 return -ENXIO;
464
43df2a57 465 fp = kmemdup(&ua_format, sizeof(*fp), GFP_KERNEL);
e5779998
DM		 466 if (!fp)
467 return -ENOMEM;
e5779998
DM		 468
469 fp->iface = altsd->bInterfaceNumber;
470 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
471 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
472 fp->datainterval = 0;
473 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
836b34a9 474 INIT_LIST_HEAD(&fp->list);
e5779998
DM		 475
476 switch (fp->maxpacksize) {
477 case 0x120:
478 fp->rate_max = fp->rate_min = 44100;
479 break;
480 case 0x138:
481 case 0x140:
482 fp->rate_max = fp->rate_min = 48000;
483 break;
484 case 0x258:
485 case 0x260:
486 fp->rate_max = fp->rate_min = 96000;
487 break;
488 default:
0ba41d91 489 usb_audio_err(chip, "unknown sample rate\n");
e5779998
DM		 490 kfree(fp);
491 return -ENXIO;
492 }
493
494 stream = (fp->endpoint & USB_DIR_IN)
495 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
e8e8babf 496 err = snd_usb_add_audio_stream(chip, stream, fp);
e5779998 497 if (err < 0) {
836b34a9 498 list_del(&fp->list); /* unlink for avoiding double-free */
e5779998
DM		 499 kfree(fp);
500 return err;
501 }
502 usb_set_interface(chip->dev, fp->iface, 0);
503 return 0;
504}
505
014950b0
DM		 506/*
507 * Create a standard mixer for the specified interface.
508 */
509static int create_standard_mixer_quirk(struct snd_usb_audio *chip,
510 struct usb_interface *iface,
511 struct usb_driver *driver,
512 const struct snd_usb_audio_quirk *quirk)
513{
514 if (quirk->ifnum < 0)
515 return 0;
516
517 return snd_usb_create_mixer(chip, quirk->ifnum, 0);
518}
519
e5779998
DM		 520/*
521 * audio-interface quirks
522 *
523 * returns zero if no standard audio/MIDI parsing is needed.
25985edc 524 * returns a positive value if standard audio/midi interfaces are parsed
e5779998
DM		 525 * after this.
526 * returns a negative value at error.
527 */
528int snd_usb_create_quirk(struct snd_usb_audio *chip,
529 struct usb_interface *iface,
530 struct usb_driver *driver,
531 const struct snd_usb_audio_quirk *quirk)
532{
533 typedef int (*quirk_func_t)(struct snd_usb_audio *,
534 struct usb_interface *,
535 struct usb_driver *,
536 const struct snd_usb_audio_quirk *);
537 static const quirk_func_t quirk_funcs[] = {
538 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
539 [QUIRK_COMPOSITE] = create_composite_quirk,
b1ce7ba6 540 [QUIRK_AUTODETECT] = create_autodetect_quirks,
e5779998
DM		 541 [QUIRK_MIDI_STANDARD_INTERFACE] = create_any_midi_quirk,
542 [QUIRK_MIDI_FIXED_ENDPOINT] = create_any_midi_quirk,
543 [QUIRK_MIDI_YAMAHA] = create_any_midi_quirk,
aafe77cc 544 [QUIRK_MIDI_ROLAND] = create_any_midi_quirk,
e5779998
DM		 545 [QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk,
546 [QUIRK_MIDI_NOVATION] = create_any_midi_quirk,
c7f57216 547 [QUIRK_MIDI_RAW_BYTES] = create_any_midi_quirk,
e5779998
DM		 548 [QUIRK_MIDI_EMAGIC] = create_any_midi_quirk,
549 [QUIRK_MIDI_CME] = create_any_midi_quirk,
4434ade8 550 [QUIRK_MIDI_AKAI] = create_any_midi_quirk,
1ef0e0a0 551 [QUIRK_MIDI_FTDI] = create_any_midi_quirk,
1ca8b201 552 [QUIRK_MIDI_CH345] = create_any_midi_quirk,
e5779998
DM		 553 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
554 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
555 [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk,
014950b0
DM		 556 [QUIRK_AUDIO_ALIGN_TRANSFER] = create_align_transfer_quirk,
557 [QUIRK_AUDIO_STANDARD_MIXER] = create_standard_mixer_quirk,
e5779998
DM		 558 };
559
560 if (quirk->type < QUIRK_TYPE_COUNT) {
561 return quirk_funcs[quirk->type](chip, iface, driver, quirk);
562 } else {
0ba41d91 563 usb_audio_err(chip, "invalid quirk type %d\n", quirk->type);
e5779998
DM		 564 return -ENXIO;
565 }
566}
567
568/*
569 * boot quirks
570 */
571
572#define EXTIGY_FIRMWARE_SIZE_OLD 794
573#define EXTIGY_FIRMWARE_SIZE_NEW 483
574
575static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)
576{
577 struct usb_host_config *config = dev->actconfig;
578 int err;
579
580 if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
581 le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
0ba41d91 582 dev_dbg(&dev->dev, "sending Extigy boot sequence...\n");
e5779998
DM		 583 /* Send message to force it to reconnect with full interface. */
584 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
17d900c4 585 0x10, 0x43, 0x0001, 0x000a, NULL, 0);
0ba41d91
TI		 586 if (err < 0)
587 dev_dbg(&dev->dev, "error sending boot message: %d\n", err);
e5779998
DM		 588 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
589 &dev->descriptor, sizeof(dev->descriptor));
590 config = dev->actconfig;
0ba41d91
TI		 591 if (err < 0)
592 dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);
e5779998 593 err = usb_reset_configuration(dev);
0ba41d91
TI		 594 if (err < 0)
595 dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);
596 dev_dbg(&dev->dev, "extigy_boot: new boot length = %d\n",
e5779998
DM		 597 le16_to_cpu(get_cfg_desc(config)->wTotalLength));
598 return -ENODEV; /* quit this anyway */
599 }
600 return 0;
601}
602
603static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
604{
605 u8 buf = 1;
606
607 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,
608 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
17d900c4 609 0, 0, &buf, 1);
e5779998
DM		 610 if (buf == 0) {
611 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,
612 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
17d900c4 613 1, 2000, NULL, 0);
e5779998
DM		 614 return -ENODEV;
615 }
616 return 0;
617}
618
0f5733b0
GP		 619static int snd_usb_fasttrackpro_boot_quirk(struct usb_device *dev)
620{
621 int err;
622
623 if (dev->actconfig->desc.bConfigurationValue == 1) {
0ba41d91 624 dev_info(&dev->dev,
0f5733b0
GP		 625 "Fast Track Pro switching to config #2\n");
626 /* This function has to be available by the usb core module.
627 * if it is not avialable the boot quirk has to be left out
628 * and the configuration has to be set by udev or hotplug
629 * rules
630 */
631 err = usb_driver_set_configuration(dev, 2);
b98ae272 632 if (err < 0)
0ba41d91
TI		 633 dev_dbg(&dev->dev,
634 "error usb_driver_set_configuration: %d\n",
635 err);
b98ae272
DH		 636 /* Always return an error, so that we stop creating a device
637 that will just be destroyed and recreated with a new
638 configuration */
639 return -ENODEV;
0f5733b0 640 } else
0ba41d91 641 dev_info(&dev->dev, "Fast Track Pro config OK\n");
0f5733b0
GP		 642
643 return 0;
644}
645
e5779998
DM		 646/*
647 * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely
648 * documented in the device's data sheet.
649 */
650static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value)
651{
652 u8 buf[4];
653 buf[0] = 0x20;
654 buf[1] = value & 0xff;
655 buf[2] = (value >> 8) & 0xff;
656 buf[3] = reg;
657 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION,
658 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
17d900c4 659 0, 0, &buf, 4);
e5779998
DM		 660}
661
662static int snd_usb_cm106_boot_quirk(struct usb_device *dev)
663{
664 /*
665 * Enable line-out driver mode, set headphone source to front
666 * channels, enable stereo mic.
667 */
668 return snd_usb_cm106_write_int_reg(dev, 2, 0x8004);
669}
670
671/*
ad43d528 672 * CM6206 registers from the CM6206 datasheet rev 2.1
e5779998 673 */
ad43d528
LW		 674#define CM6206_REG0_DMA_MASTER BIT(15)
675#define CM6206_REG0_SPDIFO_RATE_48K (2 << 12)
676#define CM6206_REG0_SPDIFO_RATE_96K (7 << 12)
677/* Bit 4 thru 11 is the S/PDIF category code */
678#define CM6206_REG0_SPDIFO_CAT_CODE_GENERAL (0 << 4)
679#define CM6206_REG0_SPDIFO_EMPHASIS_CD BIT(3)
680#define CM6206_REG0_SPDIFO_COPYRIGHT_NA BIT(2)
681#define CM6206_REG0_SPDIFO_NON_AUDIO BIT(1)
682#define CM6206_REG0_SPDIFO_PRO_FORMAT BIT(0)
683
684#define CM6206_REG1_TEST_SEL_CLK BIT(14)
685#define CM6206_REG1_PLLBIN_EN BIT(13)
686#define CM6206_REG1_SOFT_MUTE_EN BIT(12)
687#define CM6206_REG1_GPIO4_OUT BIT(11)
688#define CM6206_REG1_GPIO4_OE BIT(10)
689#define CM6206_REG1_GPIO3_OUT BIT(9)
690#define CM6206_REG1_GPIO3_OE BIT(8)
691#define CM6206_REG1_GPIO2_OUT BIT(7)
692#define CM6206_REG1_GPIO2_OE BIT(6)
693#define CM6206_REG1_GPIO1_OUT BIT(5)
694#define CM6206_REG1_GPIO1_OE BIT(4)
695#define CM6206_REG1_SPDIFO_INVALID BIT(3)
696#define CM6206_REG1_SPDIF_LOOP_EN BIT(2)
697#define CM6206_REG1_SPDIFO_DIS BIT(1)
698#define CM6206_REG1_SPDIFI_MIX BIT(0)
699
700#define CM6206_REG2_DRIVER_ON BIT(15)
701#define CM6206_REG2_HEADP_SEL_SIDE_CHANNELS (0 << 13)
702#define CM6206_REG2_HEADP_SEL_SURROUND_CHANNELS (1 << 13)
703#define CM6206_REG2_HEADP_SEL_CENTER_SUBW (2 << 13)
704#define CM6206_REG2_HEADP_SEL_FRONT_CHANNELS (3 << 13)
705#define CM6206_REG2_MUTE_HEADPHONE_RIGHT BIT(12)
706#define CM6206_REG2_MUTE_HEADPHONE_LEFT BIT(11)
707#define CM6206_REG2_MUTE_REAR_SURROUND_RIGHT BIT(10)
708#define CM6206_REG2_MUTE_REAR_SURROUND_LEFT BIT(9)
709#define CM6206_REG2_MUTE_SIDE_SURROUND_RIGHT BIT(8)
710#define CM6206_REG2_MUTE_SIDE_SURROUND_LEFT BIT(7)
711#define CM6206_REG2_MUTE_SUBWOOFER BIT(6)
712#define CM6206_REG2_MUTE_CENTER BIT(5)
713#define CM6206_REG2_MUTE_RIGHT_FRONT BIT(3)
714#define CM6206_REG2_MUTE_LEFT_FRONT BIT(3)
715#define CM6206_REG2_EN_BTL BIT(2)
716#define CM6206_REG2_MCUCLKSEL_1_5_MHZ (0)
717#define CM6206_REG2_MCUCLKSEL_3_MHZ (1)
718#define CM6206_REG2_MCUCLKSEL_6_MHZ (2)
719#define CM6206_REG2_MCUCLKSEL_12_MHZ (3)
720
721/* Bit 11..13 sets the sensitivity to FLY tuner volume control VP/VD signal */
722#define CM6206_REG3_FLYSPEED_DEFAULT (2 << 11)
723#define CM6206_REG3_VRAP25EN BIT(10)
724#define CM6206_REG3_MSEL1 BIT(9)
725#define CM6206_REG3_SPDIFI_RATE_44_1K BIT(0 << 7)
726#define CM6206_REG3_SPDIFI_RATE_48K BIT(2 << 7)
727#define CM6206_REG3_SPDIFI_RATE_32K BIT(3 << 7)
728#define CM6206_REG3_PINSEL BIT(6)
729#define CM6206_REG3_FOE BIT(5)
730#define CM6206_REG3_ROE BIT(4)
731#define CM6206_REG3_CBOE BIT(3)
732#define CM6206_REG3_LOSE BIT(2)
733#define CM6206_REG3_HPOE BIT(1)
734#define CM6206_REG3_SPDIFI_CANREC BIT(0)
735
736#define CM6206_REG5_DA_RSTN BIT(13)
737#define CM6206_REG5_AD_RSTN BIT(12)
738#define CM6206_REG5_SPDIFO_AD2SPDO BIT(12)
739#define CM6206_REG5_SPDIFO_SEL_FRONT (0 << 9)
740#define CM6206_REG5_SPDIFO_SEL_SIDE_SUR (1 << 9)
741#define CM6206_REG5_SPDIFO_SEL_CEN_LFE (2 << 9)
742#define CM6206_REG5_SPDIFO_SEL_REAR_SUR (3 << 9)
743#define CM6206_REG5_CODECM BIT(8)
744#define CM6206_REG5_EN_HPF BIT(7)
745#define CM6206_REG5_T_SEL_DSDA4 BIT(6)
746#define CM6206_REG5_T_SEL_DSDA3 BIT(5)
747#define CM6206_REG5_T_SEL_DSDA2 BIT(4)
748#define CM6206_REG5_T_SEL_DSDA1 BIT(3)
749#define CM6206_REG5_T_SEL_DSDAD_NORMAL 0
750#define CM6206_REG5_T_SEL_DSDAD_FRONT 4
751#define CM6206_REG5_T_SEL_DSDAD_S_SURROUND 5
752#define CM6206_REG5_T_SEL_DSDAD_CEN_LFE 6
753#define CM6206_REG5_T_SEL_DSDAD_R_SURROUND 7
754
e5779998
DM		 755static int snd_usb_cm6206_boot_quirk(struct usb_device *dev)
756{
dac8f847 757 int err = 0, reg;
ad43d528
LW		 758 int val[] = {
759 /*
760 * Values here are chosen based on sniffing USB traffic
761 * under Windows.
762 *
763 * REG0: DAC is master, sample rate 48kHz, no copyright
764 */
765 CM6206_REG0_SPDIFO_RATE_48K |
766 CM6206_REG0_SPDIFO_COPYRIGHT_NA,
767 /*
768 * REG1: PLL binary search enable, soft mute enable.
769 */
770 CM6206_REG1_PLLBIN_EN |
f5c9571e 771 CM6206_REG1_SOFT_MUTE_EN,
ad43d528
LW		 772 /*
773 * REG2: enable output drivers,
774 * select front channels to the headphone output,
775 * then mute the headphone channels, run the MCU
776 * at 1.5 MHz.
777 */
778 CM6206_REG2_DRIVER_ON |
779 CM6206_REG2_HEADP_SEL_FRONT_CHANNELS |
780 CM6206_REG2_MUTE_HEADPHONE_RIGHT |
781 CM6206_REG2_MUTE_HEADPHONE_LEFT,
782 /*
783 * REG3: default flyspeed, set 2.5V mic bias
784 * enable all line out ports and enable SPDIF
785 */
786 CM6206_REG3_FLYSPEED_DEFAULT |
787 CM6206_REG3_VRAP25EN |
788 CM6206_REG3_FOE |
789 CM6206_REG3_ROE |
790 CM6206_REG3_CBOE |
791 CM6206_REG3_LOSE |
792 CM6206_REG3_HPOE |
793 CM6206_REG3_SPDIFI_CANREC,
794 /* REG4 is just a bunch of GPIO lines */
795 0x0000,
796 /* REG5: de-assert AD/DA reset signals */
797 CM6206_REG5_DA_RSTN |
798 CM6206_REG5_AD_RSTN };
e5779998
DM		 799
800 for (reg = 0; reg < ARRAY_SIZE(val); reg++) {
801 err = snd_usb_cm106_write_int_reg(dev, reg, val[reg]);
802 if (err < 0)
803 return err;
804 }
805
806 return err;
807}
808
19570d74
TI		 809/* quirk for Plantronics GameCom 780 with CM6302 chip */
810static int snd_usb_gamecon780_boot_quirk(struct usb_device *dev)
811{
812 /* set the initial volume and don't change; other values are either
813 * too loud or silent due to firmware bug (bko#65251)
814 */
542baf94 815 u8 buf[2] = { 0x74, 0xe3 };
19570d74
TI		 816 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
817 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
818 UAC_FU_VOLUME << 8, 9 << 8, buf, 2);
819}
820
5e212332
MH		 821/*
822 * Novation Twitch DJ controller
11e424e8 823 * Focusrite Novation Saffire 6 USB audio card
5e212332 824 */
11e424e8 825static int snd_usb_novation_boot_quirk(struct usb_device *dev)
5e212332
MH		 826{
827 /* preemptively set up the device because otherwise the
828 * raw MIDI endpoints are not active */
829 usb_set_interface(dev, 0, 1);
830 return 0;
831}
832
e5779998
DM		 833/*
834 * This call will put the synth in "USB send" mode, i.e it will send MIDI
835 * messages through USB (this is disabled at startup). The synth will
836 * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB
837 * sign on its LCD. Values here are chosen based on sniffing USB traffic
838 * under Windows.
839 */
840static int snd_usb_accessmusic_boot_quirk(struct usb_device *dev)
841{
842 int err, actual_length;
e5779998
DM		 843 /* "midi send" enable */
844 static const u8 seq[] = { 0x4e, 0x73, 0x52, 0x01 };
801ebf10 845 void *buf;
e5779998 846
801ebf10
TI		 847 if (snd_usb_pipe_sanity_check(dev, usb_sndintpipe(dev, 0x05)))
848 return -EINVAL;
849 buf = kmemdup(seq, ARRAY_SIZE(seq), GFP_KERNEL);
e5779998
DM		 850 if (!buf)
851 return -ENOMEM;
852 err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x05), buf,
853 ARRAY_SIZE(seq), &actual_length, 1000);
854 kfree(buf);
855 if (err < 0)
856 return err;
857
858 return 0;
859}
860
54a8c500
DM		 861/*
862 * Some sound cards from Native Instruments are in fact compliant to the USB
863 * audio standard of version 2 and other approved USB standards, even though
864 * they come up as vendor-specific device when first connected.
865 *
866 * However, they can be told to come up with a new set of descriptors
867 * upon their next enumeration, and the interfaces announced by the new
868 * descriptors will then be handled by the kernel's class drivers. As the
869 * product ID will also change, no further checks are required.
870 */
871
872static int snd_usb_nativeinstruments_boot_quirk(struct usb_device *dev)
873{
801ebf10
TI		 874 int ret;
875
876 if (snd_usb_pipe_sanity_check(dev, usb_sndctrlpipe(dev, 0)))
877 return -EINVAL;
878 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
54a8c500 879 0xaf, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
889d6684 880 1, 0, NULL, 0, 1000);
54a8c500
DM		 881
882 if (ret < 0)
883 return ret;
884
885 usb_reset_device(dev);
886
887 /* return -EAGAIN, so the creation of an audio interface for this
888 * temporary device is aborted. The device will reconnect with a
889 * new product ID */
890 return -EAGAIN;
891}
892
cb99864d
DZ		 893static void mbox2_setup_48_24_magic(struct usb_device *dev)
894{
895 u8 srate[3];
896 u8 temp[12];
897
898 /* Choose 48000Hz permanently */
899 srate[0] = 0x80;
900 srate[1] = 0xbb;
901 srate[2] = 0x00;
902
903 /* Send the magic! */
904 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
905 0x01, 0x22, 0x0100, 0x0085, &temp, 0x0003);
906 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
907 0x81, 0xa2, 0x0100, 0x0085, &srate, 0x0003);
908 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
909 0x81, 0xa2, 0x0100, 0x0086, &srate, 0x0003);
910 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
911 0x81, 0xa2, 0x0100, 0x0003, &srate, 0x0003);
912 return;
913}
914
915/* Digidesign Mbox 2 needs to load firmware onboard
916 * and driver must wait a few seconds for initialisation.
917 */
918
919#define MBOX2_FIRMWARE_SIZE 646
920#define MBOX2_BOOT_LOADING 0x01 /* Hard coded into the device */
921#define MBOX2_BOOT_READY 0x02 /* Hard coded into the device */
922
b7b435e8 923static int snd_usb_mbox2_boot_quirk(struct usb_device *dev)
cb99864d
DZ		 924{
925 struct usb_host_config *config = dev->actconfig;
926 int err;
4909a0ca 927 u8 bootresponse[0x12];
cb99864d
DZ		 928 int fwsize;
929 int count;
930
931 fwsize = le16_to_cpu(get_cfg_desc(config)->wTotalLength);
932
933 if (fwsize != MBOX2_FIRMWARE_SIZE) {
0ba41d91 934 dev_err(&dev->dev, "Invalid firmware size=%d.\n", fwsize);
cb99864d
DZ		 935 return -ENODEV;
936 }
937
0ba41d91 938 dev_dbg(&dev->dev, "Sending Digidesign Mbox 2 boot sequence...\n");
cb99864d
DZ		 939
940 count = 0;
b7b435e8
DZ		 941 bootresponse[0] = MBOX2_BOOT_LOADING;
942 while ((bootresponse[0] == MBOX2_BOOT_LOADING) && (count < 10)) {
cb99864d
DZ		 943 msleep(500); /* 0.5 second delay */
944 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
945 /* Control magic - load onboard firmware */
946 0x85, 0xc0, 0x0001, 0x0000, &bootresponse, 0x0012);
b7b435e8 947 if (bootresponse[0] == MBOX2_BOOT_READY)
cb99864d 948 break;
0ba41d91 949 dev_dbg(&dev->dev, "device not ready, resending boot sequence...\n");
cb99864d
DZ		 950 count++;
951 }
952
b7b435e8 953 if (bootresponse[0] != MBOX2_BOOT_READY) {
0ba41d91 954 dev_err(&dev->dev, "Unknown bootresponse=%d, or timed out, ignoring device.\n", bootresponse[0]);
cb99864d
DZ		 955 return -ENODEV;
956 }
957
0ba41d91 958 dev_dbg(&dev->dev, "device initialised!\n");
cb99864d
DZ		 959
960 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
961 &dev->descriptor, sizeof(dev->descriptor));
962 config = dev->actconfig;
963 if (err < 0)
0ba41d91 964 dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);
cb99864d
DZ		 965
966 err = usb_reset_configuration(dev);
967 if (err < 0)
0ba41d91
TI		 968 dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);
969 dev_dbg(&dev->dev, "mbox2_boot: new boot length = %d\n",
cb99864d
DZ		 970 le16_to_cpu(get_cfg_desc(config)->wTotalLength));
971
972 mbox2_setup_48_24_magic(dev);
973
0ba41d91 974 dev_info(&dev->dev, "Digidesign Mbox 2: 24bit 48kHz");
cb99864d
DZ		 975
976 return 0; /* Successful boot */
977}
978
16bafa79
AA		 979static int snd_usb_axefx3_boot_quirk(struct usb_device *dev)
980{
981 int err;
982
983 dev_dbg(&dev->dev, "Waiting for Axe-Fx III to boot up...\n");
984
801ebf10
TI		 985 if (snd_usb_pipe_sanity_check(dev, usb_sndctrlpipe(dev, 0)))
986 return -EINVAL;
16bafa79
AA		 987 /* If the Axe-Fx III has not fully booted, it will timeout when trying
988 * to enable the audio streaming interface. A more generous timeout is
989 * used here to detect when the Axe-Fx III has finished booting as the
990 * set interface message will be acked once it has
991 */
992 err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
993 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
994 1, 1, NULL, 0, 120000);
995 if (err < 0) {
996 dev_err(&dev->dev,
997 "failed waiting for Axe-Fx III to boot: %d\n", err);
998 return err;
999 }
1000
1001 dev_dbg(&dev->dev, "Axe-Fx III is now ready\n");
1002
1003 err = usb_set_interface(dev, 1, 0);
1004 if (err < 0)
1005 dev_dbg(&dev->dev,
1006 "error stopping Axe-Fx III interface: %d\n", err);
1007
1008 return 0;
1009}
1010
a634090a
MR		 1011
1012#define MICROBOOK_BUF_SIZE 128
1013
1014static int snd_usb_motu_microbookii_communicate(struct usb_device *dev, u8 *buf,
1015 int buf_size, int *length)
1016{
1017 int err, actual_length;
1018
801ebf10
TI		 1019 if (snd_usb_pipe_sanity_check(dev, usb_sndintpipe(dev, 0x01)))
1020 return -EINVAL;
a634090a
MR		 1021 err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x01), buf, *length,
1022 &actual_length, 1000);
1023 if (err < 0)
1024 return err;
1025
1026 print_hex_dump(KERN_DEBUG, "MicroBookII snd: ", DUMP_PREFIX_NONE, 16, 1,
1027 buf, actual_length, false);
1028
1029 memset(buf, 0, buf_size);
1030
801ebf10
TI		 1031 if (snd_usb_pipe_sanity_check(dev, usb_rcvintpipe(dev, 0x82)))
1032 return -EINVAL;
a634090a
MR		 1033 err = usb_interrupt_msg(dev, usb_rcvintpipe(dev, 0x82), buf, buf_size,
1034 &actual_length, 1000);
1035 if (err < 0)
1036 return err;
1037
1038 print_hex_dump(KERN_DEBUG, "MicroBookII rcv: ", DUMP_PREFIX_NONE, 16, 1,
1039 buf, actual_length, false);
1040
1041 *length = actual_length;
1042 return 0;
1043}
1044
1045static int snd_usb_motu_microbookii_boot_quirk(struct usb_device *dev)
1046{
1047 int err, actual_length, poll_attempts = 0;
1048 static const u8 set_samplerate_seq[] = { 0x00, 0x00, 0x00, 0x00,
1049 0x00, 0x00, 0x0b, 0x14,
1050 0x00, 0x00, 0x00, 0x01 };
1051 static const u8 poll_ready_seq[] = { 0x00, 0x04, 0x00, 0x00,
1052 0x00, 0x00, 0x0b, 0x18 };
1053 u8 *buf = kzalloc(MICROBOOK_BUF_SIZE, GFP_KERNEL);
1054
1055 if (!buf)
1056 return -ENOMEM;
1057
1058 dev_info(&dev->dev, "Waiting for MOTU Microbook II to boot up...\n");
1059
1060 /* First we tell the device which sample rate to use. */
1061 memcpy(buf, set_samplerate_seq, sizeof(set_samplerate_seq));
1062 actual_length = sizeof(set_samplerate_seq);
1063 err = snd_usb_motu_microbookii_communicate(dev, buf, MICROBOOK_BUF_SIZE,
1064 &actual_length);
1065
1066 if (err < 0) {
1067 dev_err(&dev->dev,
1068 "failed setting the sample rate for Motu MicroBook II: %d\n",
1069 err);
1070 goto free_buf;
1071 }
1072
1073 /* Then we poll every 100 ms until the device informs of its readiness. */
1074 while (true) {
1075 if (++poll_attempts > 100) {
1076 dev_err(&dev->dev,
1077 "failed booting Motu MicroBook II: timeout\n");
1078 err = -ENODEV;
1079 goto free_buf;
1080 }
1081
1082 memset(buf, 0, MICROBOOK_BUF_SIZE);
1083 memcpy(buf, poll_ready_seq, sizeof(poll_ready_seq));
1084
1085 actual_length = sizeof(poll_ready_seq);
1086 err = snd_usb_motu_microbookii_communicate(
1087 dev, buf, MICROBOOK_BUF_SIZE, &actual_length);
1088 if (err < 0) {
1089 dev_err(&dev->dev,
1090 "failed booting Motu MicroBook II: communication error %d\n",
1091 err);
1092 goto free_buf;
1093 }
1094
1095 /* the device signals its readiness through a message of the
1096 * form
1097 * XX 06 00 00 00 00 0b 18 00 00 00 01
1098 * If the device is not yet ready to accept audio data, the
1099 * last byte of that sequence is 00.
1100 */
1101 if (actual_length == 12 && buf[actual_length - 1] == 1)
1102 break;
1103
1104 msleep(100);
1105 }
1106
1107 dev_info(&dev->dev, "MOTU MicroBook II ready\n");
1108
1109free_buf:
1110 kfree(buf);
1111 return err;
1112}
1113
e5779998
DM		 1114/*
1115 * Setup quirks
1116 */
0f5733b0
GP		 1117#define MAUDIO_SET 0x01 /* parse device_setup */
1118#define MAUDIO_SET_COMPATIBLE 0x80 /* use only "win-compatible" interfaces */
1119#define MAUDIO_SET_DTS 0x02 /* enable DTS Digital Output */
1120#define MAUDIO_SET_96K 0x04 /* 48-96KHz rate if set, 8-48KHz otherwise */
1121#define MAUDIO_SET_24B 0x08 /* 24bits sample if set, 16bits otherwise */
1122#define MAUDIO_SET_DI 0x10 /* enable Digital Input */
1123#define MAUDIO_SET_MASK 0x1f /* bit mask for setup value */
1124#define MAUDIO_SET_24B_48K_DI 0x19 /* 24bits+48KHz+Digital Input */
1125#define MAUDIO_SET_24B_48K_NOTDI 0x09 /* 24bits+48KHz+No Digital Input */
1126#define MAUDIO_SET_16B_48K_DI 0x11 /* 16bits+48KHz+Digital Input */
1127#define MAUDIO_SET_16B_48K_NOTDI 0x01 /* 16bits+48KHz+No Digital Input */
1128
1129static int quattro_skip_setting_quirk(struct snd_usb_audio *chip,
1130 int iface, int altno)
1131{
1132 /* Reset ALL ifaces to 0 altsetting.
1133 * Call it for every possible altsetting of every interface.
1134 */
1135 usb_set_interface(chip->dev, iface, 0);
1136 if (chip->setup & MAUDIO_SET) {
1137 if (chip->setup & MAUDIO_SET_COMPATIBLE) {
1138 if (iface != 1 && iface != 2)
1139 return 1; /* skip all interfaces but 1 and 2 */
1140 } else {
1141 unsigned int mask;
1142 if (iface == 1 || iface == 2)
1143 return 1; /* skip interfaces 1 and 2 */
1144 if ((chip->setup & MAUDIO_SET_96K) && altno != 1)
1145 return 1; /* skip this altsetting */
1146 mask = chip->setup & MAUDIO_SET_MASK;
1147 if (mask == MAUDIO_SET_24B_48K_DI && altno != 2)
1148 return 1; /* skip this altsetting */
1149 if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3)
1150 return 1; /* skip this altsetting */
1151 if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 4)
1152 return 1; /* skip this altsetting */
1153 }
1154 }
0ba41d91 1155 usb_audio_dbg(chip,
0f5733b0
GP		 1156 "using altsetting %d for interface %d config %d\n",
1157 altno, iface, chip->setup);
1158 return 0; /* keep this altsetting */
1159}
e5779998
DM		 1160
1161static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
1162 int iface,
1163 int altno)
1164{
1165 /* Reset ALL ifaces to 0 altsetting.
1166 * Call it for every possible altsetting of every interface.
1167 */
1168 usb_set_interface(chip->dev, iface, 0);
1169
0f5733b0
GP		 1170 if (chip->setup & MAUDIO_SET) {
1171 unsigned int mask;
1172 if ((chip->setup & MAUDIO_SET_DTS) && altno != 6)
e5779998 1173 return 1; /* skip this altsetting */
0f5733b0 1174 if ((chip->setup & MAUDIO_SET_96K) && altno != 1)
e5779998 1175 return 1; /* skip this altsetting */
0f5733b0
GP		 1176 mask = chip->setup & MAUDIO_SET_MASK;
1177 if (mask == MAUDIO_SET_24B_48K_DI && altno != 2)
e5779998 1178 return 1; /* skip this altsetting */
0f5733b0 1179 if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3)
e5779998 1180 return 1; /* skip this altsetting */
0f5733b0 1181 if (mask == MAUDIO_SET_16B_48K_DI && altno != 4)
e5779998 1182 return 1; /* skip this altsetting */
0f5733b0 1183 if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 5)
e5779998
DM		 1184 return 1; /* skip this altsetting */
1185 }
1186
1187 return 0; /* keep this altsetting */
1188}
1189
0f5733b0
GP		 1190static int fasttrackpro_skip_setting_quirk(struct snd_usb_audio *chip,
1191 int iface, int altno)
1192{
1193 /* Reset ALL ifaces to 0 altsetting.
1194 * Call it for every possible altsetting of every interface.
1195 */
1196 usb_set_interface(chip->dev, iface, 0);
1197
1198 /* possible configuration where both inputs and only one output is
1199 *used is not supported by the current setup
1200 */
1201 if (chip->setup & (MAUDIO_SET | MAUDIO_SET_24B)) {
1202 if (chip->setup & MAUDIO_SET_96K) {
1203 if (altno != 3 && altno != 6)
1204 return 1;
1205 } else if (chip->setup & MAUDIO_SET_DI) {
1206 if (iface == 4)
1207 return 1; /* no analog input */
1208 if (altno != 2 && altno != 5)
1209 return 1; /* enable only altsets 2 and 5 */
1210 } else {
1211 if (iface == 5)
1212 return 1; /* disable digialt input */
1213 if (altno != 2 && altno != 5)
1214 return 1; /* enalbe only altsets 2 and 5 */
1215 }
1216 } else {
1217 /* keep only 16-Bit mode */
1218 if (altno != 1)
1219 return 1;
1220 }
1221
0ba41d91 1222 usb_audio_dbg(chip,
0f5733b0
GP		 1223 "using altsetting %d for interface %d config %d\n",
1224 altno, iface, chip->setup);
1225 return 0; /* keep this altsetting */
1226}
1227
e5779998
DM		 1228int snd_usb_apply_interface_quirk(struct snd_usb_audio *chip,
1229 int iface,
1230 int altno)
1231{
1232 /* audiophile usb: skip altsets incompatible with device_setup */
1233 if (chip->usb_id == USB_ID(0x0763, 0x2003))
1234 return audiophile_skip_setting_quirk(chip, iface, altno);
0f5733b0
GP		 1235 /* quattro usb: skip altsets incompatible with device_setup */
1236 if (chip->usb_id == USB_ID(0x0763, 0x2001))
1237 return quattro_skip_setting_quirk(chip, iface, altno);
1238 /* fasttrackpro usb: skip altsets incompatible with device_setup */
1239 if (chip->usb_id == USB_ID(0x0763, 0x2012))
1240 return fasttrackpro_skip_setting_quirk(chip, iface, altno);
e5779998
DM		 1241
1242 return 0;
1243}
1244
1245int snd_usb_apply_boot_quirk(struct usb_device *dev,
1246 struct usb_interface *intf,
79289e24
TI		 1247 const struct snd_usb_audio_quirk *quirk,
1248 unsigned int id)
e5779998 1249{
3347b26c
DM		 1250 switch (id) {
1251 case USB_ID(0x041e, 0x3000):
1252 /* SB Extigy needs special boot-up sequence */
1253 /* if more models come, this will go to the quirk list. */
e5779998
DM		 1254 return snd_usb_extigy_boot_quirk(dev, intf);
1255
3347b26c
DM		 1256 case USB_ID(0x041e, 0x3020):
1257 /* SB Audigy 2 NX needs its own boot-up magic, too */
e5779998
DM		 1258 return snd_usb_audigy2nx_boot_quirk(dev);
1259
3347b26c
DM		 1260 case USB_ID(0x10f5, 0x0200):
1261 /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */
e5779998
DM		 1262 return snd_usb_cm106_boot_quirk(dev);
1263
3347b26c
DM		 1264 case USB_ID(0x0d8c, 0x0102):
1265 /* C-Media CM6206 / CM106-Like Sound Device */
8129e79e 1266 case USB_ID(0x0ccd, 0x00b1): /* Terratec Aureon 7.1 USB */
e5779998
DM		 1267 return snd_usb_cm6206_boot_quirk(dev);
1268
cb99864d
DZ		 1269 case USB_ID(0x0dba, 0x3000):
1270 /* Digidesign Mbox 2 */
1271 return snd_usb_mbox2_boot_quirk(dev);
1272
11e424e8
EG		 1273 case USB_ID(0x1235, 0x0010): /* Focusrite Novation Saffire 6 USB */
1274 case USB_ID(0x1235, 0x0018): /* Focusrite Novation Twitch */
1275 return snd_usb_novation_boot_quirk(dev);
5e212332 1276
3347b26c
DM		 1277 case USB_ID(0x133e, 0x0815):
1278 /* Access Music VirusTI Desktop */
e5779998
DM		 1279 return snd_usb_accessmusic_boot_quirk(dev);
1280
759e890f 1281 case USB_ID(0x17cc, 0x1000): /* Komplete Audio 6 */
3347b26c
DM		 1282 case USB_ID(0x17cc, 0x1010): /* Traktor Audio 6 */
1283 case USB_ID(0x17cc, 0x1020): /* Traktor Audio 10 */
54a8c500 1284 return snd_usb_nativeinstruments_boot_quirk(dev);
0f5733b0
GP		 1285 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */
1286 return snd_usb_fasttrackpro_boot_quirk(dev);
19570d74
TI		 1287 case USB_ID(0x047f, 0xc010): /* Plantronics Gamecom 780 */
1288 return snd_usb_gamecon780_boot_quirk(dev);
16bafa79
AA		 1289 case USB_ID(0x2466, 0x8010): /* Fractal Audio Axe-Fx 3 */
1290 return snd_usb_axefx3_boot_quirk(dev);
a634090a
MR		 1291 case USB_ID(0x07fd, 0x0004): /* MOTU MicroBook II */
1292 return snd_usb_motu_microbookii_boot_quirk(dev);
3347b26c 1293 }
54a8c500 1294
e5779998
DM		 1295 return 0;
1296}
1297
1298/*
1299 * check if the device uses big-endian samples
1300 */
1301int snd_usb_is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *fp)
1302{
48fc7f7e 1303 /* it depends on altsetting whether the device is big-endian or not */
e5779998
DM		 1304 switch (chip->usb_id) {
1305 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
0f5733b0
GP		 1306 if (fp->altsetting == 2 || fp->altsetting == 3 ||
1307 fp->altsetting == 5 || fp->altsetting == 6)
e5779998
DM		 1308 return 1;
1309 break;
1310 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
1311 if (chip->setup == 0x00 ||
0f5733b0
GP		 1312 fp->altsetting == 1 || fp->altsetting == 2 ||
1313 fp->altsetting == 3)
1314 return 1;
1315 break;
1316 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro */
1317 if (fp->altsetting == 2 || fp->altsetting == 3 ||
1318 fp->altsetting == 5 || fp->altsetting == 6)
e5779998 1319 return 1;
0f5733b0 1320 break;
e5779998
DM		 1321 }
1322 return 0;
1323}
1324
1325/*
1cdfa9f3 1326 * For E-Mu 0404USB/0202USB/TrackerPre/0204 sample rate should be set for device,
e5779998
DM		 1327 * not for interface.
1328 */
1329
1330enum {
1331 EMU_QUIRK_SR_44100HZ = 0,
1332 EMU_QUIRK_SR_48000HZ,
1333 EMU_QUIRK_SR_88200HZ,
1334 EMU_QUIRK_SR_96000HZ,
1335 EMU_QUIRK_SR_176400HZ,
1336 EMU_QUIRK_SR_192000HZ
1337};
1338
1339static void set_format_emu_quirk(struct snd_usb_substream *subs,
1340 struct audioformat *fmt)
1341{
1342 unsigned char emu_samplerate_id = 0;
1343
1344 /* When capture is active
1345 * sample rate shouldn't be changed
1346 * by playback substream
1347 */
1348 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
1349 if (subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE].interface != -1)
1350 return;
1351 }
1352
1353 switch (fmt->rate_min) {
1354 case 48000:
1355 emu_samplerate_id = EMU_QUIRK_SR_48000HZ;
1356 break;
1357 case 88200:
1358 emu_samplerate_id = EMU_QUIRK_SR_88200HZ;
1359 break;
1360 case 96000:
1361 emu_samplerate_id = EMU_QUIRK_SR_96000HZ;
1362 break;
1363 case 176400:
1364 emu_samplerate_id = EMU_QUIRK_SR_176400HZ;
1365 break;
1366 case 192000:
1367 emu_samplerate_id = EMU_QUIRK_SR_192000HZ;
1368 break;
1369 default:
1370 emu_samplerate_id = EMU_QUIRK_SR_44100HZ;
1371 break;
1372 }
1373 snd_emuusb_set_samplerate(subs->stream->chip, emu_samplerate_id);
1539d4f8 1374 subs->pkt_offset_adj = (emu_samplerate_id >= EMU_QUIRK_SR_176400HZ) ? 4 : 0;
e5779998
DM		 1375}
1376
1377void snd_usb_set_format_quirk(struct snd_usb_substream *subs,
1378 struct audioformat *fmt)
1379{
1380 switch (subs->stream->chip->usb_id) {
1381 case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
1382 case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
1383 case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
1cdfa9f3 1384 case USB_ID(0x041e, 0x3f19): /* E-Mu 0204 USB */
e5779998
DM		 1385 set_format_emu_quirk(subs, fmt);
1386 break;
1387 }
1388}
1389
b62b9980
JT		 1390bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip)
1391{
9fc88ad6
EW		 1392 /* devices which do not support reading the sample rate. */
1393 switch (chip->usb_id) {
7627e40c 1394 case USB_ID(0x041E, 0x4080): /* Creative Live Cam VF0610 */
9fc88ad6 1395 case USB_ID(0x04D8, 0xFEEA): /* Benchmark DAC1 Pre */
84add303 1396 case USB_ID(0x0556, 0x0014): /* Phoenix Audio TMX320VC */
41f5e3bd 1397 case USB_ID(0x05A3, 0x9420): /* ELP HD USB Camera */
2f80b295 1398 case USB_ID(0x074D, 0x3553): /* Outlaw RR2150 (Micronas UAC3553B) */
a8e800fe 1399 case USB_ID(0x1395, 0x740a): /* Sennheiser DECT */
83d9956b 1400 case USB_ID(0x1901, 0x0191): /* GE B850V3 CP2114 audio interface */
12a6116e 1401 case USB_ID(0x21B4, 0x0081): /* AudioQuest DragonFly */
9fc88ad6
EW		 1402 return true;
1403 }
a6aa6cdc
TI		 1404
1405 /* devices of these vendors don't support reading rate, either */
1406 switch (USB_ID_VENDOR(chip->usb_id)) {
1407 case 0x045E: /* MS Lifecam */
1408 case 0x047F: /* Plantronics */
1409 case 0x1de7: /* Phoenix Audio */
1410 return true;
1411 }
1412
9fc88ad6 1413 return false;
b62b9980 1414}
6874daad 1415
71426535 1416/* ITF-USB DSD based DACs need a vendor cmd to switch
6874daad
JK		 1417 * between PCM and native DSD mode
1418 */
f3b906d7 1419static bool is_itf_usb_dsd_dac(unsigned int id)
8b28c93f 1420{
f3b906d7 1421 switch (id) {
8b28c93f
TI		 1422 case USB_ID(0x154e, 0x1003): /* Denon DA-300USB */
1423 case USB_ID(0x154e, 0x3005): /* Marantz HD-DAC1 */
1424 case USB_ID(0x154e, 0x3006): /* Marantz SA-14S1 */
71426535 1425 case USB_ID(0x1852, 0x5065): /* Luxman DA-06 */
f3b906d7 1426 case USB_ID(0x0644, 0x8043): /* TEAC UD-501/UD-501V2/UD-503/NT-503 */
866f7ed7 1427 case USB_ID(0x0644, 0x8044): /* Esoteric D-05X */
b0021486 1428 case USB_ID(0x0644, 0x804a): /* TEAC UD-301 */
7f38ca04
NO		 1429 return true;
1430 }
1431 return false;
1432}
1433
6874daad
JK		 1434int snd_usb_select_mode_quirk(struct snd_usb_substream *subs,
1435 struct audioformat *fmt)
1436{
1437 struct usb_device *dev = subs->dev;
1438 int err;
1439
f3b906d7 1440 if (is_itf_usb_dsd_dac(subs->stream->chip->usb_id)) {
6874daad
JK		 1441 /* First switch to alt set 0, otherwise the mode switch cmd
1442 * will not be accepted by the DAC
1443 */
1444 err = usb_set_interface(dev, fmt->iface, 0);
1445 if (err < 0)
1446 return err;
1447
df3f0347 1448 msleep(20); /* Delay needed after setting the interface */
6874daad 1449
7f38ca04 1450 /* Vendor mode switch cmd is required. */
f3b906d7
NO		 1451 if (fmt->formats & SNDRV_PCM_FMTBIT_DSD_U32_BE) {
1452 /* DSD mode (DSD_U32) requested */
7f38ca04
NO		 1453 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,
1454 USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
1455 1, 1, NULL, 0);
1456 if (err < 0)
1457 return err;
7f38ca04 1458
f3b906d7
NO		 1459 } else {
1460 /* PCM or DOP mode (S32) requested */
1461 /* PCM mode (S16) requested */
7f38ca04
NO		 1462 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,
1463 USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
1464 0, 1, NULL, 0);
1465 if (err < 0)
1466 return err;
f3b906d7 1467
7f38ca04 1468 }
df3f0347 1469 msleep(20);
6874daad
JK		 1470 }
1471 return 0;
1472}
1473
2b58fd5b
DM		 1474void snd_usb_endpoint_start_quirk(struct snd_usb_endpoint *ep)
1475{
1476 /*
1477 * "Playback Design" products send bogus feedback data at the start
1478 * of the stream. Ignore them.
1479 */
79289e24 1480 if (USB_ID_VENDOR(ep->chip->usb_id) == 0x23ba &&
2b58fd5b
DM		 1481 ep->type == SND_USB_ENDPOINT_TYPE_SYNC)
1482 ep->skip_packets = 4;
83e3acd4
EZ		 1483
1484 /*
e9a25e04
MG		 1485 * M-Audio Fast Track C400/C600 - when packets are not skipped, real
1486 * world latency varies by approx. +/- 50 frames (at 96KHz) each time
1487 * the stream is (re)started. When skipping packets 16 at endpoint
1488 * start up, the real world latency is stable within +/- 1 frame (also
83e3acd4
EZ		 1489 * across power cycles).
1490 */
e9a25e04
MG		 1491 if ((ep->chip->usb_id == USB_ID(0x0763, 0x2030) ||
1492 ep->chip->usb_id == USB_ID(0x0763, 0x2031)) &&
83e3acd4
EZ		 1493 ep->type == SND_USB_ENDPOINT_TYPE_DATA)
1494 ep->skip_packets = 16;
9abc1341
DM		 1495
1496 /* Work around devices that report unreasonable feedback data */
ca0dd273
DM		 1497 if ((ep->chip->usb_id == USB_ID(0x0644, 0x8038) || /* TEAC UD-H01 */
1498 ep->chip->usb_id == USB_ID(0x1852, 0x5034)) && /* T+A Dac8 */
9abc1341 1499 ep->syncmaxsize == 4)
ca0dd273 1500 ep->tenor_fb_quirk = 1;
2b58fd5b
DM		 1501}
1502
21bb5aaf
DM		 1503void snd_usb_set_interface_quirk(struct usb_device *dev)
1504{
79289e24
TI		 1505 struct snd_usb_audio *chip = dev_get_drvdata(&dev->dev);
1506
1507 if (!chip)
1508 return;
21bb5aaf
DM		 1509 /*
1510 * "Playback Design" products need a 50ms delay after setting the
1511 * USB interface.
1512 */
79289e24 1513 switch (USB_ID_VENDOR(chip->usb_id)) {
5a4ff9ec
GF		 1514 case 0x23ba: /* Playback Design */
1515 case 0x0644: /* TEAC Corp. */
df3f0347 1516 msleep(50);
5a4ff9ec
GF		 1517 break;
1518 }
21bb5aaf
DM		 1519}
1520
79289e24 1521/* quirk applied after snd_usb_ctl_msg(); not applied during boot quirks */
2b58fd5b
DM		 1522void snd_usb_ctl_msg_quirk(struct usb_device *dev, unsigned int pipe,
1523 __u8 request, __u8 requesttype, __u16 value,
1524 __u16 index, void *data, __u16 size)
1525{
79289e24
TI		 1526 struct snd_usb_audio *chip = dev_get_drvdata(&dev->dev);
1527
1528 if (!chip)
1529 return;
2b58fd5b
DM		 1530 /*
1531 * "Playback Design" products need a 20ms delay after each
1532 * class compliant request
1533 */
79289e24 1534 if (USB_ID_VENDOR(chip->usb_id) == 0x23ba &&
2b58fd5b 1535 (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
df3f0347 1536 msleep(20);
6e84a8d7 1537
5a4ff9ec
GF		 1538 /*
1539 * "TEAC Corp." products need a 20ms delay after each
1540 * class compliant request
1541 */
79289e24 1542 if (USB_ID_VENDOR(chip->usb_id) == 0x0644 &&
5a4ff9ec 1543 (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
df3f0347 1544 msleep(20);
5a4ff9ec 1545
71426535 1546 /* ITF-USB DSD based DACs functionality need a delay
6e84a8d7
JK		 1547 * after each class compliant request
1548 */
f3b906d7 1549 if (is_itf_usb_dsd_dac(chip->usb_id)
8b28c93f 1550 && (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
df3f0347 1551 msleep(20);
dacacb0a 1552
07b3b5e9
JT		 1553 /* Zoom R16/24, Logitech H650e, Jabra 550a needs a tiny delay here,
1554 * otherwise requests like get/set frequency return as failed despite
1555 * actually succeeding.
dacacb0a 1556 */
07b3b5e9
JT		 1557 if ((chip->usb_id == USB_ID(0x1686, 0x00dd) ||
1558 chip->usb_id == USB_ID(0x046d, 0x0a46) ||
1559 chip->usb_id == USB_ID(0x0b0e, 0x0349)) &&
dacacb0a 1560 (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
df3f0347 1561 usleep_range(1000, 2000);
2b58fd5b
DM		 1562}
1563
126825e7
DM		 1564/*
1565 * snd_usb_interface_dsd_format_quirks() is called from format.c to
1566 * augment the PCM format bit-field for DSD types. The UAC standards
1567 * don't have a designated bit field to denote DSD-capable interfaces,
1568 * hence all hardware that is known to support this format has to be
1569 * listed here.
1570 */
1571u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip,
1572 struct audioformat *fp,
1573 unsigned int sample_bytes)
1574{
f3b906d7
NO		 1575 struct usb_interface *iface;
1576
126825e7 1577 /* Playback Designs */
79289e24 1578 if (USB_ID_VENDOR(chip->usb_id) == 0x23ba) {
126825e7
DM		 1579 switch (fp->altsetting) {
1580 case 1:
1581 fp->dsd_dop = true;
1582 return SNDRV_PCM_FMTBIT_DSD_U16_LE;
1583 case 2:
1584 fp->dsd_bitrev = true;
1585 return SNDRV_PCM_FMTBIT_DSD_U8;
1586 case 3:
1587 fp->dsd_bitrev = true;
1588 return SNDRV_PCM_FMTBIT_DSD_U16_LE;
1589 }
1590 }
1591
848f3a82
JK		 1592 /* XMOS based USB DACs */
1593 switch (chip->usb_id) {
f656891c 1594 case USB_ID(0x1511, 0x0037): /* AURALiC VEGA */
5327d6ba 1595 case USB_ID(0x22d9, 0x0416): /* OPPO HA-1 */
f656891c
DM		 1596 case USB_ID(0x22d9, 0x0436): /* OPPO Sonica */
1597 case USB_ID(0x22d9, 0x0461): /* OPPO UDP-205 */
1598 case USB_ID(0x2522, 0x0012): /* LH Labs VI DAC Infinity */
9bb201a5 1599 case USB_ID(0x2772, 0x0230): /* Pro-Ject Pre Box S2 Digital */
848f3a82 1600 if (fp->altsetting == 2)
d42472ec 1601 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
848f3a82 1602 break;
3b7e5c7e 1603
f656891c 1604 case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */
202e69e6 1605 case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */
f656891c 1606 case USB_ID(0x16b0, 0x06b2): /* NuPrime DAC-10 */
202e69e6 1607 case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */
f656891c
DM		 1608 case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */
1609 case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */
1610 case USB_ID(0x1db5, 0x0003): /* Bryston BDA3 */
f656891c
DM		 1611 case USB_ID(0x22d9, 0x0426): /* OPPO HA-2 */
1612 case USB_ID(0x22e1, 0xca01): /* HDTA Serenade DSD */
1613 case USB_ID(0x249c, 0x9326): /* M2Tech Young MkIII */
ad678b4c 1614 case USB_ID(0x2616, 0x0106): /* PS Audio NuWave DAC */
f656891c
DM		 1615 case USB_ID(0x2622, 0x0041): /* Audiolab M-DAC+ */
1616 case USB_ID(0x27f7, 0x3002): /* W4S DAC-2v2SE */
1617 case USB_ID(0x29a2, 0x0086): /* Mutec MC3+ USB */
1618 case USB_ID(0x6b42, 0x0042): /* MSB Technology */
848f3a82 1619 if (fp->altsetting == 3)
d42472ec 1620 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
848f3a82 1621 break;
3eff682d 1622
7c74866b
DM		 1623 /* Amanero Combo384 USB based DACs with native DSD support */
1624 case USB_ID(0x16d0, 0x071a): /* Amanero - Combo384 */
1625 case USB_ID(0x2ab6, 0x0004): /* T+A DAC8DSD-V2.0, MP1000E-V2.0, MP2000R-V2.0, MP2500R-V2.0, MP3100HV-V2.0 */
1626 case USB_ID(0x2ab6, 0x0005): /* T+A USB HD Audio 1 */
1627 case USB_ID(0x2ab6, 0x0006): /* T+A USB HD Audio 2 */
3eff682d 1628 if (fp->altsetting == 2) {
f83914fd 1629 switch (le16_to_cpu(chip->dev->descriptor.bcdDevice)) {
3eff682d
JL		 1630 case 0x199:
1631 return SNDRV_PCM_FMTBIT_DSD_U32_LE;
1632 case 0x19b:
f5ce8179 1633 case 0x203:
3eff682d
JL		 1634 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1635 default:
1636 break;
1637 }
1638 }
1639 break;
ed993c6f
JL		 1640 case USB_ID(0x16d0, 0x0a23):
1641 if (fp->altsetting == 2)
1642 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1643 break;
3eff682d 1644
848f3a82
JK		 1645 default:
1646 break;
1647 }
1648
f3b906d7
NO		 1649 /* ITF-USB DSD based DACs */
1650 if (is_itf_usb_dsd_dac(chip->usb_id)) {
1651 iface = usb_ifnum_to_if(chip->dev, fp->iface);
7a2e9ddc 1652
f3b906d7
NO		 1653 /* Altsetting 2 support native DSD if the num of altsets is
1654 * three (0-2),
1655 * Altsetting 3 support native DSD if the num of altsets is
1656 * four (0-3).
1657 */
1658 if (fp->altsetting == iface->num_altsetting - 1)
7f38ca04
NO		 1659 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1660 }
1661
3a572d94
JL		 1662 /* Mostly generic method to detect many DSD-capable implementations -
1663 * from XMOS/Thesycon
1664 */
1665 switch (USB_ID_VENDOR(chip->usb_id)) {
f332485f 1666 case 0x20b1: /* XMOS based devices */
1ea0358e 1667 case 0x152a: /* Thesycon devices */
3a572d94 1668 case 0x25ce: /* Mytek devices */
3bff2407 1669 case 0x2ab6: /* T+A devices */
3a572d94
JL		 1670 if (fp->dsd_raw)
1671 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1672 break;
1673 default:
1674 break;
1675
1676 }
1677
126825e7
DM		 1678 return 0;
1679}
ceb18f51
RB		 1680
1681void snd_usb_audioformat_attributes_quirk(struct snd_usb_audio *chip,
1682 struct audioformat *fp,
1683 int stream)
1684{
1685 switch (chip->usb_id) {
1686 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
1687 /* Optoplay sets the sample rate attribute although
1688 * it seems not supporting it in fact.
1689 */
1690 fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE;
1691 break;
1692 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
1693 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
1694 /* doesn't set the sample rate attribute, but supports it */
1695 fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE;
1696 break;
1697 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro USB */
1698 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */
1699 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
1700 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
1701 an older model 77d:223) */
1702 /*
1703 * plantronics headset and Griffin iMic have set adaptive-in
1704 * although it's really not...
1705 */
1706 fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE;
1707 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
1708 fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE;
1709 else
1710 fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC;
1711 break;
1712 }
1713}
Linux 6.x block layer and io_uring tree(s)