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> 18 #include <linux/slab.h> 19 #include <linux/usb.h> 20 #include <linux/usb/audio.h> 21 #include <linux/usb/midi.h> 22 23 #include <sound/control.h> 24 #include <sound/core.h> 25 #include <sound/info.h> 26 #include <sound/pcm.h> 27 28 #include "usbaudio.h" 29 #include "card.h" 30 #include "mixer.h" 31 #include "mixer_quirks.h" 32 #include "midi.h" 33 #include "quirks.h" 34 #include "helper.h" 35 #include "endpoint.h" 36 #include "pcm.h" 37 #include "clock.h" 38 #include "stream.h" 39 40 /* 41 * handle the quirks for the contained interfaces 42 */ 43 static int create_composite_quirk(struct snd_usb_audio *chip, 44 struct usb_interface *iface, 45 struct usb_driver *driver, 46 const struct snd_usb_audio_quirk *quirk) 47 { 48 int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber; 49 int err; 50 51 for (quirk = quirk->data; quirk->ifnum >= 0; ++quirk) { 52 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum); 53 if (!iface) 54 continue; 55 if (quirk->ifnum != probed_ifnum && 56 usb_interface_claimed(iface)) 57 continue; 58 err = snd_usb_create_quirk(chip, iface, driver, quirk); 59 if (err < 0) 60 return err; 61 if (quirk->ifnum != probed_ifnum) 62 usb_driver_claim_interface(driver, iface, (void *)-1L); 63 } 64 return 0; 65 } 66 67 static int ignore_interface_quirk(struct snd_usb_audio *chip, 68 struct usb_interface *iface, 69 struct usb_driver *driver, 70 const struct snd_usb_audio_quirk *quirk) 71 { 72 return 0; 73 } 74 75 76 /* 77 * Allow alignment on audio sub-slot (channel samples) rather than 78 * on audio slots (audio frames) 79 */ 80 static int create_align_transfer_quirk(struct snd_usb_audio *chip, 81 struct usb_interface *iface, 82 struct usb_driver *driver, 83 const struct snd_usb_audio_quirk *quirk) 84 { 85 chip->txfr_quirk = 1; 86 return 1; /* Continue with creating streams and mixer */ 87 } 88 89 static int create_any_midi_quirk(struct snd_usb_audio *chip, 90 struct usb_interface *intf, 91 struct usb_driver *driver, 92 const struct snd_usb_audio_quirk *quirk) 93 { 94 return snd_usbmidi_create(chip->card, intf, &chip->midi_list, quirk); 95 } 96 97 /* 98 * create a stream for an interface with proper descriptors 99 */ 100 static int create_standard_audio_quirk(struct snd_usb_audio *chip, 101 struct usb_interface *iface, 102 struct usb_driver *driver, 103 const struct snd_usb_audio_quirk *quirk) 104 { 105 struct usb_host_interface *alts; 106 struct usb_interface_descriptor *altsd; 107 int err; 108 109 alts = &iface->altsetting[0]; 110 altsd = get_iface_desc(alts); 111 err = snd_usb_parse_audio_interface(chip, altsd->bInterfaceNumber); 112 if (err < 0) { 113 usb_audio_err(chip, "cannot setup if %d: error %d\n", 114 altsd->bInterfaceNumber, err); 115 return err; 116 } 117 /* reset the current interface */ 118 usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0); 119 return 0; 120 } 121 122 /* 123 * create a stream for an endpoint/altsetting without proper descriptors 124 */ 125 static int create_fixed_stream_quirk(struct snd_usb_audio *chip, 126 struct usb_interface *iface, 127 struct usb_driver *driver, 128 const struct snd_usb_audio_quirk *quirk) 129 { 130 struct audioformat *fp; 131 struct usb_host_interface *alts; 132 struct usb_interface_descriptor *altsd; 133 int stream, err; 134 unsigned *rate_table = NULL; 135 136 fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL); 137 if (!fp) { 138 usb_audio_err(chip, "cannot memdup\n"); 139 return -ENOMEM; 140 } 141 if (fp->nr_rates > MAX_NR_RATES) { 142 kfree(fp); 143 return -EINVAL; 144 } 145 if (fp->nr_rates > 0) { 146 rate_table = kmemdup(fp->rate_table, 147 sizeof(int) * fp->nr_rates, GFP_KERNEL); 148 if (!rate_table) { 149 kfree(fp); 150 return -ENOMEM; 151 } 152 fp->rate_table = rate_table; 153 } 154 155 stream = (fp->endpoint & USB_DIR_IN) 156 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK; 157 err = snd_usb_add_audio_stream(chip, stream, fp); 158 if (err < 0) { 159 kfree(fp); 160 kfree(rate_table); 161 return err; 162 } 163 if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber || 164 fp->altset_idx >= iface->num_altsetting) { 165 kfree(fp); 166 kfree(rate_table); 167 return -EINVAL; 168 } 169 alts = &iface->altsetting[fp->altset_idx]; 170 altsd = get_iface_desc(alts); 171 fp->protocol = altsd->bInterfaceProtocol; 172 173 if (fp->datainterval == 0) 174 fp->datainterval = snd_usb_parse_datainterval(chip, alts); 175 if (fp->maxpacksize == 0) 176 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); 177 usb_set_interface(chip->dev, fp->iface, 0); 178 snd_usb_init_pitch(chip, fp->iface, alts, fp); 179 snd_usb_init_sample_rate(chip, fp->iface, alts, fp, fp->rate_max); 180 return 0; 181 } 182 183 static int create_auto_pcm_quirk(struct snd_usb_audio *chip, 184 struct usb_interface *iface, 185 struct usb_driver *driver) 186 { 187 struct usb_host_interface *alts; 188 struct usb_interface_descriptor *altsd; 189 struct usb_endpoint_descriptor *epd; 190 struct uac1_as_header_descriptor *ashd; 191 struct uac_format_type_i_discrete_descriptor *fmtd; 192 193 /* 194 * Most Roland/Yamaha audio streaming interfaces have more or less 195 * standard descriptors, but older devices might lack descriptors, and 196 * future ones might change, so ensure that we fail silently if the 197 * interface doesn't look exactly right. 198 */ 199 200 /* must have a non-zero altsetting for streaming */ 201 if (iface->num_altsetting < 2) 202 return -ENODEV; 203 alts = &iface->altsetting[1]; 204 altsd = get_iface_desc(alts); 205 206 /* must have an isochronous endpoint for streaming */ 207 if (altsd->bNumEndpoints < 1) 208 return -ENODEV; 209 epd = get_endpoint(alts, 0); 210 if (!usb_endpoint_xfer_isoc(epd)) 211 return -ENODEV; 212 213 /* must have format descriptors */ 214 ashd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, 215 UAC_AS_GENERAL); 216 fmtd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, 217 UAC_FORMAT_TYPE); 218 if (!ashd || ashd->bLength < 7 || 219 !fmtd || fmtd->bLength < 8) 220 return -ENODEV; 221 222 return create_standard_audio_quirk(chip, iface, driver, NULL); 223 } 224 225 static int create_yamaha_midi_quirk(struct snd_usb_audio *chip, 226 struct usb_interface *iface, 227 struct usb_driver *driver, 228 struct usb_host_interface *alts) 229 { 230 static const struct snd_usb_audio_quirk yamaha_midi_quirk = { 231 .type = QUIRK_MIDI_YAMAHA 232 }; 233 struct usb_midi_in_jack_descriptor *injd; 234 struct usb_midi_out_jack_descriptor *outjd; 235 236 /* must have some valid jack descriptors */ 237 injd = snd_usb_find_csint_desc(alts->extra, alts->extralen, 238 NULL, USB_MS_MIDI_IN_JACK); 239 outjd = snd_usb_find_csint_desc(alts->extra, alts->extralen, 240 NULL, USB_MS_MIDI_OUT_JACK); 241 if (!injd && !outjd) 242 return -ENODEV; 243 if (injd && (injd->bLength < 5 || 244 (injd->bJackType != USB_MS_EMBEDDED && 245 injd->bJackType != USB_MS_EXTERNAL))) 246 return -ENODEV; 247 if (outjd && (outjd->bLength < 6 || 248 (outjd->bJackType != USB_MS_EMBEDDED && 249 outjd->bJackType != USB_MS_EXTERNAL))) 250 return -ENODEV; 251 return create_any_midi_quirk(chip, iface, driver, &yamaha_midi_quirk); 252 } 253 254 static int create_roland_midi_quirk(struct snd_usb_audio *chip, 255 struct usb_interface *iface, 256 struct usb_driver *driver, 257 struct usb_host_interface *alts) 258 { 259 static const struct snd_usb_audio_quirk roland_midi_quirk = { 260 .type = QUIRK_MIDI_ROLAND 261 }; 262 u8 *roland_desc = NULL; 263 264 /* might have a vendor-specific descriptor <06 24 F1 02 ...> */ 265 for (;;) { 266 roland_desc = snd_usb_find_csint_desc(alts->extra, 267 alts->extralen, 268 roland_desc, 0xf1); 269 if (!roland_desc) 270 return -ENODEV; 271 if (roland_desc[0] < 6 || roland_desc[3] != 2) 272 continue; 273 return create_any_midi_quirk(chip, iface, driver, 274 &roland_midi_quirk); 275 } 276 } 277 278 static int create_std_midi_quirk(struct snd_usb_audio *chip, 279 struct usb_interface *iface, 280 struct usb_driver *driver, 281 struct usb_host_interface *alts) 282 { 283 struct usb_ms_header_descriptor *mshd; 284 struct usb_ms_endpoint_descriptor *msepd; 285 286 /* must have the MIDIStreaming interface header descriptor*/ 287 mshd = (struct usb_ms_header_descriptor *)alts->extra; 288 if (alts->extralen < 7 || 289 mshd->bLength < 7 || 290 mshd->bDescriptorType != USB_DT_CS_INTERFACE || 291 mshd->bDescriptorSubtype != USB_MS_HEADER) 292 return -ENODEV; 293 /* must have the MIDIStreaming endpoint descriptor*/ 294 msepd = (struct usb_ms_endpoint_descriptor *)alts->endpoint[0].extra; 295 if (alts->endpoint[0].extralen < 4 || 296 msepd->bLength < 4 || 297 msepd->bDescriptorType != USB_DT_CS_ENDPOINT || 298 msepd->bDescriptorSubtype != UAC_MS_GENERAL || 299 msepd->bNumEmbMIDIJack < 1 || 300 msepd->bNumEmbMIDIJack > 16) 301 return -ENODEV; 302 303 return create_any_midi_quirk(chip, iface, driver, NULL); 304 } 305 306 static int create_auto_midi_quirk(struct snd_usb_audio *chip, 307 struct usb_interface *iface, 308 struct usb_driver *driver) 309 { 310 struct usb_host_interface *alts; 311 struct usb_interface_descriptor *altsd; 312 struct usb_endpoint_descriptor *epd; 313 int err; 314 315 alts = &iface->altsetting[0]; 316 altsd = get_iface_desc(alts); 317 318 /* must have at least one bulk/interrupt endpoint for streaming */ 319 if (altsd->bNumEndpoints < 1) 320 return -ENODEV; 321 epd = get_endpoint(alts, 0); 322 if (!usb_endpoint_xfer_bulk(epd) && 323 !usb_endpoint_xfer_int(epd)) 324 return -ENODEV; 325 326 switch (USB_ID_VENDOR(chip->usb_id)) { 327 case 0x0499: /* Yamaha */ 328 err = create_yamaha_midi_quirk(chip, iface, driver, alts); 329 if (err != -ENODEV) 330 return err; 331 break; 332 case 0x0582: /* Roland */ 333 err = create_roland_midi_quirk(chip, iface, driver, alts); 334 if (err != -ENODEV) 335 return err; 336 break; 337 } 338 339 return create_std_midi_quirk(chip, iface, driver, alts); 340 } 341 342 static int create_autodetect_quirk(struct snd_usb_audio *chip, 343 struct usb_interface *iface, 344 struct usb_driver *driver) 345 { 346 int err; 347 348 err = create_auto_pcm_quirk(chip, iface, driver); 349 if (err == -ENODEV) 350 err = create_auto_midi_quirk(chip, iface, driver); 351 return err; 352 } 353 354 static int create_autodetect_quirks(struct snd_usb_audio *chip, 355 struct usb_interface *iface, 356 struct usb_driver *driver, 357 const struct snd_usb_audio_quirk *quirk) 358 { 359 int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber; 360 int ifcount, ifnum, err; 361 362 err = create_autodetect_quirk(chip, iface, driver); 363 if (err < 0) 364 return err; 365 366 /* 367 * ALSA PCM playback/capture devices cannot be registered in two steps, 368 * so we have to claim the other corresponding interface here. 369 */ 370 ifcount = chip->dev->actconfig->desc.bNumInterfaces; 371 for (ifnum = 0; ifnum < ifcount; ifnum++) { 372 if (ifnum == probed_ifnum || quirk->ifnum >= 0) 373 continue; 374 iface = usb_ifnum_to_if(chip->dev, ifnum); 375 if (!iface || 376 usb_interface_claimed(iface) || 377 get_iface_desc(iface->altsetting)->bInterfaceClass != 378 USB_CLASS_VENDOR_SPEC) 379 continue; 380 381 err = create_autodetect_quirk(chip, iface, driver); 382 if (err >= 0) 383 usb_driver_claim_interface(driver, iface, (void *)-1L); 384 } 385 386 return 0; 387 } 388 389 /* 390 * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface. 391 * The only way to detect the sample rate is by looking at wMaxPacketSize. 392 */ 393 static int create_uaxx_quirk(struct snd_usb_audio *chip, 394 struct usb_interface *iface, 395 struct usb_driver *driver, 396 const struct snd_usb_audio_quirk *quirk) 397 { 398 static const struct audioformat ua_format = { 399 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 400 .channels = 2, 401 .fmt_type = UAC_FORMAT_TYPE_I, 402 .altsetting = 1, 403 .altset_idx = 1, 404 .rates = SNDRV_PCM_RATE_CONTINUOUS, 405 }; 406 struct usb_host_interface *alts; 407 struct usb_interface_descriptor *altsd; 408 struct audioformat *fp; 409 int stream, err; 410 411 /* both PCM and MIDI interfaces have 2 or more altsettings */ 412 if (iface->num_altsetting < 2) 413 return -ENXIO; 414 alts = &iface->altsetting[1]; 415 altsd = get_iface_desc(alts); 416 417 if (altsd->bNumEndpoints == 2) { 418 static const struct snd_usb_midi_endpoint_info ua700_ep = { 419 .out_cables = 0x0003, 420 .in_cables = 0x0003 421 }; 422 static const struct snd_usb_audio_quirk ua700_quirk = { 423 .type = QUIRK_MIDI_FIXED_ENDPOINT, 424 .data = &ua700_ep 425 }; 426 static const struct snd_usb_midi_endpoint_info uaxx_ep = { 427 .out_cables = 0x0001, 428 .in_cables = 0x0001 429 }; 430 static const struct snd_usb_audio_quirk uaxx_quirk = { 431 .type = QUIRK_MIDI_FIXED_ENDPOINT, 432 .data = &uaxx_ep 433 }; 434 const struct snd_usb_audio_quirk *quirk = 435 chip->usb_id == USB_ID(0x0582, 0x002b) 436 ? &ua700_quirk : &uaxx_quirk; 437 return snd_usbmidi_create(chip->card, iface, 438 &chip->midi_list, quirk); 439 } 440 441 if (altsd->bNumEndpoints != 1) 442 return -ENXIO; 443 444 fp = kmemdup(&ua_format, sizeof(*fp), GFP_KERNEL); 445 if (!fp) 446 return -ENOMEM; 447 448 fp->iface = altsd->bInterfaceNumber; 449 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress; 450 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes; 451 fp->datainterval = 0; 452 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); 453 454 switch (fp->maxpacksize) { 455 case 0x120: 456 fp->rate_max = fp->rate_min = 44100; 457 break; 458 case 0x138: 459 case 0x140: 460 fp->rate_max = fp->rate_min = 48000; 461 break; 462 case 0x258: 463 case 0x260: 464 fp->rate_max = fp->rate_min = 96000; 465 break; 466 default: 467 usb_audio_err(chip, "unknown sample rate\n"); 468 kfree(fp); 469 return -ENXIO; 470 } 471 472 stream = (fp->endpoint & USB_DIR_IN) 473 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK; 474 err = snd_usb_add_audio_stream(chip, stream, fp); 475 if (err < 0) { 476 kfree(fp); 477 return err; 478 } 479 usb_set_interface(chip->dev, fp->iface, 0); 480 return 0; 481 } 482 483 /* 484 * Create a standard mixer for the specified interface. 485 */ 486 static int create_standard_mixer_quirk(struct snd_usb_audio *chip, 487 struct usb_interface *iface, 488 struct usb_driver *driver, 489 const struct snd_usb_audio_quirk *quirk) 490 { 491 if (quirk->ifnum < 0) 492 return 0; 493 494 return snd_usb_create_mixer(chip, quirk->ifnum, 0); 495 } 496 497 /* 498 * audio-interface quirks 499 * 500 * returns zero if no standard audio/MIDI parsing is needed. 501 * returns a positive value if standard audio/midi interfaces are parsed 502 * after this. 503 * returns a negative value at error. 504 */ 505 int snd_usb_create_quirk(struct snd_usb_audio *chip, 506 struct usb_interface *iface, 507 struct usb_driver *driver, 508 const struct snd_usb_audio_quirk *quirk) 509 { 510 typedef int (*quirk_func_t)(struct snd_usb_audio *, 511 struct usb_interface *, 512 struct usb_driver *, 513 const struct snd_usb_audio_quirk *); 514 static const quirk_func_t quirk_funcs[] = { 515 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk, 516 [QUIRK_COMPOSITE] = create_composite_quirk, 517 [QUIRK_AUTODETECT] = create_autodetect_quirks, 518 [QUIRK_MIDI_STANDARD_INTERFACE] = create_any_midi_quirk, 519 [QUIRK_MIDI_FIXED_ENDPOINT] = create_any_midi_quirk, 520 [QUIRK_MIDI_YAMAHA] = create_any_midi_quirk, 521 [QUIRK_MIDI_ROLAND] = create_any_midi_quirk, 522 [QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk, 523 [QUIRK_MIDI_NOVATION] = create_any_midi_quirk, 524 [QUIRK_MIDI_RAW_BYTES] = create_any_midi_quirk, 525 [QUIRK_MIDI_EMAGIC] = create_any_midi_quirk, 526 [QUIRK_MIDI_CME] = create_any_midi_quirk, 527 [QUIRK_MIDI_AKAI] = create_any_midi_quirk, 528 [QUIRK_MIDI_FTDI] = create_any_midi_quirk, 529 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk, 530 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk, 531 [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk, 532 [QUIRK_AUDIO_ALIGN_TRANSFER] = create_align_transfer_quirk, 533 [QUIRK_AUDIO_STANDARD_MIXER] = create_standard_mixer_quirk, 534 }; 535 536 if (quirk->type < QUIRK_TYPE_COUNT) { 537 return quirk_funcs[quirk->type](chip, iface, driver, quirk); 538 } else { 539 usb_audio_err(chip, "invalid quirk type %d\n", quirk->type); 540 return -ENXIO; 541 } 542 } 543 544 /* 545 * boot quirks 546 */ 547 548 #define EXTIGY_FIRMWARE_SIZE_OLD 794 549 #define EXTIGY_FIRMWARE_SIZE_NEW 483 550 551 static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf) 552 { 553 struct usb_host_config *config = dev->actconfig; 554 int err; 555 556 if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD || 557 le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) { 558 dev_dbg(&dev->dev, "sending Extigy boot sequence...\n"); 559 /* Send message to force it to reconnect with full interface. */ 560 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0), 561 0x10, 0x43, 0x0001, 0x000a, NULL, 0); 562 if (err < 0) 563 dev_dbg(&dev->dev, "error sending boot message: %d\n", err); 564 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, 565 &dev->descriptor, sizeof(dev->descriptor)); 566 config = dev->actconfig; 567 if (err < 0) 568 dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err); 569 err = usb_reset_configuration(dev); 570 if (err < 0) 571 dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err); 572 dev_dbg(&dev->dev, "extigy_boot: new boot length = %d\n", 573 le16_to_cpu(get_cfg_desc(config)->wTotalLength)); 574 return -ENODEV; /* quit this anyway */ 575 } 576 return 0; 577 } 578 579 static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev) 580 { 581 u8 buf = 1; 582 583 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a, 584 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER, 585 0, 0, &buf, 1); 586 if (buf == 0) { 587 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29, 588 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 589 1, 2000, NULL, 0); 590 return -ENODEV; 591 } 592 return 0; 593 } 594 595 static int snd_usb_fasttrackpro_boot_quirk(struct usb_device *dev) 596 { 597 int err; 598 599 if (dev->actconfig->desc.bConfigurationValue == 1) { 600 dev_info(&dev->dev, 601 "Fast Track Pro switching to config #2\n"); 602 /* This function has to be available by the usb core module. 603 * if it is not avialable the boot quirk has to be left out 604 * and the configuration has to be set by udev or hotplug 605 * rules 606 */ 607 err = usb_driver_set_configuration(dev, 2); 608 if (err < 0) 609 dev_dbg(&dev->dev, 610 "error usb_driver_set_configuration: %d\n", 611 err); 612 /* Always return an error, so that we stop creating a device 613 that will just be destroyed and recreated with a new 614 configuration */ 615 return -ENODEV; 616 } else 617 dev_info(&dev->dev, "Fast Track Pro config OK\n"); 618 619 return 0; 620 } 621 622 /* 623 * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely 624 * documented in the device's data sheet. 625 */ 626 static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value) 627 { 628 u8 buf[4]; 629 buf[0] = 0x20; 630 buf[1] = value & 0xff; 631 buf[2] = (value >> 8) & 0xff; 632 buf[3] = reg; 633 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION, 634 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT, 635 0, 0, &buf, 4); 636 } 637 638 static int snd_usb_cm106_boot_quirk(struct usb_device *dev) 639 { 640 /* 641 * Enable line-out driver mode, set headphone source to front 642 * channels, enable stereo mic. 643 */ 644 return snd_usb_cm106_write_int_reg(dev, 2, 0x8004); 645 } 646 647 /* 648 * C-Media CM6206 is based on CM106 with two additional 649 * registers that are not documented in the data sheet. 650 * Values here are chosen based on sniffing USB traffic 651 * under Windows. 652 */ 653 static int snd_usb_cm6206_boot_quirk(struct usb_device *dev) 654 { 655 int err = 0, reg; 656 int val[] = {0x2004, 0x3000, 0xf800, 0x143f, 0x0000, 0x3000}; 657 658 for (reg = 0; reg < ARRAY_SIZE(val); reg++) { 659 err = snd_usb_cm106_write_int_reg(dev, reg, val[reg]); 660 if (err < 0) 661 return err; 662 } 663 664 return err; 665 } 666 667 /* quirk for Plantronics GameCom 780 with CM6302 chip */ 668 static int snd_usb_gamecon780_boot_quirk(struct usb_device *dev) 669 { 670 /* set the initial volume and don't change; other values are either 671 * too loud or silent due to firmware bug (bko#65251) 672 */ 673 u8 buf[2] = { 0x74, 0xe3 }; 674 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR, 675 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 676 UAC_FU_VOLUME << 8, 9 << 8, buf, 2); 677 } 678 679 /* 680 * Novation Twitch DJ controller 681 * Focusrite Novation Saffire 6 USB audio card 682 */ 683 static int snd_usb_novation_boot_quirk(struct usb_device *dev) 684 { 685 /* preemptively set up the device because otherwise the 686 * raw MIDI endpoints are not active */ 687 usb_set_interface(dev, 0, 1); 688 return 0; 689 } 690 691 /* 692 * This call will put the synth in "USB send" mode, i.e it will send MIDI 693 * messages through USB (this is disabled at startup). The synth will 694 * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB 695 * sign on its LCD. Values here are chosen based on sniffing USB traffic 696 * under Windows. 697 */ 698 static int snd_usb_accessmusic_boot_quirk(struct usb_device *dev) 699 { 700 int err, actual_length; 701 702 /* "midi send" enable */ 703 static const u8 seq[] = { 0x4e, 0x73, 0x52, 0x01 }; 704 705 void *buf = kmemdup(seq, ARRAY_SIZE(seq), GFP_KERNEL); 706 if (!buf) 707 return -ENOMEM; 708 err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x05), buf, 709 ARRAY_SIZE(seq), &actual_length, 1000); 710 kfree(buf); 711 if (err < 0) 712 return err; 713 714 return 0; 715 } 716 717 /* 718 * Some sound cards from Native Instruments are in fact compliant to the USB 719 * audio standard of version 2 and other approved USB standards, even though 720 * they come up as vendor-specific device when first connected. 721 * 722 * However, they can be told to come up with a new set of descriptors 723 * upon their next enumeration, and the interfaces announced by the new 724 * descriptors will then be handled by the kernel's class drivers. As the 725 * product ID will also change, no further checks are required. 726 */ 727 728 static int snd_usb_nativeinstruments_boot_quirk(struct usb_device *dev) 729 { 730 int ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 731 0xaf, USB_TYPE_VENDOR | USB_RECIP_DEVICE, 732 1, 0, NULL, 0, 1000); 733 734 if (ret < 0) 735 return ret; 736 737 usb_reset_device(dev); 738 739 /* return -EAGAIN, so the creation of an audio interface for this 740 * temporary device is aborted. The device will reconnect with a 741 * new product ID */ 742 return -EAGAIN; 743 } 744 745 static void mbox2_setup_48_24_magic(struct usb_device *dev) 746 { 747 u8 srate[3]; 748 u8 temp[12]; 749 750 /* Choose 48000Hz permanently */ 751 srate[0] = 0x80; 752 srate[1] = 0xbb; 753 srate[2] = 0x00; 754 755 /* Send the magic! */ 756 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 757 0x01, 0x22, 0x0100, 0x0085, &temp, 0x0003); 758 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 759 0x81, 0xa2, 0x0100, 0x0085, &srate, 0x0003); 760 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 761 0x81, 0xa2, 0x0100, 0x0086, &srate, 0x0003); 762 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 763 0x81, 0xa2, 0x0100, 0x0003, &srate, 0x0003); 764 return; 765 } 766 767 /* Digidesign Mbox 2 needs to load firmware onboard 768 * and driver must wait a few seconds for initialisation. 769 */ 770 771 #define MBOX2_FIRMWARE_SIZE 646 772 #define MBOX2_BOOT_LOADING 0x01 /* Hard coded into the device */ 773 #define MBOX2_BOOT_READY 0x02 /* Hard coded into the device */ 774 775 static int snd_usb_mbox2_boot_quirk(struct usb_device *dev) 776 { 777 struct usb_host_config *config = dev->actconfig; 778 int err; 779 u8 bootresponse[0x12]; 780 int fwsize; 781 int count; 782 783 fwsize = le16_to_cpu(get_cfg_desc(config)->wTotalLength); 784 785 if (fwsize != MBOX2_FIRMWARE_SIZE) { 786 dev_err(&dev->dev, "Invalid firmware size=%d.\n", fwsize); 787 return -ENODEV; 788 } 789 790 dev_dbg(&dev->dev, "Sending Digidesign Mbox 2 boot sequence...\n"); 791 792 count = 0; 793 bootresponse[0] = MBOX2_BOOT_LOADING; 794 while ((bootresponse[0] == MBOX2_BOOT_LOADING) && (count < 10)) { 795 msleep(500); /* 0.5 second delay */ 796 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 797 /* Control magic - load onboard firmware */ 798 0x85, 0xc0, 0x0001, 0x0000, &bootresponse, 0x0012); 799 if (bootresponse[0] == MBOX2_BOOT_READY) 800 break; 801 dev_dbg(&dev->dev, "device not ready, resending boot sequence...\n"); 802 count++; 803 } 804 805 if (bootresponse[0] != MBOX2_BOOT_READY) { 806 dev_err(&dev->dev, "Unknown bootresponse=%d, or timed out, ignoring device.\n", bootresponse[0]); 807 return -ENODEV; 808 } 809 810 dev_dbg(&dev->dev, "device initialised!\n"); 811 812 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, 813 &dev->descriptor, sizeof(dev->descriptor)); 814 config = dev->actconfig; 815 if (err < 0) 816 dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err); 817 818 err = usb_reset_configuration(dev); 819 if (err < 0) 820 dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err); 821 dev_dbg(&dev->dev, "mbox2_boot: new boot length = %d\n", 822 le16_to_cpu(get_cfg_desc(config)->wTotalLength)); 823 824 mbox2_setup_48_24_magic(dev); 825 826 dev_info(&dev->dev, "Digidesign Mbox 2: 24bit 48kHz"); 827 828 return 0; /* Successful boot */ 829 } 830 831 /* 832 * Setup quirks 833 */ 834 #define MAUDIO_SET 0x01 /* parse device_setup */ 835 #define MAUDIO_SET_COMPATIBLE 0x80 /* use only "win-compatible" interfaces */ 836 #define MAUDIO_SET_DTS 0x02 /* enable DTS Digital Output */ 837 #define MAUDIO_SET_96K 0x04 /* 48-96KHz rate if set, 8-48KHz otherwise */ 838 #define MAUDIO_SET_24B 0x08 /* 24bits sample if set, 16bits otherwise */ 839 #define MAUDIO_SET_DI 0x10 /* enable Digital Input */ 840 #define MAUDIO_SET_MASK 0x1f /* bit mask for setup value */ 841 #define MAUDIO_SET_24B_48K_DI 0x19 /* 24bits+48KHz+Digital Input */ 842 #define MAUDIO_SET_24B_48K_NOTDI 0x09 /* 24bits+48KHz+No Digital Input */ 843 #define MAUDIO_SET_16B_48K_DI 0x11 /* 16bits+48KHz+Digital Input */ 844 #define MAUDIO_SET_16B_48K_NOTDI 0x01 /* 16bits+48KHz+No Digital Input */ 845 846 static int quattro_skip_setting_quirk(struct snd_usb_audio *chip, 847 int iface, int altno) 848 { 849 /* Reset ALL ifaces to 0 altsetting. 850 * Call it for every possible altsetting of every interface. 851 */ 852 usb_set_interface(chip->dev, iface, 0); 853 if (chip->setup & MAUDIO_SET) { 854 if (chip->setup & MAUDIO_SET_COMPATIBLE) { 855 if (iface != 1 && iface != 2) 856 return 1; /* skip all interfaces but 1 and 2 */ 857 } else { 858 unsigned int mask; 859 if (iface == 1 || iface == 2) 860 return 1; /* skip interfaces 1 and 2 */ 861 if ((chip->setup & MAUDIO_SET_96K) && altno != 1) 862 return 1; /* skip this altsetting */ 863 mask = chip->setup & MAUDIO_SET_MASK; 864 if (mask == MAUDIO_SET_24B_48K_DI && altno != 2) 865 return 1; /* skip this altsetting */ 866 if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3) 867 return 1; /* skip this altsetting */ 868 if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 4) 869 return 1; /* skip this altsetting */ 870 } 871 } 872 usb_audio_dbg(chip, 873 "using altsetting %d for interface %d config %d\n", 874 altno, iface, chip->setup); 875 return 0; /* keep this altsetting */ 876 } 877 878 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip, 879 int iface, 880 int altno) 881 { 882 /* Reset ALL ifaces to 0 altsetting. 883 * Call it for every possible altsetting of every interface. 884 */ 885 usb_set_interface(chip->dev, iface, 0); 886 887 if (chip->setup & MAUDIO_SET) { 888 unsigned int mask; 889 if ((chip->setup & MAUDIO_SET_DTS) && altno != 6) 890 return 1; /* skip this altsetting */ 891 if ((chip->setup & MAUDIO_SET_96K) && altno != 1) 892 return 1; /* skip this altsetting */ 893 mask = chip->setup & MAUDIO_SET_MASK; 894 if (mask == MAUDIO_SET_24B_48K_DI && altno != 2) 895 return 1; /* skip this altsetting */ 896 if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3) 897 return 1; /* skip this altsetting */ 898 if (mask == MAUDIO_SET_16B_48K_DI && altno != 4) 899 return 1; /* skip this altsetting */ 900 if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 5) 901 return 1; /* skip this altsetting */ 902 } 903 904 return 0; /* keep this altsetting */ 905 } 906 907 static int fasttrackpro_skip_setting_quirk(struct snd_usb_audio *chip, 908 int iface, int altno) 909 { 910 /* Reset ALL ifaces to 0 altsetting. 911 * Call it for every possible altsetting of every interface. 912 */ 913 usb_set_interface(chip->dev, iface, 0); 914 915 /* possible configuration where both inputs and only one output is 916 *used is not supported by the current setup 917 */ 918 if (chip->setup & (MAUDIO_SET | MAUDIO_SET_24B)) { 919 if (chip->setup & MAUDIO_SET_96K) { 920 if (altno != 3 && altno != 6) 921 return 1; 922 } else if (chip->setup & MAUDIO_SET_DI) { 923 if (iface == 4) 924 return 1; /* no analog input */ 925 if (altno != 2 && altno != 5) 926 return 1; /* enable only altsets 2 and 5 */ 927 } else { 928 if (iface == 5) 929 return 1; /* disable digialt input */ 930 if (altno != 2 && altno != 5) 931 return 1; /* enalbe only altsets 2 and 5 */ 932 } 933 } else { 934 /* keep only 16-Bit mode */ 935 if (altno != 1) 936 return 1; 937 } 938 939 usb_audio_dbg(chip, 940 "using altsetting %d for interface %d config %d\n", 941 altno, iface, chip->setup); 942 return 0; /* keep this altsetting */ 943 } 944 945 int snd_usb_apply_interface_quirk(struct snd_usb_audio *chip, 946 int iface, 947 int altno) 948 { 949 /* audiophile usb: skip altsets incompatible with device_setup */ 950 if (chip->usb_id == USB_ID(0x0763, 0x2003)) 951 return audiophile_skip_setting_quirk(chip, iface, altno); 952 /* quattro usb: skip altsets incompatible with device_setup */ 953 if (chip->usb_id == USB_ID(0x0763, 0x2001)) 954 return quattro_skip_setting_quirk(chip, iface, altno); 955 /* fasttrackpro usb: skip altsets incompatible with device_setup */ 956 if (chip->usb_id == USB_ID(0x0763, 0x2012)) 957 return fasttrackpro_skip_setting_quirk(chip, iface, altno); 958 959 return 0; 960 } 961 962 int snd_usb_apply_boot_quirk(struct usb_device *dev, 963 struct usb_interface *intf, 964 const struct snd_usb_audio_quirk *quirk) 965 { 966 u32 id = USB_ID(le16_to_cpu(dev->descriptor.idVendor), 967 le16_to_cpu(dev->descriptor.idProduct)); 968 969 switch (id) { 970 case USB_ID(0x041e, 0x3000): 971 /* SB Extigy needs special boot-up sequence */ 972 /* if more models come, this will go to the quirk list. */ 973 return snd_usb_extigy_boot_quirk(dev, intf); 974 975 case USB_ID(0x041e, 0x3020): 976 /* SB Audigy 2 NX needs its own boot-up magic, too */ 977 return snd_usb_audigy2nx_boot_quirk(dev); 978 979 case USB_ID(0x10f5, 0x0200): 980 /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */ 981 return snd_usb_cm106_boot_quirk(dev); 982 983 case USB_ID(0x0d8c, 0x0102): 984 /* C-Media CM6206 / CM106-Like Sound Device */ 985 case USB_ID(0x0ccd, 0x00b1): /* Terratec Aureon 7.1 USB */ 986 return snd_usb_cm6206_boot_quirk(dev); 987 988 case USB_ID(0x0dba, 0x3000): 989 /* Digidesign Mbox 2 */ 990 return snd_usb_mbox2_boot_quirk(dev); 991 992 case USB_ID(0x1235, 0x0010): /* Focusrite Novation Saffire 6 USB */ 993 case USB_ID(0x1235, 0x0018): /* Focusrite Novation Twitch */ 994 return snd_usb_novation_boot_quirk(dev); 995 996 case USB_ID(0x133e, 0x0815): 997 /* Access Music VirusTI Desktop */ 998 return snd_usb_accessmusic_boot_quirk(dev); 999 1000 case USB_ID(0x17cc, 0x1000): /* Komplete Audio 6 */ 1001 case USB_ID(0x17cc, 0x1010): /* Traktor Audio 6 */ 1002 case USB_ID(0x17cc, 0x1020): /* Traktor Audio 10 */ 1003 return snd_usb_nativeinstruments_boot_quirk(dev); 1004 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */ 1005 return snd_usb_fasttrackpro_boot_quirk(dev); 1006 case USB_ID(0x047f, 0xc010): /* Plantronics Gamecom 780 */ 1007 return snd_usb_gamecon780_boot_quirk(dev); 1008 } 1009 1010 return 0; 1011 } 1012 1013 /* 1014 * check if the device uses big-endian samples 1015 */ 1016 int snd_usb_is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *fp) 1017 { 1018 /* it depends on altsetting whether the device is big-endian or not */ 1019 switch (chip->usb_id) { 1020 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */ 1021 if (fp->altsetting == 2 || fp->altsetting == 3 || 1022 fp->altsetting == 5 || fp->altsetting == 6) 1023 return 1; 1024 break; 1025 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */ 1026 if (chip->setup == 0x00 || 1027 fp->altsetting == 1 || fp->altsetting == 2 || 1028 fp->altsetting == 3) 1029 return 1; 1030 break; 1031 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro */ 1032 if (fp->altsetting == 2 || fp->altsetting == 3 || 1033 fp->altsetting == 5 || fp->altsetting == 6) 1034 return 1; 1035 break; 1036 } 1037 return 0; 1038 } 1039 1040 /* 1041 * For E-Mu 0404USB/0202USB/TrackerPre/0204 sample rate should be set for device, 1042 * not for interface. 1043 */ 1044 1045 enum { 1046 EMU_QUIRK_SR_44100HZ = 0, 1047 EMU_QUIRK_SR_48000HZ, 1048 EMU_QUIRK_SR_88200HZ, 1049 EMU_QUIRK_SR_96000HZ, 1050 EMU_QUIRK_SR_176400HZ, 1051 EMU_QUIRK_SR_192000HZ 1052 }; 1053 1054 static void set_format_emu_quirk(struct snd_usb_substream *subs, 1055 struct audioformat *fmt) 1056 { 1057 unsigned char emu_samplerate_id = 0; 1058 1059 /* When capture is active 1060 * sample rate shouldn't be changed 1061 * by playback substream 1062 */ 1063 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) { 1064 if (subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE].interface != -1) 1065 return; 1066 } 1067 1068 switch (fmt->rate_min) { 1069 case 48000: 1070 emu_samplerate_id = EMU_QUIRK_SR_48000HZ; 1071 break; 1072 case 88200: 1073 emu_samplerate_id = EMU_QUIRK_SR_88200HZ; 1074 break; 1075 case 96000: 1076 emu_samplerate_id = EMU_QUIRK_SR_96000HZ; 1077 break; 1078 case 176400: 1079 emu_samplerate_id = EMU_QUIRK_SR_176400HZ; 1080 break; 1081 case 192000: 1082 emu_samplerate_id = EMU_QUIRK_SR_192000HZ; 1083 break; 1084 default: 1085 emu_samplerate_id = EMU_QUIRK_SR_44100HZ; 1086 break; 1087 } 1088 snd_emuusb_set_samplerate(subs->stream->chip, emu_samplerate_id); 1089 subs->pkt_offset_adj = (emu_samplerate_id >= EMU_QUIRK_SR_176400HZ) ? 4 : 0; 1090 } 1091 1092 void snd_usb_set_format_quirk(struct snd_usb_substream *subs, 1093 struct audioformat *fmt) 1094 { 1095 switch (subs->stream->chip->usb_id) { 1096 case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */ 1097 case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */ 1098 case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */ 1099 case USB_ID(0x041e, 0x3f19): /* E-Mu 0204 USB */ 1100 set_format_emu_quirk(subs, fmt); 1101 break; 1102 } 1103 } 1104 1105 void snd_usb_endpoint_start_quirk(struct snd_usb_endpoint *ep) 1106 { 1107 /* 1108 * "Playback Design" products send bogus feedback data at the start 1109 * of the stream. Ignore them. 1110 */ 1111 if ((le16_to_cpu(ep->chip->dev->descriptor.idVendor) == 0x23ba) && 1112 ep->type == SND_USB_ENDPOINT_TYPE_SYNC) 1113 ep->skip_packets = 4; 1114 1115 /* 1116 * M-Audio Fast Track C400/C600 - when packets are not skipped, real 1117 * world latency varies by approx. +/- 50 frames (at 96KHz) each time 1118 * the stream is (re)started. When skipping packets 16 at endpoint 1119 * start up, the real world latency is stable within +/- 1 frame (also 1120 * across power cycles). 1121 */ 1122 if ((ep->chip->usb_id == USB_ID(0x0763, 0x2030) || 1123 ep->chip->usb_id == USB_ID(0x0763, 0x2031)) && 1124 ep->type == SND_USB_ENDPOINT_TYPE_DATA) 1125 ep->skip_packets = 16; 1126 } 1127 1128 void snd_usb_set_interface_quirk(struct usb_device *dev) 1129 { 1130 /* 1131 * "Playback Design" products need a 50ms delay after setting the 1132 * USB interface. 1133 */ 1134 if (le16_to_cpu(dev->descriptor.idVendor) == 0x23ba) 1135 mdelay(50); 1136 } 1137 1138 void snd_usb_ctl_msg_quirk(struct usb_device *dev, unsigned int pipe, 1139 __u8 request, __u8 requesttype, __u16 value, 1140 __u16 index, void *data, __u16 size) 1141 { 1142 /* 1143 * "Playback Design" products need a 20ms delay after each 1144 * class compliant request 1145 */ 1146 if ((le16_to_cpu(dev->descriptor.idVendor) == 0x23ba) && 1147 (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS) 1148 mdelay(20); 1149 } 1150 1151 /* 1152 * snd_usb_interface_dsd_format_quirks() is called from format.c to 1153 * augment the PCM format bit-field for DSD types. The UAC standards 1154 * don't have a designated bit field to denote DSD-capable interfaces, 1155 * hence all hardware that is known to support this format has to be 1156 * listed here. 1157 */ 1158 u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip, 1159 struct audioformat *fp, 1160 unsigned int sample_bytes) 1161 { 1162 /* Playback Designs */ 1163 if (le16_to_cpu(chip->dev->descriptor.idVendor) == 0x23ba) { 1164 switch (fp->altsetting) { 1165 case 1: 1166 fp->dsd_dop = true; 1167 return SNDRV_PCM_FMTBIT_DSD_U16_LE; 1168 case 2: 1169 fp->dsd_bitrev = true; 1170 return SNDRV_PCM_FMTBIT_DSD_U8; 1171 case 3: 1172 fp->dsd_bitrev = true; 1173 return SNDRV_PCM_FMTBIT_DSD_U16_LE; 1174 } 1175 } 1176 1177 /* XMOS based USB DACs */ 1178 switch (chip->usb_id) { 1179 /* iFi Audio micro/nano iDSD */ 1180 case USB_ID(0x20b1, 0x3008): 1181 if (fp->altsetting == 2) 1182 return SNDRV_PCM_FMTBIT_DSD_U32_LE; 1183 break; 1184 /* DIYINHK DSD DXD 384kHz USB to I2S/DSD */ 1185 case USB_ID(0x20b1, 0x2009): 1186 if (fp->altsetting == 3) 1187 return SNDRV_PCM_FMTBIT_DSD_U32_LE; 1188 break; 1189 default: 1190 break; 1191 } 1192 1193 return 0; 1194 } 1195