sound/usb/pcm.c

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