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