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