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 */ 32static 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 */ 72static 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 */ 90static const struct audioformat * 91find_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 151static const struct audioformat * 152find_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 160bool 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 188static 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 202static 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 */ 219int 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 250static 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 265static 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 296static 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 */ 303static 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 */ 312int 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 401static 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 419int 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 434int 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 449static 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 */ 474static 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 */ 588static 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) */ 608static 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 */ 614static 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 */ 637static 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 ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D0); 654 if (ret < 0) 655 goto unlock; 656 657 again: 658 if (subs->sync_endpoint) { 659 ret = snd_usb_endpoint_prepare(chip, subs->sync_endpoint); 660 if (ret < 0) 661 goto unlock; 662 } 663 664 ret = snd_usb_endpoint_prepare(chip, subs->data_endpoint); 665 if (ret < 0) 666 goto unlock; 667 else if (ret > 0) 668 snd_usb_set_format_quirk(subs, subs->cur_audiofmt); 669 ret = 0; 670 671 /* reset the pointer */ 672 subs->buffer_bytes = frames_to_bytes(runtime, runtime->buffer_size); 673 subs->inflight_bytes = 0; 674 subs->hwptr_done = 0; 675 subs->transfer_done = 0; 676 subs->last_frame_number = 0; 677 subs->period_elapsed_pending = 0; 678 runtime->delay = 0; 679 680 subs->lowlatency_playback = lowlatency_playback_available(runtime, subs); 681 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && 682 !subs->lowlatency_playback) { 683 ret = start_endpoints(subs); 684 /* if XRUN happens at starting streams (possibly with implicit 685 * fb case), restart again, but only try once. 686 */ 687 if (ret == -EPIPE && !retry++) { 688 sync_pending_stops(subs); 689 goto again; 690 } 691 } 692 unlock: 693 snd_usb_unlock_shutdown(chip); 694 return ret; 695} 696 697/* 698 * h/w constraints 699 */ 700 701#ifdef HW_CONST_DEBUG 702#define hwc_debug(fmt, args...) pr_debug(fmt, ##args) 703#else 704#define hwc_debug(fmt, args...) do { } while(0) 705#endif 706 707static const struct snd_pcm_hardware snd_usb_hardware = 708{ 709 .info = SNDRV_PCM_INFO_MMAP | 710 SNDRV_PCM_INFO_MMAP_VALID | 711 SNDRV_PCM_INFO_BATCH | 712 SNDRV_PCM_INFO_INTERLEAVED | 713 SNDRV_PCM_INFO_BLOCK_TRANSFER | 714 SNDRV_PCM_INFO_PAUSE, 715 .channels_min = 1, 716 .channels_max = 256, 717 .buffer_bytes_max = INT_MAX, /* limited by BUFFER_TIME later */ 718 .period_bytes_min = 64, 719 .period_bytes_max = INT_MAX, /* limited by PERIOD_TIME later */ 720 .periods_min = 2, 721 .periods_max = 1024, 722}; 723 724static int hw_check_valid_format(struct snd_usb_substream *subs, 725 struct snd_pcm_hw_params *params, 726 const struct audioformat *fp) 727{ 728 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 729 struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 730 struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 731 struct snd_interval *pt = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME); 732 struct snd_mask check_fmts; 733 unsigned int ptime; 734 735 /* check the format */ 736 snd_mask_none(&check_fmts); 737 check_fmts.bits[0] = (u32)fp->formats; 738 check_fmts.bits[1] = (u32)(fp->formats >> 32); 739 snd_mask_intersect(&check_fmts, fmts); 740 if (snd_mask_empty(&check_fmts)) { 741 hwc_debug(" > check: no supported format 0x%llx\n", fp->formats); 742 return 0; 743 } 744 /* check the channels */ 745 if (fp->channels < ct->min || fp->channels > ct->max) { 746 hwc_debug(" > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max); 747 return 0; 748 } 749 /* check the rate is within the range */ 750 if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) { 751 hwc_debug(" > check: rate_min %d > max %d\n", fp->rate_min, it->max); 752 return 0; 753 } 754 if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) { 755 hwc_debug(" > check: rate_max %d < min %d\n", fp->rate_max, it->min); 756 return 0; 757 } 758 /* check whether the period time is >= the data packet interval */ 759 if (subs->speed != USB_SPEED_FULL) { 760 ptime = 125 * (1 << fp->datainterval); 761 if (ptime > pt->max || (ptime == pt->max && pt->openmax)) { 762 hwc_debug(" > check: ptime %u > max %u\n", ptime, pt->max); 763 return 0; 764 } 765 } 766 return 1; 767} 768 769static int apply_hw_params_minmax(struct snd_interval *it, unsigned int rmin, 770 unsigned int rmax) 771{ 772 int changed; 773 774 if (rmin > rmax) { 775 hwc_debug(" --> get empty\n"); 776 it->empty = 1; 777 return -EINVAL; 778 } 779 780 changed = 0; 781 if (it->min < rmin) { 782 it->min = rmin; 783 it->openmin = 0; 784 changed = 1; 785 } 786 if (it->max > rmax) { 787 it->max = rmax; 788 it->openmax = 0; 789 changed = 1; 790 } 791 if (snd_interval_checkempty(it)) { 792 it->empty = 1; 793 return -EINVAL; 794 } 795 hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed); 796 return changed; 797} 798 799/* get the specified endpoint object that is being used by other streams 800 * (i.e. the parameter is locked) 801 */ 802static const struct snd_usb_endpoint * 803get_endpoint_in_use(struct snd_usb_audio *chip, int endpoint, 804 const struct snd_usb_endpoint *ref_ep) 805{ 806 const struct snd_usb_endpoint *ep; 807 808 ep = snd_usb_get_endpoint(chip, endpoint); 809 if (ep && ep->cur_audiofmt && (ep != ref_ep || ep->opened > 1)) 810 return ep; 811 return NULL; 812} 813 814static int hw_rule_rate(struct snd_pcm_hw_params *params, 815 struct snd_pcm_hw_rule *rule) 816{ 817 struct snd_usb_substream *subs = rule->private; 818 struct snd_usb_audio *chip = subs->stream->chip; 819 const struct snd_usb_endpoint *ep; 820 const struct audioformat *fp; 821 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 822 unsigned int rmin, rmax, r; 823 int i; 824 825 hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max); 826 rmin = UINT_MAX; 827 rmax = 0; 828 list_for_each_entry(fp, &subs->fmt_list, list) { 829 if (!hw_check_valid_format(subs, params, fp)) 830 continue; 831 832 ep = get_endpoint_in_use(chip, fp->endpoint, 833 subs->data_endpoint); 834 if (ep) { 835 hwc_debug("rate limit %d for ep#%x\n", 836 ep->cur_rate, fp->endpoint); 837 rmin = min(rmin, ep->cur_rate); 838 rmax = max(rmax, ep->cur_rate); 839 continue; 840 } 841 842 if (fp->implicit_fb) { 843 ep = get_endpoint_in_use(chip, fp->sync_ep, 844 subs->sync_endpoint); 845 if (ep) { 846 hwc_debug("rate limit %d for sync_ep#%x\n", 847 ep->cur_rate, fp->sync_ep); 848 rmin = min(rmin, ep->cur_rate); 849 rmax = max(rmax, ep->cur_rate); 850 continue; 851 } 852 } 853 854 r = snd_usb_endpoint_get_clock_rate(chip, fp->clock); 855 if (r > 0) { 856 if (!snd_interval_test(it, r)) 857 continue; 858 rmin = min(rmin, r); 859 rmax = max(rmax, r); 860 continue; 861 } 862 if (fp->rate_table && fp->nr_rates) { 863 for (i = 0; i < fp->nr_rates; i++) { 864 r = fp->rate_table[i]; 865 if (!snd_interval_test(it, r)) 866 continue; 867 rmin = min(rmin, r); 868 rmax = max(rmax, r); 869 } 870 } else { 871 rmin = min(rmin, fp->rate_min); 872 rmax = max(rmax, fp->rate_max); 873 } 874 } 875 876 return apply_hw_params_minmax(it, rmin, rmax); 877} 878 879 880static int hw_rule_channels(struct snd_pcm_hw_params *params, 881 struct snd_pcm_hw_rule *rule) 882{ 883 struct snd_usb_substream *subs = rule->private; 884 const struct audioformat *fp; 885 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 886 unsigned int rmin, rmax; 887 888 hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max); 889 rmin = UINT_MAX; 890 rmax = 0; 891 list_for_each_entry(fp, &subs->fmt_list, list) { 892 if (!hw_check_valid_format(subs, params, fp)) 893 continue; 894 rmin = min(rmin, fp->channels); 895 rmax = max(rmax, fp->channels); 896 } 897 898 return apply_hw_params_minmax(it, rmin, rmax); 899} 900 901static int apply_hw_params_format_bits(struct snd_mask *fmt, u64 fbits) 902{ 903 u32 oldbits[2]; 904 int changed; 905 906 oldbits[0] = fmt->bits[0]; 907 oldbits[1] = fmt->bits[1]; 908 fmt->bits[0] &= (u32)fbits; 909 fmt->bits[1] &= (u32)(fbits >> 32); 910 if (!fmt->bits[0] && !fmt->bits[1]) { 911 hwc_debug(" --> get empty\n"); 912 return -EINVAL; 913 } 914 changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]); 915 hwc_debug(" --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed); 916 return changed; 917} 918 919static int hw_rule_format(struct snd_pcm_hw_params *params, 920 struct snd_pcm_hw_rule *rule) 921{ 922 struct snd_usb_substream *subs = rule->private; 923 struct snd_usb_audio *chip = subs->stream->chip; 924 const struct snd_usb_endpoint *ep; 925 const struct audioformat *fp; 926 struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 927 u64 fbits; 928 929 hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]); 930 fbits = 0; 931 list_for_each_entry(fp, &subs->fmt_list, list) { 932 if (!hw_check_valid_format(subs, params, fp)) 933 continue; 934 935 ep = get_endpoint_in_use(chip, fp->endpoint, 936 subs->data_endpoint); 937 if (ep) { 938 hwc_debug("format limit %d for ep#%x\n", 939 ep->cur_format, fp->endpoint); 940 fbits |= pcm_format_to_bits(ep->cur_format); 941 continue; 942 } 943 944 if (fp->implicit_fb) { 945 ep = get_endpoint_in_use(chip, fp->sync_ep, 946 subs->sync_endpoint); 947 if (ep) { 948 hwc_debug("format limit %d for sync_ep#%x\n", 949 ep->cur_format, fp->sync_ep); 950 fbits |= pcm_format_to_bits(ep->cur_format); 951 continue; 952 } 953 } 954 955 fbits |= fp->formats; 956 } 957 return apply_hw_params_format_bits(fmt, fbits); 958} 959 960static int hw_rule_period_time(struct snd_pcm_hw_params *params, 961 struct snd_pcm_hw_rule *rule) 962{ 963 struct snd_usb_substream *subs = rule->private; 964 const struct audioformat *fp; 965 struct snd_interval *it; 966 unsigned char min_datainterval; 967 unsigned int pmin; 968 969 it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME); 970 hwc_debug("hw_rule_period_time: (%u,%u)\n", it->min, it->max); 971 min_datainterval = 0xff; 972 list_for_each_entry(fp, &subs->fmt_list, list) { 973 if (!hw_check_valid_format(subs, params, fp)) 974 continue; 975 min_datainterval = min(min_datainterval, fp->datainterval); 976 } 977 if (min_datainterval == 0xff) { 978 hwc_debug(" --> get empty\n"); 979 it->empty = 1; 980 return -EINVAL; 981 } 982 pmin = 125 * (1 << min_datainterval); 983 984 return apply_hw_params_minmax(it, pmin, UINT_MAX); 985} 986 987/* additional hw constraints for implicit feedback mode */ 988static int hw_rule_period_size_implicit_fb(struct snd_pcm_hw_params *params, 989 struct snd_pcm_hw_rule *rule) 990{ 991 struct snd_usb_substream *subs = rule->private; 992 struct snd_usb_audio *chip = subs->stream->chip; 993 const struct audioformat *fp; 994 const struct snd_usb_endpoint *ep; 995 struct snd_interval *it; 996 unsigned int rmin, rmax; 997 998 it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE); 999 hwc_debug("hw_rule_period_size: (%u,%u)\n", it->min, it->max); 1000 rmin = UINT_MAX; 1001 rmax = 0; 1002 list_for_each_entry(fp, &subs->fmt_list, list) { 1003 if (!hw_check_valid_format(subs, params, fp)) 1004 continue; 1005 ep = get_endpoint_in_use(chip, fp->endpoint, 1006 subs->data_endpoint); 1007 if (ep) { 1008 hwc_debug("period size limit %d for ep#%x\n", 1009 ep->cur_period_frames, fp->endpoint); 1010 rmin = min(rmin, ep->cur_period_frames); 1011 rmax = max(rmax, ep->cur_period_frames); 1012 continue; 1013 } 1014 1015 if (fp->implicit_fb) { 1016 ep = get_endpoint_in_use(chip, fp->sync_ep, 1017 subs->sync_endpoint); 1018 if (ep) { 1019 hwc_debug("period size limit %d for sync_ep#%x\n", 1020 ep->cur_period_frames, fp->sync_ep); 1021 rmin = min(rmin, ep->cur_period_frames); 1022 rmax = max(rmax, ep->cur_period_frames); 1023 continue; 1024 } 1025 } 1026 } 1027 1028 if (!rmax) 1029 return 0; /* no limit by implicit fb */ 1030 return apply_hw_params_minmax(it, rmin, rmax); 1031} 1032 1033static int hw_rule_periods_implicit_fb(struct snd_pcm_hw_params *params, 1034 struct snd_pcm_hw_rule *rule) 1035{ 1036 struct snd_usb_substream *subs = rule->private; 1037 struct snd_usb_audio *chip = subs->stream->chip; 1038 const struct audioformat *fp; 1039 const struct snd_usb_endpoint *ep; 1040 struct snd_interval *it; 1041 unsigned int rmin, rmax; 1042 1043 it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIODS); 1044 hwc_debug("hw_rule_periods: (%u,%u)\n", it->min, it->max); 1045 rmin = UINT_MAX; 1046 rmax = 0; 1047 list_for_each_entry(fp, &subs->fmt_list, list) { 1048 if (!hw_check_valid_format(subs, params, fp)) 1049 continue; 1050 ep = get_endpoint_in_use(chip, fp->endpoint, 1051 subs->data_endpoint); 1052 if (ep) { 1053 hwc_debug("periods limit %d for ep#%x\n", 1054 ep->cur_buffer_periods, fp->endpoint); 1055 rmin = min(rmin, ep->cur_buffer_periods); 1056 rmax = max(rmax, ep->cur_buffer_periods); 1057 continue; 1058 } 1059 1060 if (fp->implicit_fb) { 1061 ep = get_endpoint_in_use(chip, fp->sync_ep, 1062 subs->sync_endpoint); 1063 if (ep) { 1064 hwc_debug("periods limit %d for sync_ep#%x\n", 1065 ep->cur_buffer_periods, fp->sync_ep); 1066 rmin = min(rmin, ep->cur_buffer_periods); 1067 rmax = max(rmax, ep->cur_buffer_periods); 1068 continue; 1069 } 1070 } 1071 } 1072 1073 if (!rmax) 1074 return 0; /* no limit by implicit fb */ 1075 return apply_hw_params_minmax(it, rmin, rmax); 1076} 1077 1078/* 1079 * set up the runtime hardware information. 1080 */ 1081 1082static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs) 1083{ 1084 const struct audioformat *fp; 1085 unsigned int pt, ptmin; 1086 int param_period_time_if_needed = -1; 1087 int err; 1088 1089 runtime->hw.formats = subs->formats; 1090 1091 runtime->hw.rate_min = 0x7fffffff; 1092 runtime->hw.rate_max = 0; 1093 runtime->hw.channels_min = 256; 1094 runtime->hw.channels_max = 0; 1095 runtime->hw.rates = 0; 1096 ptmin = UINT_MAX; 1097 /* check min/max rates and channels */ 1098 list_for_each_entry(fp, &subs->fmt_list, list) { 1099 runtime->hw.rates |= fp->rates; 1100 if (runtime->hw.rate_min > fp->rate_min) 1101 runtime->hw.rate_min = fp->rate_min; 1102 if (runtime->hw.rate_max < fp->rate_max) 1103 runtime->hw.rate_max = fp->rate_max; 1104 if (runtime->hw.channels_min > fp->channels) 1105 runtime->hw.channels_min = fp->channels; 1106 if (runtime->hw.channels_max < fp->channels) 1107 runtime->hw.channels_max = fp->channels; 1108 if (fp->fmt_type == UAC_FORMAT_TYPE_II && fp->frame_size > 0) { 1109 /* FIXME: there might be more than one audio formats... */ 1110 runtime->hw.period_bytes_min = runtime->hw.period_bytes_max = 1111 fp->frame_size; 1112 } 1113 pt = 125 * (1 << fp->datainterval); 1114 ptmin = min(ptmin, pt); 1115 } 1116 1117 param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME; 1118 if (subs->speed == USB_SPEED_FULL) 1119 /* full speed devices have fixed data packet interval */ 1120 ptmin = 1000; 1121 if (ptmin == 1000) 1122 /* if period time doesn't go below 1 ms, no rules needed */ 1123 param_period_time_if_needed = -1; 1124 1125 err = snd_pcm_hw_constraint_minmax(runtime, 1126 SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1127 ptmin, UINT_MAX); 1128 if (err < 0) 1129 return err; 1130 1131 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 1132 hw_rule_rate, subs, 1133 SNDRV_PCM_HW_PARAM_RATE, 1134 SNDRV_PCM_HW_PARAM_FORMAT, 1135 SNDRV_PCM_HW_PARAM_CHANNELS, 1136 param_period_time_if_needed, 1137 -1); 1138 if (err < 0) 1139 return err; 1140 1141 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 1142 hw_rule_channels, subs, 1143 SNDRV_PCM_HW_PARAM_CHANNELS, 1144 SNDRV_PCM_HW_PARAM_FORMAT, 1145 SNDRV_PCM_HW_PARAM_RATE, 1146 param_period_time_if_needed, 1147 -1); 1148 if (err < 0) 1149 return err; 1150 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT, 1151 hw_rule_format, subs, 1152 SNDRV_PCM_HW_PARAM_FORMAT, 1153 SNDRV_PCM_HW_PARAM_RATE, 1154 SNDRV_PCM_HW_PARAM_CHANNELS, 1155 param_period_time_if_needed, 1156 -1); 1157 if (err < 0) 1158 return err; 1159 if (param_period_time_if_needed >= 0) { 1160 err = snd_pcm_hw_rule_add(runtime, 0, 1161 SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1162 hw_rule_period_time, subs, 1163 SNDRV_PCM_HW_PARAM_FORMAT, 1164 SNDRV_PCM_HW_PARAM_CHANNELS, 1165 SNDRV_PCM_HW_PARAM_RATE, 1166 -1); 1167 if (err < 0) 1168 return err; 1169 } 1170 1171 /* set max period and buffer sizes for 1 and 2 seconds, respectively */ 1172 err = snd_pcm_hw_constraint_minmax(runtime, 1173 SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1174 0, 1000000); 1175 if (err < 0) 1176 return err; 1177 err = snd_pcm_hw_constraint_minmax(runtime, 1178 SNDRV_PCM_HW_PARAM_BUFFER_TIME, 1179 0, 2000000); 1180 if (err < 0) 1181 return err; 1182 1183 /* additional hw constraints for implicit fb */ 1184 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 1185 hw_rule_period_size_implicit_fb, subs, 1186 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1); 1187 if (err < 0) 1188 return err; 1189 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS, 1190 hw_rule_periods_implicit_fb, subs, 1191 SNDRV_PCM_HW_PARAM_PERIODS, -1); 1192 if (err < 0) 1193 return err; 1194 1195 list_for_each_entry(fp, &subs->fmt_list, list) { 1196 if (fp->implicit_fb) { 1197 runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX; 1198 break; 1199 } 1200 } 1201 1202 return 0; 1203} 1204 1205static int snd_usb_pcm_open(struct snd_pcm_substream *substream) 1206{ 1207 int direction = substream->stream; 1208 struct snd_usb_stream *as = snd_pcm_substream_chip(substream); 1209 struct snd_pcm_runtime *runtime = substream->runtime; 1210 struct snd_usb_substream *subs = &as->substream[direction]; 1211 int ret; 1212 1213 runtime->hw = snd_usb_hardware; 1214 /* need an explicit sync to catch applptr update in low-latency mode */ 1215 if (direction == SNDRV_PCM_STREAM_PLAYBACK && 1216 as->chip->lowlatency) 1217 runtime->hw.info |= SNDRV_PCM_INFO_SYNC_APPLPTR; 1218 runtime->private_data = subs; 1219 subs->pcm_substream = substream; 1220 /* runtime PM is also done there */ 1221 1222 /* initialize DSD/DOP context */ 1223 subs->dsd_dop.byte_idx = 0; 1224 subs->dsd_dop.channel = 0; 1225 subs->dsd_dop.marker = 1; 1226 1227 ret = setup_hw_info(runtime, subs); 1228 if (ret < 0) 1229 return ret; 1230 ret = snd_usb_autoresume(subs->stream->chip); 1231 if (ret < 0) 1232 return ret; 1233 ret = snd_media_stream_init(subs, as->pcm, direction); 1234 if (ret < 0) 1235 snd_usb_autosuspend(subs->stream->chip); 1236 return ret; 1237} 1238 1239static int snd_usb_pcm_close(struct snd_pcm_substream *substream) 1240{ 1241 int direction = substream->stream; 1242 struct snd_usb_stream *as = snd_pcm_substream_chip(substream); 1243 struct snd_usb_substream *subs = &as->substream[direction]; 1244 int ret; 1245 1246 snd_media_stop_pipeline(subs); 1247 1248 if (!snd_usb_lock_shutdown(subs->stream->chip)) { 1249 ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D1); 1250 snd_usb_unlock_shutdown(subs->stream->chip); 1251 if (ret < 0) 1252 return ret; 1253 } 1254 1255 subs->pcm_substream = NULL; 1256 snd_usb_autosuspend(subs->stream->chip); 1257 1258 return 0; 1259} 1260 1261/* Since a URB can handle only a single linear buffer, we must use double 1262 * buffering when the data to be transferred overflows the buffer boundary. 1263 * To avoid inconsistencies when updating hwptr_done, we use double buffering 1264 * for all URBs. 1265 */ 1266static void retire_capture_urb(struct snd_usb_substream *subs, 1267 struct urb *urb) 1268{ 1269 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 1270 unsigned int stride, frames, bytes, oldptr; 1271 int i, period_elapsed = 0; 1272 unsigned long flags; 1273 unsigned char *cp; 1274 int current_frame_number; 1275 1276 /* read frame number here, update pointer in critical section */ 1277 current_frame_number = usb_get_current_frame_number(subs->dev); 1278 1279 stride = runtime->frame_bits >> 3; 1280 1281 for (i = 0; i < urb->number_of_packets; i++) { 1282 cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset + subs->pkt_offset_adj; 1283 if (urb->iso_frame_desc[i].status && printk_ratelimit()) { 1284 dev_dbg(&subs->dev->dev, "frame %d active: %d\n", 1285 i, urb->iso_frame_desc[i].status); 1286 // continue; 1287 } 1288 bytes = urb->iso_frame_desc[i].actual_length; 1289 if (subs->stream_offset_adj > 0) { 1290 unsigned int adj = min(subs->stream_offset_adj, bytes); 1291 cp += adj; 1292 bytes -= adj; 1293 subs->stream_offset_adj -= adj; 1294 } 1295 frames = bytes / stride; 1296 if (!subs->txfr_quirk) 1297 bytes = frames * stride; 1298 if (bytes % (runtime->sample_bits >> 3) != 0) { 1299 int oldbytes = bytes; 1300 bytes = frames * stride; 1301 dev_warn_ratelimited(&subs->dev->dev, 1302 "Corrected urb data len. %d->%d\n", 1303 oldbytes, bytes); 1304 } 1305 /* update the current pointer */ 1306 spin_lock_irqsave(&subs->lock, flags); 1307 oldptr = subs->hwptr_done; 1308 subs->hwptr_done += bytes; 1309 if (subs->hwptr_done >= subs->buffer_bytes) 1310 subs->hwptr_done -= subs->buffer_bytes; 1311 frames = (bytes + (oldptr % stride)) / stride; 1312 subs->transfer_done += frames; 1313 if (subs->transfer_done >= runtime->period_size) { 1314 subs->transfer_done -= runtime->period_size; 1315 period_elapsed = 1; 1316 } 1317 1318 /* realign last_frame_number */ 1319 subs->last_frame_number = current_frame_number; 1320 1321 spin_unlock_irqrestore(&subs->lock, flags); 1322 /* copy a data chunk */ 1323 if (oldptr + bytes > subs->buffer_bytes) { 1324 unsigned int bytes1 = subs->buffer_bytes - oldptr; 1325 1326 memcpy(runtime->dma_area + oldptr, cp, bytes1); 1327 memcpy(runtime->dma_area, cp + bytes1, bytes - bytes1); 1328 } else { 1329 memcpy(runtime->dma_area + oldptr, cp, bytes); 1330 } 1331 } 1332 1333 if (period_elapsed) 1334 snd_pcm_period_elapsed(subs->pcm_substream); 1335} 1336 1337static void urb_ctx_queue_advance(struct snd_usb_substream *subs, 1338 struct urb *urb, unsigned int bytes) 1339{ 1340 struct snd_urb_ctx *ctx = urb->context; 1341 1342 ctx->queued += bytes; 1343 subs->inflight_bytes += bytes; 1344 subs->hwptr_done += bytes; 1345 if (subs->hwptr_done >= subs->buffer_bytes) 1346 subs->hwptr_done -= subs->buffer_bytes; 1347} 1348 1349static inline void fill_playback_urb_dsd_dop(struct snd_usb_substream *subs, 1350 struct urb *urb, unsigned int bytes) 1351{ 1352 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 1353 unsigned int dst_idx = 0; 1354 unsigned int src_idx = subs->hwptr_done; 1355 unsigned int wrap = subs->buffer_bytes; 1356 u8 *dst = urb->transfer_buffer; 1357 u8 *src = runtime->dma_area; 1358 static const u8 marker[] = { 0x05, 0xfa }; 1359 unsigned int queued = 0; 1360 1361 /* 1362 * The DSP DOP format defines a way to transport DSD samples over 1363 * normal PCM data endpoints. It requires stuffing of marker bytes 1364 * (0x05 and 0xfa, alternating per sample frame), and then expects 1365 * 2 additional bytes of actual payload. The whole frame is stored 1366 * LSB. 1367 * 1368 * Hence, for a stereo transport, the buffer layout looks like this, 1369 * where L refers to left channel samples and R to right. 1370 * 1371 * L1 L2 0x05 R1 R2 0x05 L3 L4 0xfa R3 R4 0xfa 1372 * L5 L6 0x05 R5 R6 0x05 L7 L8 0xfa R7 R8 0xfa 1373 * ..... 1374 * 1375 */ 1376 1377 while (bytes--) { 1378 if (++subs->dsd_dop.byte_idx == 3) { 1379 /* frame boundary? */ 1380 dst[dst_idx++] = marker[subs->dsd_dop.marker]; 1381 src_idx += 2; 1382 subs->dsd_dop.byte_idx = 0; 1383 1384 if (++subs->dsd_dop.channel % runtime->channels == 0) { 1385 /* alternate the marker */ 1386 subs->dsd_dop.marker++; 1387 subs->dsd_dop.marker %= ARRAY_SIZE(marker); 1388 subs->dsd_dop.channel = 0; 1389 } 1390 } else { 1391 /* stuff the DSD payload */ 1392 int idx = (src_idx + subs->dsd_dop.byte_idx - 1) % wrap; 1393 1394 if (subs->cur_audiofmt->dsd_bitrev) 1395 dst[dst_idx++] = bitrev8(src[idx]); 1396 else 1397 dst[dst_idx++] = src[idx]; 1398 queued++; 1399 } 1400 } 1401 1402 urb_ctx_queue_advance(subs, urb, queued); 1403} 1404 1405/* copy bit-reversed bytes onto transfer buffer */ 1406static void fill_playback_urb_dsd_bitrev(struct snd_usb_substream *subs, 1407 struct urb *urb, unsigned int bytes) 1408{ 1409 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 1410 const u8 *src = runtime->dma_area; 1411 u8 *buf = urb->transfer_buffer; 1412 int i, ofs = subs->hwptr_done; 1413 1414 for (i = 0; i < bytes; i++) { 1415 *buf++ = bitrev8(src[ofs]); 1416 if (++ofs >= subs->buffer_bytes) 1417 ofs = 0; 1418 } 1419 1420 urb_ctx_queue_advance(subs, urb, bytes); 1421} 1422 1423static void copy_to_urb(struct snd_usb_substream *subs, struct urb *urb, 1424 int offset, int stride, unsigned int bytes) 1425{ 1426 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 1427 1428 if (subs->hwptr_done + bytes > subs->buffer_bytes) { 1429 /* err, the transferred area goes over buffer boundary. */ 1430 unsigned int bytes1 = subs->buffer_bytes - subs->hwptr_done; 1431 1432 memcpy(urb->transfer_buffer + offset, 1433 runtime->dma_area + subs->hwptr_done, bytes1); 1434 memcpy(urb->transfer_buffer + offset + bytes1, 1435 runtime->dma_area, bytes - bytes1); 1436 } else { 1437 memcpy(urb->transfer_buffer + offset, 1438 runtime->dma_area + subs->hwptr_done, bytes); 1439 } 1440 1441 urb_ctx_queue_advance(subs, urb, bytes); 1442} 1443 1444static unsigned int copy_to_urb_quirk(struct snd_usb_substream *subs, 1445 struct urb *urb, int stride, 1446 unsigned int bytes) 1447{ 1448 __le32 packet_length; 1449 int i; 1450 1451 /* Put __le32 length descriptor at start of each packet. */ 1452 for (i = 0; i < urb->number_of_packets; i++) { 1453 unsigned int length = urb->iso_frame_desc[i].length; 1454 unsigned int offset = urb->iso_frame_desc[i].offset; 1455 1456 packet_length = cpu_to_le32(length); 1457 offset += i * sizeof(packet_length); 1458 urb->iso_frame_desc[i].offset = offset; 1459 urb->iso_frame_desc[i].length += sizeof(packet_length); 1460 memcpy(urb->transfer_buffer + offset, 1461 &packet_length, sizeof(packet_length)); 1462 copy_to_urb(subs, urb, offset + sizeof(packet_length), 1463 stride, length); 1464 } 1465 /* Adjust transfer size accordingly. */ 1466 bytes += urb->number_of_packets * sizeof(packet_length); 1467 return bytes; 1468} 1469 1470static int prepare_playback_urb(struct snd_usb_substream *subs, 1471 struct urb *urb, 1472 bool in_stream_lock) 1473{ 1474 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; 1475 struct snd_usb_endpoint *ep = subs->data_endpoint; 1476 struct snd_urb_ctx *ctx = urb->context; 1477 unsigned int frames, bytes; 1478 int counts; 1479 unsigned int transfer_done, frame_limit, avail = 0; 1480 int i, stride, period_elapsed = 0; 1481 unsigned long flags; 1482 int err = 0; 1483 1484 stride = ep->stride; 1485 1486 frames = 0; 1487 ctx->queued = 0; 1488 urb->number_of_packets = 0; 1489 1490 spin_lock_irqsave(&subs->lock, flags); 1491 frame_limit = subs->frame_limit + ep->max_urb_frames; 1492 transfer_done = subs->transfer_done; 1493 1494 if (subs->lowlatency_playback && 1495 runtime->state != SNDRV_PCM_STATE_DRAINING) { 1496 unsigned int hwptr = subs->hwptr_done / stride; 1497 1498 /* calculate the byte offset-in-buffer of the appl_ptr */ 1499 avail = (runtime->control->appl_ptr - runtime->hw_ptr_base) 1500 % runtime->buffer_size; 1501 if (avail <= hwptr) 1502 avail += runtime->buffer_size; 1503 avail -= hwptr; 1504 } 1505 1506 for (i = 0; i < ctx->packets; i++) { 1507 counts = snd_usb_endpoint_next_packet_size(ep, ctx, i, avail); 1508 if (counts < 0) 1509 break; 1510 /* set up descriptor */ 1511 urb->iso_frame_desc[i].offset = frames * stride; 1512 urb->iso_frame_desc[i].length = counts * stride; 1513 frames += counts; 1514 avail -= counts; 1515 urb->number_of_packets++; 1516 transfer_done += counts; 1517 if (transfer_done >= runtime->period_size) { 1518 transfer_done -= runtime->period_size; 1519 frame_limit = 0; 1520 period_elapsed = 1; 1521 if (subs->fmt_type == UAC_FORMAT_TYPE_II) { 1522 if (transfer_done > 0) { 1523 /* FIXME: fill-max mode is not 1524 * supported yet */ 1525 frames -= transfer_done; 1526 counts -= transfer_done; 1527 urb->iso_frame_desc[i].length = 1528 counts * stride; 1529 transfer_done = 0; 1530 } 1531 i++; 1532 if (i < ctx->packets) { 1533 /* add a transfer delimiter */ 1534 urb->iso_frame_desc[i].offset = 1535 frames * stride; 1536 urb->iso_frame_desc[i].length = 0; 1537 urb->number_of_packets++; 1538 } 1539 break; 1540 } 1541 } 1542 /* finish at the period boundary or after enough frames */ 1543 if ((period_elapsed || transfer_done >= frame_limit) && 1544 !snd_usb_endpoint_implicit_feedback_sink(ep)) 1545 break; 1546 } 1547 1548 if (!frames) { 1549 err = -EAGAIN; 1550 goto unlock; 1551 } 1552 1553 bytes = frames * stride; 1554 subs->transfer_done = transfer_done; 1555 subs->frame_limit = frame_limit; 1556 if (unlikely(ep->cur_format == SNDRV_PCM_FORMAT_DSD_U16_LE && 1557 subs->cur_audiofmt->dsd_dop)) { 1558 fill_playback_urb_dsd_dop(subs, urb, bytes); 1559 } else if (unlikely(ep->cur_format == SNDRV_PCM_FORMAT_DSD_U8 && 1560 subs->cur_audiofmt->dsd_bitrev)) { 1561 fill_playback_urb_dsd_bitrev(subs, urb, bytes); 1562 } else { 1563 /* usual PCM */ 1564 if (!subs->tx_length_quirk) 1565 copy_to_urb(subs, urb, 0, stride, bytes); 1566 else 1567 bytes = copy_to_urb_quirk(subs, urb, stride, bytes); 1568 /* bytes is now amount of outgoing data */ 1569 } 1570 1571 subs->last_frame_number = usb_get_current_frame_number(subs->dev); 1572 1573 if (subs->trigger_tstamp_pending_update) { 1574 /* this is the first actual URB submitted, 1575 * update trigger timestamp to reflect actual start time 1576 */ 1577 snd_pcm_gettime(runtime, &runtime->trigger_tstamp); 1578 subs->trigger_tstamp_pending_update = false; 1579 } 1580 1581 if (period_elapsed && !subs->running && subs->lowlatency_playback) { 1582 subs->period_elapsed_pending = 1; 1583 period_elapsed = 0; 1584 } 1585 1586 unlock: 1587 spin_unlock_irqrestore(&subs->lock, flags); 1588 if (err < 0) 1589 return err; 1590 urb->transfer_buffer_length = bytes; 1591 if (period_elapsed) { 1592 if (in_stream_lock) 1593 snd_pcm_period_elapsed_under_stream_lock(subs->pcm_substream); 1594 else 1595 snd_pcm_period_elapsed(subs->pcm_substream); 1596 } 1597 return 0; 1598} 1599 1600/* 1601 * process after playback data complete 1602 * - decrease the delay count again 1603 */ 1604static void retire_playback_urb(struct snd_usb_substream *subs, 1605 struct urb *urb) 1606{ 1607 unsigned long flags; 1608 struct snd_urb_ctx *ctx = urb->context; 1609 bool period_elapsed = false; 1610 1611 spin_lock_irqsave(&subs->lock, flags); 1612 if (ctx->queued) { 1613 if (subs->inflight_bytes >= ctx->queued) 1614 subs->inflight_bytes -= ctx->queued; 1615 else 1616 subs->inflight_bytes = 0; 1617 } 1618 1619 subs->last_frame_number = usb_get_current_frame_number(subs->dev); 1620 if (subs->running) { 1621 period_elapsed = subs->period_elapsed_pending; 1622 subs->period_elapsed_pending = 0; 1623 } 1624 spin_unlock_irqrestore(&subs->lock, flags); 1625 if (period_elapsed) 1626 snd_pcm_period_elapsed(subs->pcm_substream); 1627} 1628 1629/* PCM ack callback for the playback stream; 1630 * this plays a role only when the stream is running in low-latency mode. 1631 */ 1632static int snd_usb_pcm_playback_ack(struct snd_pcm_substream *substream) 1633{ 1634 struct snd_usb_substream *subs = substream->runtime->private_data; 1635 struct snd_usb_endpoint *ep; 1636 1637 if (!subs->lowlatency_playback || !subs->running) 1638 return 0; 1639 ep = subs->data_endpoint; 1640 if (!ep) 1641 return 0; 1642 /* When no more in-flight URBs available, try to process the pending 1643 * outputs here 1644 */ 1645 if (!ep->active_mask) 1646 return snd_usb_queue_pending_output_urbs(ep, true); 1647 return 0; 1648} 1649 1650static int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream, 1651 int cmd) 1652{ 1653 struct snd_usb_substream *subs = substream->runtime->private_data; 1654 int err; 1655 1656 switch (cmd) { 1657 case SNDRV_PCM_TRIGGER_START: 1658 subs->trigger_tstamp_pending_update = true; 1659 fallthrough; 1660 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 1661 snd_usb_endpoint_set_callback(subs->data_endpoint, 1662 prepare_playback_urb, 1663 retire_playback_urb, 1664 subs); 1665 if (subs->lowlatency_playback && 1666 cmd == SNDRV_PCM_TRIGGER_START) { 1667 if (in_free_wheeling_mode(substream->runtime)) 1668 subs->lowlatency_playback = false; 1669 err = start_endpoints(subs); 1670 if (err < 0) { 1671 snd_usb_endpoint_set_callback(subs->data_endpoint, 1672 NULL, NULL, NULL); 1673 return err; 1674 } 1675 } 1676 subs->running = 1; 1677 dev_dbg(&subs->dev->dev, "%d:%d Start Playback PCM\n", 1678 subs->cur_audiofmt->iface, 1679 subs->cur_audiofmt->altsetting); 1680 return 0; 1681 case SNDRV_PCM_TRIGGER_SUSPEND: 1682 case SNDRV_PCM_TRIGGER_STOP: 1683 stop_endpoints(subs, substream->runtime->state == SNDRV_PCM_STATE_DRAINING); 1684 snd_usb_endpoint_set_callback(subs->data_endpoint, 1685 NULL, NULL, NULL); 1686 subs->running = 0; 1687 dev_dbg(&subs->dev->dev, "%d:%d Stop Playback PCM\n", 1688 subs->cur_audiofmt->iface, 1689 subs->cur_audiofmt->altsetting); 1690 return 0; 1691 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 1692 /* keep retire_data_urb for delay calculation */ 1693 snd_usb_endpoint_set_callback(subs->data_endpoint, 1694 NULL, 1695 retire_playback_urb, 1696 subs); 1697 subs->running = 0; 1698 dev_dbg(&subs->dev->dev, "%d:%d Pause Playback PCM\n", 1699 subs->cur_audiofmt->iface, 1700 subs->cur_audiofmt->altsetting); 1701 return 0; 1702 } 1703 1704 return -EINVAL; 1705} 1706 1707static int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, 1708 int cmd) 1709{ 1710 int err; 1711 struct snd_usb_substream *subs = substream->runtime->private_data; 1712 1713 switch (cmd) { 1714 case SNDRV_PCM_TRIGGER_START: 1715 err = start_endpoints(subs); 1716 if (err < 0) 1717 return err; 1718 fallthrough; 1719 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 1720 snd_usb_endpoint_set_callback(subs->data_endpoint, 1721 NULL, retire_capture_urb, 1722 subs); 1723 subs->last_frame_number = usb_get_current_frame_number(subs->dev); 1724 subs->running = 1; 1725 dev_dbg(&subs->dev->dev, "%d:%d Start Capture PCM\n", 1726 subs->cur_audiofmt->iface, 1727 subs->cur_audiofmt->altsetting); 1728 return 0; 1729 case SNDRV_PCM_TRIGGER_SUSPEND: 1730 case SNDRV_PCM_TRIGGER_STOP: 1731 stop_endpoints(subs, false); 1732 fallthrough; 1733 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 1734 snd_usb_endpoint_set_callback(subs->data_endpoint, 1735 NULL, NULL, NULL); 1736 subs->running = 0; 1737 dev_dbg(&subs->dev->dev, "%d:%d Stop Capture PCM\n", 1738 subs->cur_audiofmt->iface, 1739 subs->cur_audiofmt->altsetting); 1740 return 0; 1741 } 1742 1743 return -EINVAL; 1744} 1745 1746static const struct snd_pcm_ops snd_usb_playback_ops = { 1747 .open = snd_usb_pcm_open, 1748 .close = snd_usb_pcm_close, 1749 .hw_params = snd_usb_hw_params, 1750 .hw_free = snd_usb_hw_free, 1751 .prepare = snd_usb_pcm_prepare, 1752 .trigger = snd_usb_substream_playback_trigger, 1753 .sync_stop = snd_usb_pcm_sync_stop, 1754 .pointer = snd_usb_pcm_pointer, 1755 .ack = snd_usb_pcm_playback_ack, 1756}; 1757 1758static const struct snd_pcm_ops snd_usb_capture_ops = { 1759 .open = snd_usb_pcm_open, 1760 .close = snd_usb_pcm_close, 1761 .hw_params = snd_usb_hw_params, 1762 .hw_free = snd_usb_hw_free, 1763 .prepare = snd_usb_pcm_prepare, 1764 .trigger = snd_usb_substream_capture_trigger, 1765 .sync_stop = snd_usb_pcm_sync_stop, 1766 .pointer = snd_usb_pcm_pointer, 1767}; 1768 1769void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream) 1770{ 1771 const struct snd_pcm_ops *ops; 1772 1773 ops = stream == SNDRV_PCM_STREAM_PLAYBACK ? 1774 &snd_usb_playback_ops : &snd_usb_capture_ops; 1775 snd_pcm_set_ops(pcm, stream, ops); 1776} 1777 1778void snd_usb_preallocate_buffer(struct snd_usb_substream *subs) 1779{ 1780 struct snd_pcm *pcm = subs->stream->pcm; 1781 struct snd_pcm_substream *s = pcm->streams[subs->direction].substream; 1782 struct device *dev = subs->dev->bus->sysdev; 1783 1784 if (snd_usb_use_vmalloc) 1785 snd_pcm_set_managed_buffer(s, SNDRV_DMA_TYPE_VMALLOC, 1786 NULL, 0, 0); 1787 else 1788 snd_pcm_set_managed_buffer(s, SNDRV_DMA_TYPE_DEV_SG, 1789 dev, 64*1024, 512*1024); 1790} 1791