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/bitrev.h> 8 #include <linux/ratelimit.h> 9 #include <linux/usb.h> 10 #include <linux/usb/audio.h> 11 #include <linux/usb/audio-v2.h> 12 13 #include <sound/core.h> 14 #include <sound/pcm.h> 15 #include <sound/pcm_params.h> 16 17 #include "usbaudio.h" 18 #include "card.h" 19 #include "quirks.h" 20 #include "endpoint.h" 21 #include "helper.h" 22 #include "pcm.h" 23 #include "clock.h" 24 #include "power.h" 25 #include "media.h" 26 #include "implicit.h" 27 28 #define SUBSTREAM_FLAG_DATA_EP_STARTED 0 29 #define SUBSTREAM_FLAG_SYNC_EP_STARTED 1 30 31 /* return the estimated delay based on USB frame counters */ 32 static snd_pcm_uframes_t snd_usb_pcm_delay(struct snd_usb_substream *subs, 33 struct snd_pcm_runtime *runtime) 34 { 35 unsigned int current_frame_number; 36 unsigned int frame_diff; 37 int est_delay; 38 int queued; 39 40 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) { 41 queued = bytes_to_frames(runtime, subs->inflight_bytes); 42 if (!queued) 43 return 0; 44 } else if (!subs->running) { 45 return 0; 46 } 47 48 current_frame_number = usb_get_current_frame_number(subs->dev); 49 /* 50 * HCD implementations use different widths, use lower 8 bits. 51 * The delay will be managed up to 256ms, which is more than 52 * enough 53 */ 54 frame_diff = (current_frame_number - subs->last_frame_number) & 0xff; 55 56 /* Approximation based on number of samples per USB frame (ms), 57 some truncation for 44.1 but the estimate is good enough */ 58 est_delay = frame_diff * runtime->rate / 1000; 59 60 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) { 61 est_delay = queued - est_delay; 62 if (est_delay < 0) 63 est_delay = 0; 64 } 65 66 return est_delay; 67 } 68 69 /* 70 * return the current pcm pointer. just based on the hwptr_done value. 71 */ 72 static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream) 73 { 74 struct snd_pcm_runtime *runtime = substream->runtime; 75 struct snd_usb_substream *subs = runtime->private_data; 76 unsigned int hwptr_done; 77 78 if (atomic_read(&subs->stream->chip->shutdown)) 79 return SNDRV_PCM_POS_XRUN; 80 spin_lock(&subs->lock); 81 hwptr_done = subs->hwptr_done; 82 runtime->delay = snd_usb_pcm_delay(subs, runtime); 83 spin_unlock(&subs->lock); 84 return bytes_to_frames(runtime, hwptr_done); 85 } 86 87 /* 88 * find a matching audio format 89 */ 90 static const struct audioformat * 91 find_format(struct list_head *fmt_list_head, snd_pcm_format_t format, 92 unsigned int rate, unsigned int channels, bool strict_match, 93 struct snd_usb_substream *subs) 94 { 95 const struct audioformat *fp; 96 const struct audioformat *found = NULL; 97 int cur_attr = 0, attr; 98 99 list_for_each_entry(fp, fmt_list_head, list) { 100 if (strict_match) { 101 if (!(fp->formats & pcm_format_to_bits(format))) 102 continue; 103 if (fp->channels != channels) 104 continue; 105 } 106 if (rate < fp->rate_min || rate > fp->rate_max) 107 continue; 108 if (!(fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) { 109 unsigned int i; 110 for (i = 0; i < fp->nr_rates; i++) 111 if (fp->rate_table[i] == rate) 112 break; 113 if (i >= fp->nr_rates) 114 continue; 115 } 116 attr = fp->ep_attr & USB_ENDPOINT_SYNCTYPE; 117 if (!found) { 118 found = fp; 119 cur_attr = attr; 120 continue; 121 } 122 /* avoid async out and adaptive in if the other method 123 * supports the same format. 124 * this is a workaround for the case like 125 * M-audio audiophile USB. 126 */ 127 if (subs && attr != cur_attr) { 128 if ((attr == USB_ENDPOINT_SYNC_ASYNC && 129 subs->direction == SNDRV_PCM_STREAM_PLAYBACK) || 130 (attr == USB_ENDPOINT_SYNC_ADAPTIVE && 131 subs->direction == SNDRV_PCM_STREAM_CAPTURE)) 132 continue; 133 if ((cur_attr == USB_ENDPOINT_SYNC_ASYNC && 134 subs->direction == SNDRV_PCM_STREAM_PLAYBACK) || 135 (cur_attr == USB_ENDPOINT_SYNC_ADAPTIVE && 136 subs->direction == SNDRV_PCM_STREAM_CAPTURE)) { 137 found = fp; 138 cur_attr = attr; 139 continue; 140 } 141 } 142 /* find the format with the largest max. packet size */ 143 if (fp->maxpacksize > found->maxpacksize) { 144 found = fp; 145 cur_attr = attr; 146 } 147 } 148 return found; 149 } 150 151 static const struct audioformat * 152 find_substream_format(struct snd_usb_substream *subs, 153 const struct snd_pcm_hw_params *params) 154 { 155 return find_format(&subs->fmt_list, params_format(params), 156 params_rate(params), params_channels(params), 157 true, subs); 158 } 159 160 bool snd_usb_pcm_has_fixed_rate(struct snd_usb_substream *subs) 161 { 162 const struct audioformat *fp; 163 struct snd_usb_audio *chip; 164 int rate = -1; 165 166 if (!subs) 167 return false; 168 chip = subs->stream->chip; 169 if (!(chip->quirk_flags & QUIRK_FLAG_FIXED_RATE)) 170 return false; 171 list_for_each_entry(fp, &subs->fmt_list, list) { 172 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) 173 return false; 174 if (fp->nr_rates < 1) 175 continue; 176 if (fp->nr_rates > 1) 177 return false; 178 if (rate < 0) { 179 rate = fp->rate_table[0]; 180 continue; 181 } 182 if (rate != fp->rate_table[0]) 183 return false; 184 } 185 return true; 186 } 187 188 static int init_pitch_v1(struct snd_usb_audio *chip, int ep) 189 { 190 struct usb_device *dev = chip->dev; 191 unsigned char data[1]; 192 int err; 193 194 data[0] = 1; 195 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR, 196 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT, 197 UAC_EP_CS_ATTR_PITCH_CONTROL << 8, ep, 198 data, sizeof(data)); 199 return err; 200 } 201 202 static int init_pitch_v2(struct snd_usb_audio *chip, int ep) 203 { 204 struct usb_device *dev = chip->dev; 205 unsigned char data[1]; 206 int err; 207 208 data[0] = 1; 209 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR, 210 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT, 211 UAC2_EP_CS_PITCH << 8, 0, 212 data, sizeof(data)); 213 return err; 214 } 215 216 /* 217 * initialize the pitch control and sample rate 218 */ 219 int snd_usb_init_pitch(struct snd_usb_audio *chip, 220 const struct audioformat *fmt) 221 { 222 int err; 223 224 /* if endpoint doesn't have pitch control, bail out */ 225 if (!(fmt->attributes & UAC_EP_CS_ATTR_PITCH_CONTROL)) 226 return 0; 227 228 usb_audio_dbg(chip, "enable PITCH for EP 0x%x\n", fmt->endpoint); 229 230 switch (fmt->protocol) { 231 case UAC_VERSION_1: 232 err = init_pitch_v1(chip, fmt->endpoint); 233 break; 234 case UAC_VERSION_2: 235 err = init_pitch_v2(chip, fmt->endpoint); 236 break; 237 default: 238 return 0; 239 } 240 241 if (err < 0) { 242 usb_audio_err(chip, "failed to enable PITCH for EP 0x%x\n", 243 fmt->endpoint); 244 return err; 245 } 246 247 return 0; 248 } 249 250 static bool stop_endpoints(struct snd_usb_substream *subs, bool keep_pending) 251 { 252 bool stopped = 0; 253 254 if (test_and_clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags)) { 255 snd_usb_endpoint_stop(subs->sync_endpoint, keep_pending); 256 stopped = true; 257 } 258 if (test_and_clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags)) { 259 snd_usb_endpoint_stop(subs->data_endpoint, keep_pending); 260 stopped = true; 261 } 262 return stopped; 263 } 264 265 static int start_endpoints(struct snd_usb_substream *subs) 266 { 267 int err; 268 269 if (!subs->data_endpoint) 270 return -EINVAL; 271 272 if (!test_and_set_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags)) { 273 err = snd_usb_endpoint_start(subs->data_endpoint); 274 if (err < 0) { 275 clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags); 276 goto error; 277 } 278 } 279 280 if (subs->sync_endpoint && 281 !test_and_set_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags)) { 282 err = snd_usb_endpoint_start(subs->sync_endpoint); 283 if (err < 0) { 284 clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags); 285 goto error; 286 } 287 } 288 289 return 0; 290 291 error: 292 stop_endpoints(subs, false); 293 return err; 294 } 295 296 static void sync_pending_stops(struct snd_usb_substream *subs) 297 { 298 snd_usb_endpoint_sync_pending_stop(subs->sync_endpoint); 299 snd_usb_endpoint_sync_pending_stop(subs->data_endpoint); 300 } 301 302 /* PCM sync_stop callback */ 303 static int snd_usb_pcm_sync_stop(struct snd_pcm_substream *substream) 304 { 305 struct snd_usb_substream *subs = substream->runtime->private_data; 306 307 sync_pending_stops(subs); 308 return 0; 309 } 310 311 /* Set up sync endpoint */ 312 int snd_usb_audioformat_set_sync_ep(struct snd_usb_audio *chip, 313 struct audioformat *fmt) 314 { 315 struct usb_device *dev = chip->dev; 316 struct usb_host_interface *alts; 317 struct usb_interface_descriptor *altsd; 318 unsigned int ep, attr, sync_attr; 319 bool is_playback; 320 int err; 321 322 if (fmt->sync_ep) 323 return 0; /* already set up */ 324 325 alts = snd_usb_get_host_interface(chip, fmt->iface, fmt->altsetting); 326 if (!alts) 327 return 0; 328 altsd = get_iface_desc(alts); 329 330 err = snd_usb_parse_implicit_fb_quirk(chip, fmt, alts); 331 if (err > 0) 332 return 0; /* matched */ 333 334 /* 335 * Generic sync EP handling 336 */ 337 338 if (fmt->ep_idx > 0 || altsd->bNumEndpoints < 2) 339 return 0; 340 341 is_playback = !(get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN); 342 attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE; 343 if ((is_playback && (attr == USB_ENDPOINT_SYNC_SYNC || 344 attr == USB_ENDPOINT_SYNC_ADAPTIVE)) || 345 (!is_playback && attr != USB_ENDPOINT_SYNC_ADAPTIVE)) 346 return 0; 347 348 sync_attr = get_endpoint(alts, 1)->bmAttributes; 349 350 /* 351 * In case of illegal SYNC_NONE for OUT endpoint, we keep going to see 352 * if we don't find a sync endpoint, as on M-Audio Transit. In case of 353 * error fall back to SYNC mode and don't create sync endpoint 354 */ 355 356 /* check sync-pipe endpoint */ 357 /* ... and check descriptor size before accessing bSynchAddress 358 because there is a version of the SB Audigy 2 NX firmware lacking 359 the audio fields in the endpoint descriptors */ 360 if ((sync_attr & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_ISOC || 361 (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && 362 get_endpoint(alts, 1)->bSynchAddress != 0)) { 363 dev_err(&dev->dev, 364 "%d:%d : invalid sync pipe. bmAttributes %02x, bLength %d, bSynchAddress %02x\n", 365 fmt->iface, fmt->altsetting, 366 get_endpoint(alts, 1)->bmAttributes, 367 get_endpoint(alts, 1)->bLength, 368 get_endpoint(alts, 1)->bSynchAddress); 369 if (is_playback && attr == USB_ENDPOINT_SYNC_NONE) 370 return 0; 371 return -EINVAL; 372 } 373 ep = get_endpoint(alts, 1)->bEndpointAddress; 374 if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && 375 get_endpoint(alts, 0)->bSynchAddress != 0 && 376 ((is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) || 377 (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) { 378 dev_err(&dev->dev, 379 "%d:%d : invalid sync pipe. is_playback %d, ep %02x, bSynchAddress %02x\n", 380 fmt->iface, fmt->altsetting, 381 is_playback, ep, get_endpoint(alts, 0)->bSynchAddress); 382 if (is_playback && attr == USB_ENDPOINT_SYNC_NONE) 383 return 0; 384 return -EINVAL; 385 } 386 387 fmt->sync_ep = ep; 388 fmt->sync_iface = altsd->bInterfaceNumber; 389 fmt->sync_altsetting = altsd->bAlternateSetting; 390 fmt->sync_ep_idx = 1; 391 if ((sync_attr & USB_ENDPOINT_USAGE_MASK) == USB_ENDPOINT_USAGE_IMPLICIT_FB) 392 fmt->implicit_fb = 1; 393 394 dev_dbg(&dev->dev, "%d:%d: found sync_ep=0x%x, iface=%d, alt=%d, implicit_fb=%d\n", 395 fmt->iface, fmt->altsetting, fmt->sync_ep, fmt->sync_iface, 396 fmt->sync_altsetting, fmt->implicit_fb); 397 398 return 0; 399 } 400 401 static int snd_usb_pcm_change_state(struct snd_usb_substream *subs, int state) 402 { 403 int ret; 404 405 if (!subs->str_pd) 406 return 0; 407 408 ret = snd_usb_power_domain_set(subs->stream->chip, subs->str_pd, state); 409 if (ret < 0) { 410 dev_err(&subs->dev->dev, 411 "Cannot change Power Domain ID: %d to state: %d. Err: %d\n", 412 subs->str_pd->pd_id, state, ret); 413 return ret; 414 } 415 416 return 0; 417 } 418 419 int snd_usb_pcm_suspend(struct snd_usb_stream *as) 420 { 421 int ret; 422 423 ret = snd_usb_pcm_change_state(&as->substream[0], UAC3_PD_STATE_D2); 424 if (ret < 0) 425 return ret; 426 427 ret = snd_usb_pcm_change_state(&as->substream[1], UAC3_PD_STATE_D2); 428 if (ret < 0) 429 return ret; 430 431 return 0; 432 } 433 434 int snd_usb_pcm_resume(struct snd_usb_stream *as) 435 { 436 int ret; 437 438 ret = snd_usb_pcm_change_state(&as->substream[0], UAC3_PD_STATE_D1); 439 if (ret < 0) 440 return ret; 441 442 ret = snd_usb_pcm_change_state(&as->substream[1], UAC3_PD_STATE_D1); 443 if (ret < 0) 444 return ret; 445 446 return 0; 447 } 448 449 static void close_endpoints(struct snd_usb_audio *chip, 450 struct snd_usb_substream *subs) 451 { 452 if (subs->data_endpoint) { 453 snd_usb_endpoint_set_sync(chip, subs->data_endpoint, NULL); 454 snd_usb_endpoint_close(chip, subs->data_endpoint); 455 subs->data_endpoint = NULL; 456 } 457 458 if (subs->sync_endpoint) { 459 snd_usb_endpoint_close(chip, subs->sync_endpoint); 460 subs->sync_endpoint = NULL; 461 } 462 } 463 464 /* 465 * hw_params callback 466 * 467 * allocate a buffer and set the given audio format. 468 * 469 * so far we use a physically linear buffer although packetize transfer 470 * doesn't need a continuous area. 471 * if sg buffer is supported on the later version of alsa, we'll follow 472 * that. 473 */ 474 static int snd_usb_hw_params(struct snd_pcm_substream *substream, 475 struct snd_pcm_hw_params *hw_params) 476 { 477 struct snd_usb_substream *subs = substream->runtime->private_data; 478 struct snd_usb_audio *chip = subs->stream->chip; 479 const struct audioformat *fmt; 480 const struct audioformat *sync_fmt; 481 bool fixed_rate, sync_fixed_rate; 482 int ret; 483 484 ret = snd_media_start_pipeline(subs); 485 if (ret) 486 return ret; 487 488 fixed_rate = snd_usb_pcm_has_fixed_rate(subs); 489 fmt = find_substream_format(subs, hw_params); 490 if (!fmt) { 491 usb_audio_dbg(chip, 492 "cannot find format: format=%s, rate=%d, channels=%d\n", 493 snd_pcm_format_name(params_format(hw_params)), 494 params_rate(hw_params), params_channels(hw_params)); 495 ret = -EINVAL; 496 goto stop_pipeline; 497 } 498 499 if (fmt->implicit_fb) { 500 sync_fmt = snd_usb_find_implicit_fb_sync_format(chip, fmt, 501 hw_params, 502 !substream->stream, 503 &sync_fixed_rate); 504 if (!sync_fmt) { 505 usb_audio_dbg(chip, 506 "cannot find sync format: ep=0x%x, iface=%d:%d, format=%s, rate=%d, channels=%d\n", 507 fmt->sync_ep, fmt->sync_iface, 508 fmt->sync_altsetting, 509 snd_pcm_format_name(params_format(hw_params)), 510 params_rate(hw_params), params_channels(hw_params)); 511 ret = -EINVAL; 512 goto stop_pipeline; 513 } 514 } else { 515 sync_fmt = fmt; 516 sync_fixed_rate = fixed_rate; 517 } 518 519 ret = snd_usb_lock_shutdown(chip); 520 if (ret < 0) 521 goto stop_pipeline; 522 523 ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D0); 524 if (ret < 0) 525 goto unlock; 526 527 if (subs->data_endpoint) { 528 if (snd_usb_endpoint_compatible(chip, subs->data_endpoint, 529 fmt, hw_params)) 530 goto unlock; 531 if (stop_endpoints(subs, false)) 532 sync_pending_stops(subs); 533 close_endpoints(chip, subs); 534 } 535 536 subs->data_endpoint = snd_usb_endpoint_open(chip, fmt, hw_params, false, fixed_rate); 537 if (!subs->data_endpoint) { 538 ret = -EINVAL; 539 goto unlock; 540 } 541 542 if (fmt->sync_ep) { 543 subs->sync_endpoint = snd_usb_endpoint_open(chip, sync_fmt, 544 hw_params, 545 fmt == sync_fmt, 546 sync_fixed_rate); 547 if (!subs->sync_endpoint) { 548 ret = -EINVAL; 549 goto unlock; 550 } 551 552 snd_usb_endpoint_set_sync(chip, subs->data_endpoint, 553 subs->sync_endpoint); 554 } 555 556 mutex_lock(&chip->mutex); 557 subs->cur_audiofmt = fmt; 558 mutex_unlock(&chip->mutex); 559 560 if (!subs->data_endpoint->need_setup) 561 goto unlock; 562 563 if (subs->sync_endpoint) { 564 ret = snd_usb_endpoint_set_params(chip, subs->sync_endpoint); 565 if (ret < 0) 566 goto unlock; 567 } 568 569 ret = snd_usb_endpoint_set_params(chip, subs->data_endpoint); 570 571 unlock: 572 if (ret < 0) 573 close_endpoints(chip, subs); 574 575 snd_usb_unlock_shutdown(chip); 576 stop_pipeline: 577 if (ret < 0) 578 snd_media_stop_pipeline(subs); 579 580 return ret; 581 } 582 583 /* 584 * hw_free callback 585 * 586 * reset the audio format and release the buffer 587 */ 588 static int snd_usb_hw_free(struct snd_pcm_substream *substream) 589 { 590 struct snd_usb_substream *subs = substream->runtime->private_data; 591 struct snd_usb_audio *chip = subs->stream->chip; 592 593 snd_media_stop_pipeline(subs); 594 mutex_lock(&chip->mutex); 595 subs->cur_audiofmt = NULL; 596 mutex_unlock(&chip->mutex); 597 if (!snd_usb_lock_shutdown(chip)) { 598 if (stop_endpoints(subs, false)) 599 sync_pending_stops(subs); 600 close_endpoints(chip, subs); 601 snd_usb_unlock_shutdown(chip); 602 } 603 604 return 0; 605 } 606 607 /* free-wheeling mode? (e.g. dmix) */ 608 static int in_free_wheeling_mode(struct snd_pcm_runtime *runtime) 609 { 610 return runtime->stop_threshold > runtime->buffer_size; 611 } 612 613 /* check whether early start is needed for playback stream */ 614 static int lowlatency_playback_available(struct snd_pcm_runtime *runtime, 615 struct snd_usb_substream *subs) 616 { 617 struct snd_usb_audio *chip = subs->stream->chip; 618 619 if (subs->direction == SNDRV_PCM_STREAM_CAPTURE) 620 return false; 621 /* disabled via module option? */ 622 if (!chip->lowlatency) 623 return false; 624 if (in_free_wheeling_mode(runtime)) 625 return false; 626 /* implicit feedback mode has own operation mode */ 627 if (snd_usb_endpoint_implicit_feedback_sink(subs->data_endpoint)) 628 return false; 629 return true; 630 } 631 632 /* 633 * prepare callback 634 * 635 * only a few subtle things... 636 */ 637 static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream) 638 { 639 struct snd_pcm_runtime *runtime = substream->runtime; 640 struct snd_usb_substream *subs = runtime->private_data; 641 struct snd_usb_audio *chip = subs->stream->chip; 642 int retry = 0; 643 int ret; 644 645 ret = snd_usb_lock_shutdown(chip); 646 if (ret < 0) 647 return ret; 648 if (snd_BUG_ON(!subs->data_endpoint)) { 649 ret = -EIO; 650 goto unlock; 651 } 652 653 again: 654 if (subs->sync_endpoint) { 655 ret = snd_usb_endpoint_prepare(chip, subs->sync_endpoint); 656 if (ret < 0) 657 goto unlock; 658 } 659 660 ret = snd_usb_endpoint_prepare(chip, subs->data_endpoint); 661 if (ret < 0) 662 goto unlock; 663 else if (ret > 0) 664 snd_usb_set_format_quirk(subs, subs->cur_audiofmt); 665 ret = 0; 666 667 /* reset the pointer */ 668 subs->buffer_bytes = frames_to_bytes(runtime, runtime->buffer_size); 669 subs->inflight_bytes = 0; 670 subs->hwptr_done = 0; 671 subs->transfer_done = 0; 672 subs->last_frame_number = 0; 673 subs->period_elapsed_pending = 0; 674 runtime->delay = 0; 675 676 subs->lowlatency_playback = lowlatency_playback_available(runtime, subs); 677 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && 678 !subs->lowlatency_playback) { 679 ret = start_endpoints(subs); 680 /* if XRUN happens at starting streams (possibly with implicit 681 * fb case), restart again, but only try once. 682 */ 683 if (ret == -EPIPE && !retry++) { 684 sync_pending_stops(subs); 685 goto again; 686 } 687 } 688 unlock: 689 snd_usb_unlock_shutdown(chip); 690 return ret; 691 } 692 693 /* 694 * h/w constraints 695 */ 696 697 #ifdef HW_CONST_DEBUG 698 #define hwc_debug(fmt, args...) pr_debug(fmt, ##args) 699 #else 700 #define hwc_debug(fmt, args...) do { } while(0) 701 #endif 702 703 static const struct snd_pcm_hardware snd_usb_hardware = 704 { 705 .info = SNDRV_PCM_INFO_MMAP | 706 SNDRV_PCM_INFO_MMAP_VALID | 707 SNDRV_PCM_INFO_BATCH | 708 SNDRV_PCM_INFO_INTERLEAVED | 709 SNDRV_PCM_INFO_BLOCK_TRANSFER | 710 SNDRV_PCM_INFO_PAUSE, 711 .channels_min = 1, 712 .channels_max = 256, 713 .buffer_bytes_max = INT_MAX, /* limited by BUFFER_TIME later */ 714 .period_bytes_min = 64, 715 .period_bytes_max = INT_MAX, /* limited by PERIOD_TIME later */ 716 .periods_min = 2, 717 .periods_max = 1024, 718 }; 719 720 static int hw_check_valid_format(struct snd_usb_substream *subs, 721 struct snd_pcm_hw_params *params, 722 const struct audioformat *fp) 723 { 724 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 725 struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 726 struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 727 struct snd_interval *pt = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME); 728 struct snd_mask check_fmts; 729 unsigned int ptime; 730 731 /* check the format */ 732 snd_mask_none(&check_fmts); 733 check_fmts.bits[0] = (u32)fp->formats; 734 check_fmts.bits[1] = (u32)(fp->formats >> 32); 735 snd_mask_intersect(&check_fmts, fmts); 736 if (snd_mask_empty(&check_fmts)) { 737 hwc_debug(" > check: no supported format 0x%llx\n", fp->formats); 738 return 0; 739 } 740 /* check the channels */ 741 if (fp->channels < ct->min || fp->channels > ct->max) { 742 hwc_debug(" > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max); 743 return 0; 744 } 745 /* check the rate is within the range */ 746 if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) { 747 hwc_debug(" > check: rate_min %d > max %d\n", fp->rate_min, it->max); 748 return 0; 749 } 750 if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) { 751 hwc_debug(" > check: rate_max %d < min %d\n", fp->rate_max, it->min); 752 return 0; 753 } 754 /* check whether the period time is >= the data packet interval */ 755 if (subs->speed != USB_SPEED_FULL) { 756 ptime = 125 * (1 << fp->datainterval); 757 if (ptime > pt->max || (ptime == pt->max && pt->openmax)) { 758 hwc_debug(" > check: ptime %u > max %u\n", ptime, pt->max); 759 return 0; 760 } 761 } 762 return 1; 763 } 764 765 static int apply_hw_params_minmax(struct snd_interval *it, unsigned int rmin, 766 unsigned int rmax) 767 { 768 int changed; 769 770 if (rmin > rmax) { 771 hwc_debug(" --> get empty\n"); 772 it->empty = 1; 773 return -EINVAL; 774 } 775 776 changed = 0; 777 if (it->min < rmin) { 778 it->min = rmin; 779 it->openmin = 0; 780 changed = 1; 781 } 782 if (it->max > rmax) { 783 it->max = rmax; 784 it->openmax = 0; 785 changed = 1; 786 } 787 if (snd_interval_checkempty(it)) { 788 it->empty = 1; 789 return -EINVAL; 790 } 791 hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed); 792 return changed; 793 } 794 795 /* get the specified endpoint object that is being used by other streams 796 * (i.e. the parameter is locked) 797 */ 798 static const struct snd_usb_endpoint * 799 get_endpoint_in_use(struct snd_usb_audio *chip, int endpoint, 800 const struct snd_usb_endpoint *ref_ep) 801 { 802 const struct snd_usb_endpoint *ep; 803 804 ep = snd_usb_get_endpoint(chip, endpoint); 805 if (ep && ep->cur_audiofmt && (ep != ref_ep || ep->opened > 1)) 806 return ep; 807 return NULL; 808 } 809 810 static int hw_rule_rate(struct snd_pcm_hw_params *params, 811 struct snd_pcm_hw_rule *rule) 812 { 813 struct snd_usb_substream *subs = rule->private; 814 struct snd_usb_audio *chip = subs->stream->chip; 815 const struct snd_usb_endpoint *ep; 816 const struct audioformat *fp; 817 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 818 unsigned int rmin, rmax, r; 819 int i; 820 821 hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max); 822 rmin = UINT_MAX; 823 rmax = 0; 824 list_for_each_entry(fp, &subs->fmt_list, list) { 825 if (!hw_check_valid_format(subs, params, fp)) 826 continue; 827 828 ep = get_endpoint_in_use(chip, fp->endpoint, 829 subs->data_endpoint); 830 if (ep) { 831 hwc_debug("rate limit %d for ep#%x\n", 832 ep->cur_rate, fp->endpoint); 833 rmin = min(rmin, ep->cur_rate); 834 rmax = max(rmax, ep->cur_rate); 835 continue; 836 } 837 838 if (fp->implicit_fb) { 839 ep = get_endpoint_in_use(chip, fp->sync_ep, 840 subs->sync_endpoint); 841 if (ep) { 842 hwc_debug("rate limit %d for sync_ep#%x\n", 843 ep->cur_rate, fp->sync_ep); 844 rmin = min(rmin, ep->cur_rate); 845 rmax = max(rmax, ep->cur_rate); 846 continue; 847 } 848 } 849 850 r = snd_usb_endpoint_get_clock_rate(chip, fp->clock); 851 if (r > 0) { 852 if (!snd_interval_test(it, r)) 853 continue; 854 rmin = min(rmin, r); 855 rmax = max(rmax, r); 856 continue; 857 } 858 if (fp->rate_table && fp->nr_rates) { 859 for (i = 0; i < fp->nr_rates; i++) { 860 r = fp->rate_table[i]; 861 if (!snd_interval_test(it, r)) 862 continue; 863 rmin = min(rmin, r); 864 rmax = max(rmax, r); 865 } 866 } else { 867 rmin = min(rmin, fp->rate_min); 868 rmax = max(rmax, fp->rate_max); 869 } 870 } 871 872 return apply_hw_params_minmax(it, rmin, rmax); 873 } 874 875 876 static int hw_rule_channels(struct snd_pcm_hw_params *params, 877 struct snd_pcm_hw_rule *rule) 878 { 879 struct snd_usb_substream *subs = rule->private; 880 const struct audioformat *fp; 881 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 882 unsigned int rmin, rmax; 883 884 hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max); 885 rmin = UINT_MAX; 886 rmax = 0; 887 list_for_each_entry(fp, &subs->fmt_list, list) { 888 if (!hw_check_valid_format(subs, params, fp)) 889 continue; 890 rmin = min(rmin, fp->channels); 891 rmax = max(rmax, fp->channels); 892 } 893 894 return apply_hw_params_minmax(it, rmin, rmax); 895 } 896 897 static int apply_hw_params_format_bits(struct snd_mask *fmt, u64 fbits) 898 { 899 u32 oldbits[2]; 900 int changed; 901 902 oldbits[0] = fmt->bits[0]; 903 oldbits[1] = fmt->bits[1]; 904 fmt->bits[0] &= (u32)fbits; 905 fmt->bits[1] &= (u32)(fbits >> 32); 906 if (!fmt->bits[0] && !fmt->bits[1]) { 907 hwc_debug(" --> get empty\n"); 908 return -EINVAL; 909 } 910 changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]); 911 hwc_debug(" --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed); 912 return changed; 913 } 914 915 static int hw_rule_format(struct snd_pcm_hw_params *params, 916 struct snd_pcm_hw_rule *rule) 917 { 918 struct snd_usb_substream *subs = rule->private; 919 struct snd_usb_audio *chip = subs->stream->chip; 920 const struct snd_usb_endpoint *ep; 921 const struct audioformat *fp; 922 struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 923 u64 fbits; 924 925 hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]); 926 fbits = 0; 927 list_for_each_entry(fp, &subs->fmt_list, list) { 928 if (!hw_check_valid_format(subs, params, fp)) 929 continue; 930 931 ep = get_endpoint_in_use(chip, fp->endpoint, 932 subs->data_endpoint); 933 if (ep) { 934 hwc_debug("format limit %d for ep#%x\n", 935 ep->cur_format, fp->endpoint); 936 fbits |= pcm_format_to_bits(ep->cur_format); 937 continue; 938 } 939 940 if (fp->implicit_fb) { 941 ep = get_endpoint_in_use(chip, fp->sync_ep, 942 subs->sync_endpoint); 943 if (ep) { 944 hwc_debug("format limit %d for sync_ep#%x\n", 945 ep->cur_format, fp->sync_ep); 946 fbits |= pcm_format_to_bits(ep->cur_format); 947 continue; 948 } 949 } 950 951 fbits |= fp->formats; 952 } 953 return apply_hw_params_format_bits(fmt, fbits); 954 } 955 956 static int hw_rule_period_time(struct snd_pcm_hw_params *params, 957 struct snd_pcm_hw_rule *rule) 958 { 959 struct snd_usb_substream *subs = rule->private; 960 const struct audioformat *fp; 961 struct snd_interval *it; 962 unsigned char min_datainterval; 963 unsigned int pmin; 964 965 it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME); 966 hwc_debug("hw_rule_period_time: (%u,%u)\n", it->min, it->max); 967 min_datainterval = 0xff; 968 list_for_each_entry(fp, &subs->fmt_list, list) { 969 if (!hw_check_valid_format(subs, params, fp)) 970 continue; 971 min_datainterval = min(min_datainterval, fp->datainterval); 972 } 973 if (min_datainterval == 0xff) { 974 hwc_debug(" --> get empty\n"); 975 it->empty = 1; 976 return -EINVAL; 977 } 978 pmin = 125 * (1 << min_datainterval); 979 980 return apply_hw_params_minmax(it, pmin, UINT_MAX); 981 } 982 983 /* additional hw constraints for implicit feedback mode */ 984 static int hw_rule_period_size_implicit_fb(struct snd_pcm_hw_params *params, 985 struct snd_pcm_hw_rule *rule) 986 { 987 struct snd_usb_substream *subs = rule->private; 988 struct snd_usb_audio *chip = subs->stream->chip; 989 const struct audioformat *fp; 990 const struct snd_usb_endpoint *ep; 991 struct snd_interval *it; 992 unsigned int rmin, rmax; 993 994 it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE); 995 hwc_debug("hw_rule_period_size: (%u,%u)\n", it->min, it->max); 996 rmin = UINT_MAX; 997 rmax = 0; 998 list_for_each_entry(fp, &subs->fmt_list, list) { 999 if (!hw_check_valid_format(subs, params, fp)) 1000 continue; 1001 ep = get_endpoint_in_use(chip, fp->endpoint, 1002 subs->data_endpoint); 1003 if (ep) { 1004 hwc_debug("period size limit %d for ep#%x\n", 1005 ep->cur_period_frames, fp->endpoint); 1006 rmin = min(rmin, ep->cur_period_frames); 1007 rmax = max(rmax, ep->cur_period_frames); 1008 continue; 1009 } 1010 1011 if (fp->implicit_fb) { 1012 ep = get_endpoint_in_use(chip, fp->sync_ep, 1013 subs->sync_endpoint); 1014 if (ep) { 1015 hwc_debug("period size limit %d for sync_ep#%x\n", 1016 ep->cur_period_frames, fp->sync_ep); 1017 rmin = min(rmin, ep->cur_period_frames); 1018 rmax = max(rmax, ep->cur_period_frames); 1019 continue; 1020 } 1021 } 1022 } 1023 1024 if (!rmax) 1025 return 0; /* no limit by implicit fb */ 1026 return apply_hw_params_minmax(it, rmin, rmax); 1027 } 1028 1029 static int hw_rule_periods_implicit_fb(struct snd_pcm_hw_params *params, 1030 struct snd_pcm_hw_rule *rule) 1031 { 1032 struct snd_usb_substream *subs = rule->private; 1033 struct snd_usb_audio *chip = subs->stream->chip; 1034 const struct audioformat *fp; 1035 const struct snd_usb_endpoint *ep; 1036 struct snd_interval *it; 1037 unsigned int rmin, rmax; 1038 1039 it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIODS); 1040 hwc_debug("hw_rule_periods: (%u,%u)\n", it->min, it->max); 1041 rmin = UINT_MAX; 1042 rmax = 0; 1043 list_for_each_entry(fp, &subs->fmt_list, list) { 1044 if (!hw_check_valid_format(subs, params, fp)) 1045 continue; 1046 ep = get_endpoint_in_use(chip, fp->endpoint, 1047 subs->data_endpoint); 1048 if (ep) { 1049 hwc_debug("periods limit %d for ep#%x\n", 1050 ep->cur_buffer_periods, fp->endpoint); 1051 rmin = min(rmin, ep->cur_buffer_periods); 1052 rmax = max(rmax, ep->cur_buffer_periods); 1053 continue; 1054 } 1055 1056 if (fp->implicit_fb) { 1057 ep = get_endpoint_in_use(chip, fp->sync_ep, 1058 subs->sync_endpoint); 1059 if (ep) { 1060 hwc_debug("periods limit %d for sync_ep#%x\n", 1061 ep->cur_buffer_periods, fp->sync_ep); 1062 rmin = min(rmin, ep->cur_buffer_periods); 1063 rmax = max(rmax, ep->cur_buffer_periods); 1064 continue; 1065 } 1066 } 1067 } 1068 1069 if (!rmax) 1070 return 0; /* no limit by implicit fb */ 1071 return apply_hw_params_minmax(it, rmin, rmax); 1072 } 1073 1074 /* 1075 * set up the runtime hardware information. 1076 */ 1077 1078 static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs) 1079 { 1080 const struct audioformat *fp; 1081 unsigned int pt, ptmin; 1082 int param_period_time_if_needed = -1; 1083 int err; 1084 1085 runtime->hw.formats = subs->formats; 1086 1087 runtime->hw.rate_min = 0x7fffffff; 1088 runtime->hw.rate_max = 0; 1089 runtime->hw.channels_min = 256; 1090 runtime->hw.channels_max = 0; 1091 runtime->hw.rates = 0; 1092 ptmin = UINT_MAX; 1093 /* check min/max rates and channels */ 1094 list_for_each_entry(fp, &subs->fmt_list, list) { 1095 runtime->hw.rates |= fp->rates; 1096 if (runtime->hw.rate_min > fp->rate_min) 1097 runtime->hw.rate_min = fp->rate_min; 1098 if (runtime->hw.rate_max < fp->rate_max) 1099 runtime->hw.rate_max = fp->rate_max; 1100 if (runtime->hw.channels_min > fp->channels) 1101 runtime->hw.channels_min = fp->channels; 1102 if (runtime->hw.channels_max < fp->channels) 1103 runtime->hw.channels_max = fp->channels; 1104 if (fp->fmt_type == UAC_FORMAT_TYPE_II && fp->frame_size > 0) { 1105 /* FIXME: there might be more than one audio formats... */ 1106 runtime->hw.period_bytes_min = runtime->hw.period_bytes_max = 1107 fp->frame_size; 1108 } 1109 pt = 125 * (1 << fp->datainterval); 1110 ptmin = min(ptmin, pt); 1111 } 1112 1113 param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME; 1114 if (subs->speed == USB_SPEED_FULL) 1115 /* full speed devices have fixed data packet interval */ 1116 ptmin = 1000; 1117 if (ptmin == 1000) 1118 /* if period time doesn't go below 1 ms, no rules needed */ 1119 param_period_time_if_needed = -1; 1120 1121 err = snd_pcm_hw_constraint_minmax(runtime, 1122 SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1123 ptmin, UINT_MAX); 1124 if (err < 0) 1125 return err; 1126 1127 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 1128 hw_rule_rate, subs, 1129 SNDRV_PCM_HW_PARAM_RATE, 1130 SNDRV_PCM_HW_PARAM_FORMAT, 1131 SNDRV_PCM_HW_PARAM_CHANNELS, 1132 param_period_time_if_needed, 1133 -1); 1134 if (err < 0) 1135 return err; 1136 1137 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 1138 hw_rule_channels, subs, 1139 SNDRV_PCM_HW_PARAM_CHANNELS, 1140 SNDRV_PCM_HW_PARAM_FORMAT, 1141 SNDRV_PCM_HW_PARAM_RATE, 1142 param_period_time_if_needed, 1143 -1); 1144 if (err < 0) 1145 return err; 1146 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT, 1147 hw_rule_format, subs, 1148 SNDRV_PCM_HW_PARAM_FORMAT, 1149 SNDRV_PCM_HW_PARAM_RATE, 1150 SNDRV_PCM_HW_PARAM_CHANNELS, 1151 param_period_time_if_needed, 1152 -1); 1153 if (err < 0) 1154 return err; 1155 if (param_period_time_if_needed >= 0) { 1156 err = snd_pcm_hw_rule_add(runtime, 0, 1157 SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1158 hw_rule_period_time, subs, 1159 SNDRV_PCM_HW_PARAM_FORMAT, 1160 SNDRV_PCM_HW_PARAM_CHANNELS, 1161 SNDRV_PCM_HW_PARAM_RATE, 1162 -1); 1163 if (err < 0) 1164 return err; 1165 } 1166 1167 /* set max period and buffer sizes for 1 and 2 seconds, respectively */ 1168 err = snd_pcm_hw_constraint_minmax(runtime, 1169 SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1170 0, 1000000); 1171 if (err < 0) 1172 return err; 1173 err = snd_pcm_hw_constraint_minmax(runtime, 1174 SNDRV_PCM_HW_PARAM_BUFFER_TIME, 1175 0, 2000000); 1176 if (err < 0) 1177 return err; 1178 1179 /* additional hw constraints for implicit fb */ 1180 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 1181 hw_rule_period_size_implicit_fb, subs, 1182 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1); 1183 if (err < 0) 1184 return err; 1185 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS, 1186 hw_rule_periods_implicit_fb, subs, 1187 SNDRV_PCM_HW_PARAM_PERIODS, -1); 1188 if (err < 0) 1189 return err; 1190 1191 list_for_each_entry(fp, &subs->fmt_list, list) { 1192 if (fp->implicit_fb) { 1193 runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX; 1194 break; 1195 } 1196 } 1197 1198 return 0; 1199 } 1200 1201 static int snd_usb_pcm_open(struct snd_pcm_substream *substream) 1202 { 1203 int direction = substream->stream; 1204 struct snd_usb_stream *as = snd_pcm_substream_chip(substream); 1205 struct snd_pcm_runtime *runtime = substream->runtime; 1206 struct snd_usb_substream *subs = &as->substream[direction]; 1207 int ret; 1208 1209 runtime->hw = snd_usb_hardware; 1210 /* need an explicit sync to catch applptr update in low-latency mode */ 1211 if (direction == SNDRV_PCM_STREAM_PLAYBACK && 1212 as->chip->lowlatency) 1213 runtime->hw.info |= SNDRV_PCM_INFO_SYNC_APPLPTR; 1214 runtime->private_data = subs; 1215 subs->pcm_substream = substream; 1216 /* runtime PM is also done there */ 1217 1218 /* initialize DSD/DOP context */ 1219 subs->dsd_dop.byte_idx = 0; 1220 subs->dsd_dop.channel = 0; 1221 subs->dsd_dop.marker = 1; 1222 1223 ret = setup_hw_info(runtime, subs); 1224 if (ret < 0) 1225 return ret; 1226 ret = snd_usb_autoresume(subs->stream->chip); 1227 if (ret < 0) 1228 return ret; 1229 ret = snd_media_stream_init(subs, as->pcm, direction); 1230 if (ret < 0) 1231 snd_usb_autosuspend(subs->stream->chip); 1232 return ret; 1233 } 1234 1235 static int snd_usb_pcm_close(struct snd_pcm_substream *substream) 1236 { 1237 int direction = substream->stream; 1238 struct snd_usb_stream *as = snd_pcm_substream_chip(substream); 1239 struct snd_usb_substream *subs = &as->substream[direction]; 1240 int ret; 1241 1242 snd_media_stop_pipeline(subs); 1243 1244 if (!snd_usb_lock_shutdown(subs->stream->chip)) { 1245 ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D1); 1246 snd_usb_unlock_shutdown(subs->stream->chip); 1247 if (ret < 0) 1248 return ret; 1249 } 1250 1251 subs->pcm_substream = NULL; 1252 snd_usb_autosuspend(subs->stream->chip); 1253 1254 return 0; 1255 } 1256 1257 /* Since a URB can handle only a single linear buffer, we must use double 1258 * buffering when the data to be transferred overflows the buffer boundary. 1259 * To avoid inconsistencies when updating hwptr_done, we use double buffering 1260 * for all URBs. 1261 */ 1262 static void retire_capture_urb(struct snd_usb_substream *subs, 1263 struct urb *urb) 1264 { 1265 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 1266 unsigned int stride, frames, bytes, oldptr; 1267 int i, period_elapsed = 0; 1268 unsigned long flags; 1269 unsigned char *cp; 1270 int current_frame_number; 1271 1272 /* read frame number here, update pointer in critical section */ 1273 current_frame_number = usb_get_current_frame_number(subs->dev); 1274 1275 stride = runtime->frame_bits >> 3; 1276 1277 for (i = 0; i < urb->number_of_packets; i++) { 1278 cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset + subs->pkt_offset_adj; 1279 if (urb->iso_frame_desc[i].status && printk_ratelimit()) { 1280 dev_dbg(&subs->dev->dev, "frame %d active: %d\n", 1281 i, urb->iso_frame_desc[i].status); 1282 // continue; 1283 } 1284 bytes = urb->iso_frame_desc[i].actual_length; 1285 if (subs->stream_offset_adj > 0) { 1286 unsigned int adj = min(subs->stream_offset_adj, bytes); 1287 cp += adj; 1288 bytes -= adj; 1289 subs->stream_offset_adj -= adj; 1290 } 1291 frames = bytes / stride; 1292 if (!subs->txfr_quirk) 1293 bytes = frames * stride; 1294 if (bytes % (runtime->sample_bits >> 3) != 0) { 1295 int oldbytes = bytes; 1296 bytes = frames * stride; 1297 dev_warn_ratelimited(&subs->dev->dev, 1298 "Corrected urb data len. %d->%d\n", 1299 oldbytes, bytes); 1300 } 1301 /* update the current pointer */ 1302 spin_lock_irqsave(&subs->lock, flags); 1303 oldptr = subs->hwptr_done; 1304 subs->hwptr_done += bytes; 1305 if (subs->hwptr_done >= subs->buffer_bytes) 1306 subs->hwptr_done -= subs->buffer_bytes; 1307 frames = (bytes + (oldptr % stride)) / stride; 1308 subs->transfer_done += frames; 1309 if (subs->transfer_done >= runtime->period_size) { 1310 subs->transfer_done -= runtime->period_size; 1311 period_elapsed = 1; 1312 } 1313 1314 /* realign last_frame_number */ 1315 subs->last_frame_number = current_frame_number; 1316 1317 spin_unlock_irqrestore(&subs->lock, flags); 1318 /* copy a data chunk */ 1319 if (oldptr + bytes > subs->buffer_bytes) { 1320 unsigned int bytes1 = subs->buffer_bytes - oldptr; 1321 1322 memcpy(runtime->dma_area + oldptr, cp, bytes1); 1323 memcpy(runtime->dma_area, cp + bytes1, bytes - bytes1); 1324 } else { 1325 memcpy(runtime->dma_area + oldptr, cp, bytes); 1326 } 1327 } 1328 1329 if (period_elapsed) 1330 snd_pcm_period_elapsed(subs->pcm_substream); 1331 } 1332 1333 static void urb_ctx_queue_advance(struct snd_usb_substream *subs, 1334 struct urb *urb, unsigned int bytes) 1335 { 1336 struct snd_urb_ctx *ctx = urb->context; 1337 1338 ctx->queued += bytes; 1339 subs->inflight_bytes += bytes; 1340 subs->hwptr_done += bytes; 1341 if (subs->hwptr_done >= subs->buffer_bytes) 1342 subs->hwptr_done -= subs->buffer_bytes; 1343 } 1344 1345 static inline void fill_playback_urb_dsd_dop(struct snd_usb_substream *subs, 1346 struct urb *urb, unsigned int bytes) 1347 { 1348 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 1349 unsigned int dst_idx = 0; 1350 unsigned int src_idx = subs->hwptr_done; 1351 unsigned int wrap = subs->buffer_bytes; 1352 u8 *dst = urb->transfer_buffer; 1353 u8 *src = runtime->dma_area; 1354 static const u8 marker[] = { 0x05, 0xfa }; 1355 unsigned int queued = 0; 1356 1357 /* 1358 * The DSP DOP format defines a way to transport DSD samples over 1359 * normal PCM data endpoints. It requires stuffing of marker bytes 1360 * (0x05 and 0xfa, alternating per sample frame), and then expects 1361 * 2 additional bytes of actual payload. The whole frame is stored 1362 * LSB. 1363 * 1364 * Hence, for a stereo transport, the buffer layout looks like this, 1365 * where L refers to left channel samples and R to right. 1366 * 1367 * L1 L2 0x05 R1 R2 0x05 L3 L4 0xfa R3 R4 0xfa 1368 * L5 L6 0x05 R5 R6 0x05 L7 L8 0xfa R7 R8 0xfa 1369 * ..... 1370 * 1371 */ 1372 1373 while (bytes--) { 1374 if (++subs->dsd_dop.byte_idx == 3) { 1375 /* frame boundary? */ 1376 dst[dst_idx++] = marker[subs->dsd_dop.marker]; 1377 src_idx += 2; 1378 subs->dsd_dop.byte_idx = 0; 1379 1380 if (++subs->dsd_dop.channel % runtime->channels == 0) { 1381 /* alternate the marker */ 1382 subs->dsd_dop.marker++; 1383 subs->dsd_dop.marker %= ARRAY_SIZE(marker); 1384 subs->dsd_dop.channel = 0; 1385 } 1386 } else { 1387 /* stuff the DSD payload */ 1388 int idx = (src_idx + subs->dsd_dop.byte_idx - 1) % wrap; 1389 1390 if (subs->cur_audiofmt->dsd_bitrev) 1391 dst[dst_idx++] = bitrev8(src[idx]); 1392 else 1393 dst[dst_idx++] = src[idx]; 1394 queued++; 1395 } 1396 } 1397 1398 urb_ctx_queue_advance(subs, urb, queued); 1399 } 1400 1401 /* copy bit-reversed bytes onto transfer buffer */ 1402 static void fill_playback_urb_dsd_bitrev(struct snd_usb_substream *subs, 1403 struct urb *urb, unsigned int bytes) 1404 { 1405 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 1406 const u8 *src = runtime->dma_area; 1407 u8 *buf = urb->transfer_buffer; 1408 int i, ofs = subs->hwptr_done; 1409 1410 for (i = 0; i < bytes; i++) { 1411 *buf++ = bitrev8(src[ofs]); 1412 if (++ofs >= subs->buffer_bytes) 1413 ofs = 0; 1414 } 1415 1416 urb_ctx_queue_advance(subs, urb, bytes); 1417 } 1418 1419 static void copy_to_urb(struct snd_usb_substream *subs, struct urb *urb, 1420 int offset, int stride, unsigned int bytes) 1421 { 1422 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 1423 1424 if (subs->hwptr_done + bytes > subs->buffer_bytes) { 1425 /* err, the transferred area goes over buffer boundary. */ 1426 unsigned int bytes1 = subs->buffer_bytes - subs->hwptr_done; 1427 1428 memcpy(urb->transfer_buffer + offset, 1429 runtime->dma_area + subs->hwptr_done, bytes1); 1430 memcpy(urb->transfer_buffer + offset + bytes1, 1431 runtime->dma_area, bytes - bytes1); 1432 } else { 1433 memcpy(urb->transfer_buffer + offset, 1434 runtime->dma_area + subs->hwptr_done, bytes); 1435 } 1436 1437 urb_ctx_queue_advance(subs, urb, bytes); 1438 } 1439 1440 static unsigned int copy_to_urb_quirk(struct snd_usb_substream *subs, 1441 struct urb *urb, int stride, 1442 unsigned int bytes) 1443 { 1444 __le32 packet_length; 1445 int i; 1446 1447 /* Put __le32 length descriptor at start of each packet. */ 1448 for (i = 0; i < urb->number_of_packets; i++) { 1449 unsigned int length = urb->iso_frame_desc[i].length; 1450 unsigned int offset = urb->iso_frame_desc[i].offset; 1451 1452 packet_length = cpu_to_le32(length); 1453 offset += i * sizeof(packet_length); 1454 urb->iso_frame_desc[i].offset = offset; 1455 urb->iso_frame_desc[i].length += sizeof(packet_length); 1456 memcpy(urb->transfer_buffer + offset, 1457 &packet_length, sizeof(packet_length)); 1458 copy_to_urb(subs, urb, offset + sizeof(packet_length), 1459 stride, length); 1460 } 1461 /* Adjust transfer size accordingly. */ 1462 bytes += urb->number_of_packets * sizeof(packet_length); 1463 return bytes; 1464 } 1465 1466 static int prepare_playback_urb(struct snd_usb_substream *subs, 1467 struct urb *urb, 1468 bool in_stream_lock) 1469 { 1470 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 1471 struct snd_usb_endpoint *ep = subs->data_endpoint; 1472 struct snd_urb_ctx *ctx = urb->context; 1473 unsigned int frames, bytes; 1474 int counts; 1475 unsigned int transfer_done, frame_limit, avail = 0; 1476 int i, stride, period_elapsed = 0; 1477 unsigned long flags; 1478 int err = 0; 1479 1480 stride = ep->stride; 1481 1482 frames = 0; 1483 ctx->queued = 0; 1484 urb->number_of_packets = 0; 1485 1486 spin_lock_irqsave(&subs->lock, flags); 1487 frame_limit = subs->frame_limit + ep->max_urb_frames; 1488 transfer_done = subs->transfer_done; 1489 1490 if (subs->lowlatency_playback && 1491 runtime->state != SNDRV_PCM_STATE_DRAINING) { 1492 unsigned int hwptr = subs->hwptr_done / stride; 1493 1494 /* calculate the byte offset-in-buffer of the appl_ptr */ 1495 avail = (runtime->control->appl_ptr - runtime->hw_ptr_base) 1496 % runtime->buffer_size; 1497 if (avail <= hwptr) 1498 avail += runtime->buffer_size; 1499 avail -= hwptr; 1500 } 1501 1502 for (i = 0; i < ctx->packets; i++) { 1503 counts = snd_usb_endpoint_next_packet_size(ep, ctx, i, avail); 1504 if (counts < 0) 1505 break; 1506 /* set up descriptor */ 1507 urb->iso_frame_desc[i].offset = frames * stride; 1508 urb->iso_frame_desc[i].length = counts * stride; 1509 frames += counts; 1510 avail -= counts; 1511 urb->number_of_packets++; 1512 transfer_done += counts; 1513 if (transfer_done >= runtime->period_size) { 1514 transfer_done -= runtime->period_size; 1515 frame_limit = 0; 1516 period_elapsed = 1; 1517 if (subs->fmt_type == UAC_FORMAT_TYPE_II) { 1518 if (transfer_done > 0) { 1519 /* FIXME: fill-max mode is not 1520 * supported yet */ 1521 frames -= transfer_done; 1522 counts -= transfer_done; 1523 urb->iso_frame_desc[i].length = 1524 counts * stride; 1525 transfer_done = 0; 1526 } 1527 i++; 1528 if (i < ctx->packets) { 1529 /* add a transfer delimiter */ 1530 urb->iso_frame_desc[i].offset = 1531 frames * stride; 1532 urb->iso_frame_desc[i].length = 0; 1533 urb->number_of_packets++; 1534 } 1535 break; 1536 } 1537 } 1538 /* finish at the period boundary or after enough frames */ 1539 if ((period_elapsed || transfer_done >= frame_limit) && 1540 !snd_usb_endpoint_implicit_feedback_sink(ep)) 1541 break; 1542 } 1543 1544 if (!frames) { 1545 err = -EAGAIN; 1546 goto unlock; 1547 } 1548 1549 bytes = frames * stride; 1550 subs->transfer_done = transfer_done; 1551 subs->frame_limit = frame_limit; 1552 if (unlikely(ep->cur_format == SNDRV_PCM_FORMAT_DSD_U16_LE && 1553 subs->cur_audiofmt->dsd_dop)) { 1554 fill_playback_urb_dsd_dop(subs, urb, bytes); 1555 } else if (unlikely(ep->cur_format == SNDRV_PCM_FORMAT_DSD_U8 && 1556 subs->cur_audiofmt->dsd_bitrev)) { 1557 fill_playback_urb_dsd_bitrev(subs, urb, bytes); 1558 } else { 1559 /* usual PCM */ 1560 if (!subs->tx_length_quirk) 1561 copy_to_urb(subs, urb, 0, stride, bytes); 1562 else 1563 bytes = copy_to_urb_quirk(subs, urb, stride, bytes); 1564 /* bytes is now amount of outgoing data */ 1565 } 1566 1567 subs->last_frame_number = usb_get_current_frame_number(subs->dev); 1568 1569 if (subs->trigger_tstamp_pending_update) { 1570 /* this is the first actual URB submitted, 1571 * update trigger timestamp to reflect actual start time 1572 */ 1573 snd_pcm_gettime(runtime, &runtime->trigger_tstamp); 1574 subs->trigger_tstamp_pending_update = false; 1575 } 1576 1577 if (period_elapsed && !subs->running && subs->lowlatency_playback) { 1578 subs->period_elapsed_pending = 1; 1579 period_elapsed = 0; 1580 } 1581 1582 unlock: 1583 spin_unlock_irqrestore(&subs->lock, flags); 1584 if (err < 0) 1585 return err; 1586 urb->transfer_buffer_length = bytes; 1587 if (period_elapsed) { 1588 if (in_stream_lock) 1589 snd_pcm_period_elapsed_under_stream_lock(subs->pcm_substream); 1590 else 1591 snd_pcm_period_elapsed(subs->pcm_substream); 1592 } 1593 return 0; 1594 } 1595 1596 /* 1597 * process after playback data complete 1598 * - decrease the delay count again 1599 */ 1600 static void retire_playback_urb(struct snd_usb_substream *subs, 1601 struct urb *urb) 1602 { 1603 unsigned long flags; 1604 struct snd_urb_ctx *ctx = urb->context; 1605 bool period_elapsed = false; 1606 1607 spin_lock_irqsave(&subs->lock, flags); 1608 if (ctx->queued) { 1609 if (subs->inflight_bytes >= ctx->queued) 1610 subs->inflight_bytes -= ctx->queued; 1611 else 1612 subs->inflight_bytes = 0; 1613 } 1614 1615 subs->last_frame_number = usb_get_current_frame_number(subs->dev); 1616 if (subs->running) { 1617 period_elapsed = subs->period_elapsed_pending; 1618 subs->period_elapsed_pending = 0; 1619 } 1620 spin_unlock_irqrestore(&subs->lock, flags); 1621 if (period_elapsed) 1622 snd_pcm_period_elapsed(subs->pcm_substream); 1623 } 1624 1625 /* PCM ack callback for the playback stream; 1626 * this plays a role only when the stream is running in low-latency mode. 1627 */ 1628 static int snd_usb_pcm_playback_ack(struct snd_pcm_substream *substream) 1629 { 1630 struct snd_usb_substream *subs = substream->runtime->private_data; 1631 struct snd_usb_endpoint *ep; 1632 1633 if (!subs->lowlatency_playback || !subs->running) 1634 return 0; 1635 ep = subs->data_endpoint; 1636 if (!ep) 1637 return 0; 1638 /* When no more in-flight URBs available, try to process the pending 1639 * outputs here 1640 */ 1641 if (!ep->active_mask) 1642 return snd_usb_queue_pending_output_urbs(ep, true); 1643 return 0; 1644 } 1645 1646 static int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream, 1647 int cmd) 1648 { 1649 struct snd_usb_substream *subs = substream->runtime->private_data; 1650 int err; 1651 1652 switch (cmd) { 1653 case SNDRV_PCM_TRIGGER_START: 1654 subs->trigger_tstamp_pending_update = true; 1655 fallthrough; 1656 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 1657 snd_usb_endpoint_set_callback(subs->data_endpoint, 1658 prepare_playback_urb, 1659 retire_playback_urb, 1660 subs); 1661 if (subs->lowlatency_playback && 1662 cmd == SNDRV_PCM_TRIGGER_START) { 1663 if (in_free_wheeling_mode(substream->runtime)) 1664 subs->lowlatency_playback = false; 1665 err = start_endpoints(subs); 1666 if (err < 0) { 1667 snd_usb_endpoint_set_callback(subs->data_endpoint, 1668 NULL, NULL, NULL); 1669 return err; 1670 } 1671 } 1672 subs->running = 1; 1673 dev_dbg(&subs->dev->dev, "%d:%d Start Playback PCM\n", 1674 subs->cur_audiofmt->iface, 1675 subs->cur_audiofmt->altsetting); 1676 return 0; 1677 case SNDRV_PCM_TRIGGER_SUSPEND: 1678 case SNDRV_PCM_TRIGGER_STOP: 1679 stop_endpoints(subs, substream->runtime->state == SNDRV_PCM_STATE_DRAINING); 1680 snd_usb_endpoint_set_callback(subs->data_endpoint, 1681 NULL, NULL, NULL); 1682 subs->running = 0; 1683 dev_dbg(&subs->dev->dev, "%d:%d Stop Playback PCM\n", 1684 subs->cur_audiofmt->iface, 1685 subs->cur_audiofmt->altsetting); 1686 return 0; 1687 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 1688 /* keep retire_data_urb for delay calculation */ 1689 snd_usb_endpoint_set_callback(subs->data_endpoint, 1690 NULL, 1691 retire_playback_urb, 1692 subs); 1693 subs->running = 0; 1694 dev_dbg(&subs->dev->dev, "%d:%d Pause Playback PCM\n", 1695 subs->cur_audiofmt->iface, 1696 subs->cur_audiofmt->altsetting); 1697 return 0; 1698 } 1699 1700 return -EINVAL; 1701 } 1702 1703 static int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, 1704 int cmd) 1705 { 1706 int err; 1707 struct snd_usb_substream *subs = substream->runtime->private_data; 1708 1709 switch (cmd) { 1710 case SNDRV_PCM_TRIGGER_START: 1711 err = start_endpoints(subs); 1712 if (err < 0) 1713 return err; 1714 fallthrough; 1715 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 1716 snd_usb_endpoint_set_callback(subs->data_endpoint, 1717 NULL, retire_capture_urb, 1718 subs); 1719 subs->last_frame_number = usb_get_current_frame_number(subs->dev); 1720 subs->running = 1; 1721 dev_dbg(&subs->dev->dev, "%d:%d Start Capture PCM\n", 1722 subs->cur_audiofmt->iface, 1723 subs->cur_audiofmt->altsetting); 1724 return 0; 1725 case SNDRV_PCM_TRIGGER_SUSPEND: 1726 case SNDRV_PCM_TRIGGER_STOP: 1727 stop_endpoints(subs, false); 1728 fallthrough; 1729 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 1730 snd_usb_endpoint_set_callback(subs->data_endpoint, 1731 NULL, NULL, NULL); 1732 subs->running = 0; 1733 dev_dbg(&subs->dev->dev, "%d:%d Stop Capture PCM\n", 1734 subs->cur_audiofmt->iface, 1735 subs->cur_audiofmt->altsetting); 1736 return 0; 1737 } 1738 1739 return -EINVAL; 1740 } 1741 1742 static const struct snd_pcm_ops snd_usb_playback_ops = { 1743 .open = snd_usb_pcm_open, 1744 .close = snd_usb_pcm_close, 1745 .hw_params = snd_usb_hw_params, 1746 .hw_free = snd_usb_hw_free, 1747 .prepare = snd_usb_pcm_prepare, 1748 .trigger = snd_usb_substream_playback_trigger, 1749 .sync_stop = snd_usb_pcm_sync_stop, 1750 .pointer = snd_usb_pcm_pointer, 1751 .ack = snd_usb_pcm_playback_ack, 1752 }; 1753 1754 static const struct snd_pcm_ops snd_usb_capture_ops = { 1755 .open = snd_usb_pcm_open, 1756 .close = snd_usb_pcm_close, 1757 .hw_params = snd_usb_hw_params, 1758 .hw_free = snd_usb_hw_free, 1759 .prepare = snd_usb_pcm_prepare, 1760 .trigger = snd_usb_substream_capture_trigger, 1761 .sync_stop = snd_usb_pcm_sync_stop, 1762 .pointer = snd_usb_pcm_pointer, 1763 }; 1764 1765 void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream) 1766 { 1767 const struct snd_pcm_ops *ops; 1768 1769 ops = stream == SNDRV_PCM_STREAM_PLAYBACK ? 1770 &snd_usb_playback_ops : &snd_usb_capture_ops; 1771 snd_pcm_set_ops(pcm, stream, ops); 1772 } 1773 1774 void snd_usb_preallocate_buffer(struct snd_usb_substream *subs) 1775 { 1776 struct snd_pcm *pcm = subs->stream->pcm; 1777 struct snd_pcm_substream *s = pcm->streams[subs->direction].substream; 1778 struct device *dev = subs->dev->bus->sysdev; 1779 1780 if (snd_usb_use_vmalloc) 1781 snd_pcm_set_managed_buffer(s, SNDRV_DMA_TYPE_VMALLOC, 1782 NULL, 0, 0); 1783 else 1784 snd_pcm_set_managed_buffer(s, SNDRV_DMA_TYPE_DEV_SG, 1785 dev, 64*1024, 512*1024); 1786 } 1787