1791 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*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 029#define SUBSTREAM_FLAG_SYNC_EP_STARTED 130 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 than52 * enough53 */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 format89 */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 method123 * supports the same format.124 * this is a workaround for the case like125 * 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 rate218 */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 handling336 */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 see352 * if we don't find a sync endpoint, as on M-Audio Transit. In case of353 * error fall back to SYNC mode and don't create sync endpoint354 */355 356 /* check sync-pipe endpoint */357 /* ... and check descriptor size before accessing bSynchAddress358 because there is a version of the SB Audigy 2 NX firmware lacking359 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 callback466 *467 * allocate a buffer and set the given audio format.468 *469 * so far we use a physically linear buffer although packetize transfer470 * doesn't need a continuous area.471 * if sg buffer is supported on the later version of alsa, we'll follow472 * 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 callback585 *586 * reset the audio format and release the buffer587 */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 callback634 *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 implicit685 * 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 constraints699 */700 701#ifdef HW_CONST_DEBUG702#define hwc_debug(fmt, args...) pr_debug(fmt, ##args)703#else704#define hwc_debug(fmt, args...) do { } while(0)705#endif706 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 streams800 * (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 double1262 * buffering when the data to be transferred overflows the buffer boundary.1263 * To avoid inconsistencies when updating hwptr_done, we use double buffering1264 * 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 over1363 * normal PCM data endpoints. It requires stuffing of marker bytes1364 * (0x05 and 0xfa, alternating per sample frame), and then expects1365 * 2 additional bytes of actual payload. The whole frame is stored1366 * 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 0xfa1372 * L5 L6 0x05 R5 R6 0x05 L7 L8 0xfa R7 R8 0xfa1373 * .....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 else1397 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 not1524 * 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 else1567 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 time1576 */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 else1595 snd_pcm_period_elapsed(subs->pcm_substream);1596 }1597 return 0;1598}1599 1600/*1601 * process after playback data complete1602 * - decrease the delay count again1603 */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 else1616 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 pending1643 * outputs here1644 */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 else1788 snd_pcm_set_managed_buffer(s, SNDRV_DMA_TYPE_DEV_SG,1789 dev, 64*1024, 512*1024);1790}1791