sound/usb/endpoint.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  */
   4
   5 #include <linux/gfp.h>
   6 #include <linux/init.h>
   7 #include <linux/ratelimit.h>
   8 #include <linux/usb.h>
   9 #include <linux/usb/audio.h>
  10 #include <linux/slab.h>
  11
  12 #include <sound/core.h>
  13 #include <sound/pcm.h>
  14 #include <sound/pcm_params.h>
  15
  16 #include "usbaudio.h"
  17 #include "helper.h"
  18 #include "card.h"
  19 #include "endpoint.h"
  20 #include "pcm.h"
  21 #include "clock.h"
  22 #include "quirks.h"
  23
  24 enum {
  25         EP_STATE_STOPPED,
  26         EP_STATE_RUNNING,
  27         EP_STATE_STOPPING,
  28 };
  29
  30 /* interface refcounting */
  31 struct snd_usb_iface_ref {
  32         unsigned char iface;
  33         bool need_setup;
  34         int opened;
  35         struct list_head list;
  36 };
  37
  38 /* clock refcounting */
  39 struct snd_usb_clock_ref {
  40         unsigned char clock;
  41         atomic_t locked;
  42         int rate;
  43         struct list_head list;
  44 };
  45
  46 /*
  47  * snd_usb_endpoint is a model that abstracts everything related to an
  48  * USB endpoint and its streaming.
  49  *
  50  * There are functions to activate and deactivate the streaming URBs and
  51  * optional callbacks to let the pcm logic handle the actual content of the
  52  * packets for playback and record. Thus, the bus streaming and the audio
  53  * handlers are fully decoupled.
  54  *
  55  * There are two different types of endpoints in audio applications.
  56  *
  57  * SND_USB_ENDPOINT_TYPE_DATA handles full audio data payload for both
  58  * inbound and outbound traffic.
  59  *
  60  * SND_USB_ENDPOINT_TYPE_SYNC endpoints are for inbound traffic only and
  61  * expect the payload to carry Q10.14 / Q16.16 formatted sync information
  62  * (3 or 4 bytes).
  63  *
  64  * Each endpoint has to be configured prior to being used by calling
  65  * snd_usb_endpoint_set_params().
  66  *
  67  * The model incorporates a reference counting, so that multiple users
  68  * can call snd_usb_endpoint_start() and snd_usb_endpoint_stop(), and
  69  * only the first user will effectively start the URBs, and only the last
  70  * one to stop it will tear the URBs down again.
  71  */
  72
  73 /*
  74  * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
  75  * this will overflow at approx 524 kHz
  76  */
  77 static inline unsigned get_usb_full_speed_rate(unsigned int rate)
  78 {
  79         return ((rate << 13) + 62) / 125;
  80 }
  81
  82 /*
  83  * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
  84  * this will overflow at approx 4 MHz
  85  */
  86 static inline unsigned get_usb_high_speed_rate(unsigned int rate)
  87 {
  88         return ((rate << 10) + 62) / 125;
  89 }
  90
  91 /*
  92  * release a urb data
  93  */
  94 static void release_urb_ctx(struct snd_urb_ctx *u)
  95 {
  96         if (u->buffer_size)
  97                 usb_free_coherent(u->ep->chip->dev, u->buffer_size,
  98                                   u->urb->transfer_buffer,
  99                                   u->urb->transfer_dma);
 100         usb_free_urb(u->urb);
 101         u->urb = NULL;
 102 }
 103
 104 static const char *usb_error_string(int err)
 105 {
 106         switch (err) {
 107         case -ENODEV:
 108                 return "no device";
 109         case -ENOENT:
 110                 return "endpoint not enabled";
 111         case -EPIPE:
 112                 return "endpoint stalled";
 113         case -ENOSPC:
 114                 return "not enough bandwidth";
 115         case -ESHUTDOWN:
 116                 return "device disabled";
 117         case -EHOSTUNREACH:
 118                 return "device suspended";
 119         case -EINVAL:
 120         case -EAGAIN:
 121         case -EFBIG:
 122         case -EMSGSIZE:
 123                 return "internal error";
 124         default:
 125                 return "unknown error";
 126         }
 127 }
 128
 129 static inline bool ep_state_running(struct snd_usb_endpoint *ep)
 130 {
 131         return atomic_read(&ep->state) == EP_STATE_RUNNING;
 132 }
 133
 134 static inline bool ep_state_update(struct snd_usb_endpoint *ep, int old, int new)
 135 {
 136         return atomic_cmpxchg(&ep->state, old, new) == old;
 137 }
 138
 139 /**
 140  * snd_usb_endpoint_implicit_feedback_sink: Report endpoint usage type
 141  *
 142  * @ep: The snd_usb_endpoint
 143  *
 144  * Determine whether an endpoint is driven by an implicit feedback
 145  * data endpoint source.
 146  */
 147 int snd_usb_endpoint_implicit_feedback_sink(struct snd_usb_endpoint *ep)
 148 {
 149         return  ep->implicit_fb_sync && usb_pipeout(ep->pipe);
 150 }
 151
 152 /*
 153  * Return the number of samples to be sent in the next packet
 154  * for streaming based on information derived from sync endpoints
 155  *
 156  * This won't be used for implicit feedback which takes the packet size
 157  * returned from the sync source
 158  */
 159 static int slave_next_packet_size(struct snd_usb_endpoint *ep,
 160                                   unsigned int avail)
 161 {
 162         unsigned long flags;
 163         unsigned int phase;
 164         int ret;
 165
 166         if (ep->fill_max)
 167                 return ep->maxframesize;
 168
 169         spin_lock_irqsave(&ep->lock, flags);
 170         phase = (ep->phase & 0xffff) + (ep->freqm << ep->datainterval);
 171         ret = min(phase >> 16, ep->maxframesize);
 172         if (avail && ret >= avail)
 173                 ret = -EAGAIN;
 174         else
 175                 ep->phase = phase;
 176         spin_unlock_irqrestore(&ep->lock, flags);
 177
 178         return ret;
 179 }
 180
 181 /*
 182  * Return the number of samples to be sent in the next packet
 183  * for adaptive and synchronous endpoints
 184  */
 185 static int next_packet_size(struct snd_usb_endpoint *ep, unsigned int avail)
 186 {
 187         unsigned int sample_accum;
 188         int ret;
 189
 190         if (ep->fill_max)
 191                 return ep->maxframesize;
 192
 193         sample_accum = ep->sample_accum + ep->sample_rem;
 194         if (sample_accum >= ep->pps) {
 195                 sample_accum -= ep->pps;
 196                 ret = ep->packsize[1];
 197         } else {
 198                 ret = ep->packsize[0];
 199         }
 200         if (avail && ret >= avail)
 201                 ret = -EAGAIN;
 202         else
 203                 ep->sample_accum = sample_accum;
 204
 205         return ret;
 206 }
 207
 208 /*
 209  * snd_usb_endpoint_next_packet_size: Return the number of samples to be sent
 210  * in the next packet
 211  *
 212  * If the size is equal or exceeds @avail, don't proceed but return -EAGAIN
 213  * Exception: @avail = 0 for skipping the check.
 214  */
 215 int snd_usb_endpoint_next_packet_size(struct snd_usb_endpoint *ep,
 216                                       struct snd_urb_ctx *ctx, int idx,
 217                                       unsigned int avail)
 218 {
 219         unsigned int packet;
 220
 221         packet = ctx->packet_size[idx];
 222         if (packet) {
 223                 if (avail && packet >= avail)
 224                         return -EAGAIN;
 225                 return packet;
 226         }
 227
 228         if (ep->sync_source)
 229                 return slave_next_packet_size(ep, avail);
 230         else
 231                 return next_packet_size(ep, avail);
 232 }
 233
 234 static void call_retire_callback(struct snd_usb_endpoint *ep,
 235                                  struct urb *urb)
 236 {
 237         struct snd_usb_substream *data_subs;
 238
 239         data_subs = READ_ONCE(ep->data_subs);
 240         if (data_subs && ep->retire_data_urb)
 241                 ep->retire_data_urb(data_subs, urb);
 242 }
 243
 244 static void retire_outbound_urb(struct snd_usb_endpoint *ep,
 245                                 struct snd_urb_ctx *urb_ctx)
 246 {
 247         call_retire_callback(ep, urb_ctx->urb);
 248 }
 249
 250 static void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
 251                                     struct snd_usb_endpoint *sender,
 252                                     const struct urb *urb);
 253
 254 static void retire_inbound_urb(struct snd_usb_endpoint *ep,
 255                                struct snd_urb_ctx *urb_ctx)
 256 {
 257         struct urb *urb = urb_ctx->urb;
 258         struct snd_usb_endpoint *sync_sink;
 259
 260         if (unlikely(ep->skip_packets > 0)) {
 261                 ep->skip_packets--;
 262                 return;
 263         }
 264
 265         sync_sink = READ_ONCE(ep->sync_sink);
 266         if (sync_sink)
 267                 snd_usb_handle_sync_urb(sync_sink, ep, urb);
 268
 269         call_retire_callback(ep, urb);
 270 }
 271
 272 static inline bool has_tx_length_quirk(struct snd_usb_audio *chip)
 273 {
 274         return chip->quirk_flags & QUIRK_FLAG_TX_LENGTH;
 275 }
 276
 277 static void prepare_silent_urb(struct snd_usb_endpoint *ep,
 278                                struct snd_urb_ctx *ctx)
 279 {
 280         struct urb *urb = ctx->urb;
 281         unsigned int offs = 0;
 282         unsigned int extra = 0;
 283         __le32 packet_length;
 284         int i;
 285
 286         /* For tx_length_quirk, put packet length at start of packet */
 287         if (has_tx_length_quirk(ep->chip))
 288                 extra = sizeof(packet_length);
 289
 290         for (i = 0; i < ctx->packets; ++i) {
 291                 unsigned int offset;
 292                 unsigned int length;
 293                 int counts;
 294
 295                 counts = snd_usb_endpoint_next_packet_size(ep, ctx, i, 0);
 296                 length = counts * ep->stride; /* number of silent bytes */
 297                 offset = offs * ep->stride + extra * i;
 298                 urb->iso_frame_desc[i].offset = offset;
 299                 urb->iso_frame_desc[i].length = length + extra;
 300                 if (extra) {
 301                         packet_length = cpu_to_le32(length);
 302                         memcpy(urb->transfer_buffer + offset,
 303                                &packet_length, sizeof(packet_length));
 304                 }
 305                 memset(urb->transfer_buffer + offset + extra,
 306                        ep->silence_value, length);
 307                 offs += counts;
 308         }
 309
 310         urb->number_of_packets = ctx->packets;
 311         urb->transfer_buffer_length = offs * ep->stride + ctx->packets * extra;
 312         ctx->queued = 0;
 313 }
 314
 315 /*
 316  * Prepare a PLAYBACK urb for submission to the bus.
 317  */
 318 static int prepare_outbound_urb(struct snd_usb_endpoint *ep,
 319                                 struct snd_urb_ctx *ctx,
 320                                 bool in_stream_lock)
 321 {
 322         struct urb *urb = ctx->urb;
 323         unsigned char *cp = urb->transfer_buffer;
 324         struct snd_usb_substream *data_subs;
 325
 326         urb->dev = ep->chip->dev; /* we need to set this at each time */
 327
 328         switch (ep->type) {
 329         case SND_USB_ENDPOINT_TYPE_DATA:
 330                 data_subs = READ_ONCE(ep->data_subs);
 331                 if (data_subs && ep->prepare_data_urb)
 332                         return ep->prepare_data_urb(data_subs, urb, in_stream_lock);
 333                 /* no data provider, so send silence */
 334                 prepare_silent_urb(ep, ctx);
 335                 break;
 336
 337         case SND_USB_ENDPOINT_TYPE_SYNC:
 338                 if (snd_usb_get_speed(ep->chip->dev) >= USB_SPEED_HIGH) {
 339                         /*
 340                          * fill the length and offset of each urb descriptor.
 341                          * the fixed 12.13 frequency is passed as 16.16 through the pipe.
 342                          */
 343                         urb->iso_frame_desc[0].length = 4;
 344                         urb->iso_frame_desc[0].offset = 0;
 345                         cp[0] = ep->freqn;
 346                         cp[1] = ep->freqn >> 8;
 347                         cp[2] = ep->freqn >> 16;
 348                         cp[3] = ep->freqn >> 24;
 349                 } else {
 350                         /*
 351                          * fill the length and offset of each urb descriptor.
 352                          * the fixed 10.14 frequency is passed through the pipe.
 353                          */
 354                         urb->iso_frame_desc[0].length = 3;
 355                         urb->iso_frame_desc[0].offset = 0;
 356                         cp[0] = ep->freqn >> 2;
 357                         cp[1] = ep->freqn >> 10;
 358                         cp[2] = ep->freqn >> 18;
 359                 }
 360
 361                 break;
 362         }
 363         return 0;
 364 }
 365
 366 /*
 367  * Prepare a CAPTURE or SYNC urb for submission to the bus.
 368  */
 369 static int prepare_inbound_urb(struct snd_usb_endpoint *ep,
 370                                struct snd_urb_ctx *urb_ctx)
 371 {
 372         int i, offs;
 373         struct urb *urb = urb_ctx->urb;
 374
 375         urb->dev = ep->chip->dev; /* we need to set this at each time */
 376
 377         switch (ep->type) {
 378         case SND_USB_ENDPOINT_TYPE_DATA:
 379                 offs = 0;
 380                 for (i = 0; i < urb_ctx->packets; i++) {
 381                         urb->iso_frame_desc[i].offset = offs;
 382                         urb->iso_frame_desc[i].length = ep->curpacksize;
 383                         offs += ep->curpacksize;
 384                 }
 385
 386                 urb->transfer_buffer_length = offs;
 387                 urb->number_of_packets = urb_ctx->packets;
 388                 break;
 389
 390         case SND_USB_ENDPOINT_TYPE_SYNC:
 391                 urb->iso_frame_desc[0].length = min(4u, ep->syncmaxsize);
 392                 urb->iso_frame_desc[0].offset = 0;
 393                 break;
 394         }
 395         return 0;
 396 }
 397
 398 /* notify an error as XRUN to the assigned PCM data substream */
 399 static void notify_xrun(struct snd_usb_endpoint *ep)
 400 {
 401         struct snd_usb_substream *data_subs;
 402
 403         data_subs = READ_ONCE(ep->data_subs);
 404         if (data_subs && data_subs->pcm_substream)
 405                 snd_pcm_stop_xrun(data_subs->pcm_substream);
 406 }
 407
 408 static struct snd_usb_packet_info *
 409 next_packet_fifo_enqueue(struct snd_usb_endpoint *ep)
 410 {
 411         struct snd_usb_packet_info *p;
 412
 413         p = ep->next_packet + (ep->next_packet_head + ep->next_packet_queued) %
 414                 ARRAY_SIZE(ep->next_packet);
 415         ep->next_packet_queued++;
 416         return p;
 417 }
 418
 419 static struct snd_usb_packet_info *
 420 next_packet_fifo_dequeue(struct snd_usb_endpoint *ep)
 421 {
 422         struct snd_usb_packet_info *p;
 423
 424         p = ep->next_packet + ep->next_packet_head;
 425         ep->next_packet_head++;
 426         ep->next_packet_head %= ARRAY_SIZE(ep->next_packet);
 427         ep->next_packet_queued--;
 428         return p;
 429 }
 430
 431 static void push_back_to_ready_list(struct snd_usb_endpoint *ep,
 432                                     struct snd_urb_ctx *ctx)
 433 {
 434         unsigned long flags;
 435
 436         spin_lock_irqsave(&ep->lock, flags);
 437         list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
 438         spin_unlock_irqrestore(&ep->lock, flags);
 439 }
 440
 441 /*
 442  * Send output urbs that have been prepared previously. URBs are dequeued
 443  * from ep->ready_playback_urbs and in case there aren't any available
 444  * or there are no packets that have been prepared, this function does
 445  * nothing.
 446  *
 447  * The reason why the functionality of sending and preparing URBs is separated
 448  * is that host controllers don't guarantee the order in which they return
 449  * inbound and outbound packets to their submitters.
 450  *
 451  * This function is used both for implicit feedback endpoints and in low-
 452  * latency playback mode.
 453  */
 454 void snd_usb_queue_pending_output_urbs(struct snd_usb_endpoint *ep,
 455                                        bool in_stream_lock)
 456 {
 457         bool implicit_fb = snd_usb_endpoint_implicit_feedback_sink(ep);
 458
 459         while (ep_state_running(ep)) {
 460
 461                 unsigned long flags;
 462                 struct snd_usb_packet_info *packet;
 463                 struct snd_urb_ctx *ctx = NULL;
 464                 int err, i;
 465
 466                 spin_lock_irqsave(&ep->lock, flags);
 467                 if ((!implicit_fb || ep->next_packet_queued > 0) &&
 468                     !list_empty(&ep->ready_playback_urbs)) {
 469                         /* take URB out of FIFO */
 470                         ctx = list_first_entry(&ep->ready_playback_urbs,
 471                                                struct snd_urb_ctx, ready_list);
 472                         list_del_init(&ctx->ready_list);
 473                         if (implicit_fb)
 474                                 packet = next_packet_fifo_dequeue(ep);
 475                 }
 476                 spin_unlock_irqrestore(&ep->lock, flags);
 477
 478                 if (ctx == NULL)
 479                         return;
 480
 481                 /* copy over the length information */
 482                 if (implicit_fb) {
 483                         for (i = 0; i < packet->packets; i++)
 484                                 ctx->packet_size[i] = packet->packet_size[i];
 485                 }
 486
 487                 /* call the data handler to fill in playback data */
 488                 err = prepare_outbound_urb(ep, ctx, in_stream_lock);
 489                 /* can be stopped during prepare callback */
 490                 if (unlikely(!ep_state_running(ep)))
 491                         break;
 492                 if (err < 0) {
 493                         /* push back to ready list again for -EAGAIN */
 494                         if (err == -EAGAIN)
 495                                 push_back_to_ready_list(ep, ctx);
 496                         else
 497                                 notify_xrun(ep);
 498                         return;
 499                 }
 500
 501                 err = usb_submit_urb(ctx->urb, GFP_ATOMIC);
 502                 if (err < 0) {
 503                         usb_audio_err(ep->chip,
 504                                       "Unable to submit urb #%d: %d at %s\n",
 505                                       ctx->index, err, __func__);
 506                         notify_xrun(ep);
 507                         return;
 508                 }
 509
 510                 set_bit(ctx->index, &ep->active_mask);
 511                 atomic_inc(&ep->submitted_urbs);
 512         }
 513 }
 514
 515 /*
 516  * complete callback for urbs
 517  */
 518 static void snd_complete_urb(struct urb *urb)
 519 {
 520         struct snd_urb_ctx *ctx = urb->context;
 521         struct snd_usb_endpoint *ep = ctx->ep;
 522         int err;
 523
 524         if (unlikely(urb->status == -ENOENT ||          /* unlinked */
 525                      urb->status == -ENODEV ||          /* device removed */
 526                      urb->status == -ECONNRESET ||      /* unlinked */
 527                      urb->status == -ESHUTDOWN))        /* device disabled */
 528                 goto exit_clear;
 529         /* device disconnected */
 530         if (unlikely(atomic_read(&ep->chip->shutdown)))
 531                 goto exit_clear;
 532
 533         if (unlikely(!ep_state_running(ep)))
 534                 goto exit_clear;
 535
 536         if (usb_pipeout(ep->pipe)) {
 537                 retire_outbound_urb(ep, ctx);
 538                 /* can be stopped during retire callback */
 539                 if (unlikely(!ep_state_running(ep)))
 540                         goto exit_clear;
 541
 542                 /* in low-latency and implicit-feedback modes, push back the
 543                  * URB to ready list at first, then process as much as possible
 544                  */
 545                 if (ep->lowlatency_playback ||
 546                      snd_usb_endpoint_implicit_feedback_sink(ep)) {
 547                         push_back_to_ready_list(ep, ctx);
 548                         clear_bit(ctx->index, &ep->active_mask);
 549                         snd_usb_queue_pending_output_urbs(ep, false);
 550                         atomic_dec(&ep->submitted_urbs); /* decrement at last */
 551                         return;
 552                 }
 553
 554                 /* in non-lowlatency mode, no error handling for prepare */
 555                 prepare_outbound_urb(ep, ctx, false);
 556                 /* can be stopped during prepare callback */
 557                 if (unlikely(!ep_state_running(ep)))
 558                         goto exit_clear;
 559         } else {
 560                 retire_inbound_urb(ep, ctx);
 561                 /* can be stopped during retire callback */
 562                 if (unlikely(!ep_state_running(ep)))
 563                         goto exit_clear;
 564
 565                 prepare_inbound_urb(ep, ctx);
 566         }
 567
 568         err = usb_submit_urb(urb, GFP_ATOMIC);
 569         if (err == 0)
 570                 return;
 571
 572         usb_audio_err(ep->chip, "cannot submit urb (err = %d)\n", err);
 573         notify_xrun(ep);
 574
 575 exit_clear:
 576         clear_bit(ctx->index, &ep->active_mask);
 577         atomic_dec(&ep->submitted_urbs);
 578 }
 579
 580 /*
 581  * Find or create a refcount object for the given interface
 582  *
 583  * The objects are released altogether in snd_usb_endpoint_free_all()
 584  */
 585 static struct snd_usb_iface_ref *
 586 iface_ref_find(struct snd_usb_audio *chip, int iface)
 587 {
 588         struct snd_usb_iface_ref *ip;
 589
 590         list_for_each_entry(ip, &chip->iface_ref_list, list)
 591                 if (ip->iface == iface)
 592                         return ip;
 593
 594         ip = kzalloc(sizeof(*ip), GFP_KERNEL);
 595         if (!ip)
 596                 return NULL;
 597         ip->iface = iface;
 598         list_add_tail(&ip->list, &chip->iface_ref_list);
 599         return ip;
 600 }
 601
 602 /* Similarly, a refcount object for clock */
 603 static struct snd_usb_clock_ref *
 604 clock_ref_find(struct snd_usb_audio *chip, int clock)
 605 {
 606         struct snd_usb_clock_ref *ref;
 607
 608         list_for_each_entry(ref, &chip->clock_ref_list, list)
 609                 if (ref->clock == clock)
 610                         return ref;
 611
 612         ref = kzalloc(sizeof(*ref), GFP_KERNEL);
 613         if (!ref)
 614                 return NULL;
 615         ref->clock = clock;
 616         atomic_set(&ref->locked, 0);
 617         list_add_tail(&ref->list, &chip->clock_ref_list);
 618         return ref;
 619 }
 620
 621 /*
 622  * Get the existing endpoint object corresponding EP
 623  * Returns NULL if not present.
 624  */
 625 struct snd_usb_endpoint *
 626 snd_usb_get_endpoint(struct snd_usb_audio *chip, int ep_num)
 627 {
 628         struct snd_usb_endpoint *ep;
 629
 630         list_for_each_entry(ep, &chip->ep_list, list) {
 631                 if (ep->ep_num == ep_num)
 632                         return ep;
 633         }
 634
 635         return NULL;
 636 }
 637
 638 #define ep_type_name(type) \
 639         (type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync")
 640
 641 /**
 642  * snd_usb_add_endpoint: Add an endpoint to an USB audio chip
 643  *
 644  * @chip: The chip
 645  * @ep_num: The number of the endpoint to use
 646  * @type: SND_USB_ENDPOINT_TYPE_DATA or SND_USB_ENDPOINT_TYPE_SYNC
 647  *
 648  * If the requested endpoint has not been added to the given chip before,
 649  * a new instance is created.
 650  *
 651  * Returns zero on success or a negative error code.
 652  *
 653  * New endpoints will be added to chip->ep_list and freed by
 654  * calling snd_usb_endpoint_free_all().
 655  *
 656  * For SND_USB_ENDPOINT_TYPE_SYNC, the caller needs to guarantee that
 657  * bNumEndpoints > 1 beforehand.
 658  */
 659 int snd_usb_add_endpoint(struct snd_usb_audio *chip, int ep_num, int type)
 660 {
 661         struct snd_usb_endpoint *ep;
 662         bool is_playback;
 663
 664         ep = snd_usb_get_endpoint(chip, ep_num);
 665         if (ep)
 666                 return 0;
 667
 668         usb_audio_dbg(chip, "Creating new %s endpoint #%x\n",
 669                       ep_type_name(type),
 670                       ep_num);
 671         ep = kzalloc(sizeof(*ep), GFP_KERNEL);
 672         if (!ep)
 673                 return -ENOMEM;
 674
 675         ep->chip = chip;
 676         spin_lock_init(&ep->lock);
 677         ep->type = type;
 678         ep->ep_num = ep_num;
 679         INIT_LIST_HEAD(&ep->ready_playback_urbs);
 680         atomic_set(&ep->submitted_urbs, 0);
 681
 682         is_playback = ((ep_num & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT);
 683         ep_num &= USB_ENDPOINT_NUMBER_MASK;
 684         if (is_playback)
 685                 ep->pipe = usb_sndisocpipe(chip->dev, ep_num);
 686         else
 687                 ep->pipe = usb_rcvisocpipe(chip->dev, ep_num);
 688
 689         list_add_tail(&ep->list, &chip->ep_list);
 690         return 0;
 691 }
 692
 693 /* Set up syncinterval and maxsyncsize for a sync EP */
 694 static void endpoint_set_syncinterval(struct snd_usb_audio *chip,
 695                                       struct snd_usb_endpoint *ep)
 696 {
 697         struct usb_host_interface *alts;
 698         struct usb_endpoint_descriptor *desc;
 699
 700         alts = snd_usb_get_host_interface(chip, ep->iface, ep->altsetting);
 701         if (!alts)
 702                 return;
 703
 704         desc = get_endpoint(alts, ep->ep_idx);
 705         if (desc->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
 706             desc->bRefresh >= 1 && desc->bRefresh <= 9)
 707                 ep->syncinterval = desc->bRefresh;
 708         else if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL)
 709                 ep->syncinterval = 1;
 710         else if (desc->bInterval >= 1 && desc->bInterval <= 16)
 711                 ep->syncinterval = desc->bInterval - 1;
 712         else
 713                 ep->syncinterval = 3;
 714
 715         ep->syncmaxsize = le16_to_cpu(desc->wMaxPacketSize);
 716 }
 717
 718 static bool endpoint_compatible(struct snd_usb_endpoint *ep,
 719                                 const struct audioformat *fp,
 720                                 const struct snd_pcm_hw_params *params)
 721 {
 722         if (!ep->opened)
 723                 return false;
 724         if (ep->cur_audiofmt != fp)
 725                 return false;
 726         if (ep->cur_rate != params_rate(params) ||
 727             ep->cur_format != params_format(params) ||
 728             ep->cur_period_frames != params_period_size(params) ||
 729             ep->cur_buffer_periods != params_periods(params))
 730                 return false;
 731         return true;
 732 }
 733
 734 /*
 735  * Check whether the given fp and hw params are compatible with the current
 736  * setup of the target EP for implicit feedback sync
 737  */
 738 bool snd_usb_endpoint_compatible(struct snd_usb_audio *chip,
 739                                  struct snd_usb_endpoint *ep,
 740                                  const struct audioformat *fp,
 741                                  const struct snd_pcm_hw_params *params)
 742 {
 743         bool ret;
 744
 745         mutex_lock(&chip->mutex);
 746         ret = endpoint_compatible(ep, fp, params);
 747         mutex_unlock(&chip->mutex);
 748         return ret;
 749 }
 750
 751 /*
 752  * snd_usb_endpoint_open: Open the endpoint
 753  *
 754  * Called from hw_params to assign the endpoint to the substream.
 755  * It's reference-counted, and only the first opener is allowed to set up
 756  * arbitrary parameters.  The later opener must be compatible with the
 757  * former opened parameters.
 758  * The endpoint needs to be closed via snd_usb_endpoint_close() later.
 759  *
 760  * Note that this function doesn't configure the endpoint.  The substream
 761  * needs to set it up later via snd_usb_endpoint_configure().
 762  */
 763 struct snd_usb_endpoint *
 764 snd_usb_endpoint_open(struct snd_usb_audio *chip,
 765                       const struct audioformat *fp,
 766                       const struct snd_pcm_hw_params *params,
 767                       bool is_sync_ep)
 768 {
 769         struct snd_usb_endpoint *ep;
 770         int ep_num = is_sync_ep ? fp->sync_ep : fp->endpoint;
 771
 772         mutex_lock(&chip->mutex);
 773         ep = snd_usb_get_endpoint(chip, ep_num);
 774         if (!ep) {
 775                 usb_audio_err(chip, "Cannot find EP 0x%x to open\n", ep_num);
 776                 goto unlock;
 777         }
 778
 779         if (!ep->opened) {
 780                 if (is_sync_ep) {
 781                         ep->iface = fp->sync_iface;
 782                         ep->altsetting = fp->sync_altsetting;
 783                         ep->ep_idx = fp->sync_ep_idx;
 784                 } else {
 785                         ep->iface = fp->iface;
 786                         ep->altsetting = fp->altsetting;
 787                         ep->ep_idx = fp->ep_idx;
 788                 }
 789                 usb_audio_dbg(chip, "Open EP 0x%x, iface=%d:%d, idx=%d\n",
 790                               ep_num, ep->iface, ep->altsetting, ep->ep_idx);
 791
 792                 ep->iface_ref = iface_ref_find(chip, ep->iface);
 793                 if (!ep->iface_ref) {
 794                         ep = NULL;
 795                         goto unlock;
 796                 }
 797
 798                 if (fp->protocol != UAC_VERSION_1) {
 799                         ep->clock_ref = clock_ref_find(chip, fp->clock);
 800                         if (!ep->clock_ref) {
 801                                 ep = NULL;
 802                                 goto unlock;
 803                         }
 804                 }
 805
 806                 ep->cur_audiofmt = fp;
 807                 ep->cur_channels = fp->channels;
 808                 ep->cur_rate = params_rate(params);
 809                 ep->cur_format = params_format(params);
 810                 ep->cur_frame_bytes = snd_pcm_format_physical_width(ep->cur_format) *
 811                         ep->cur_channels / 8;
 812                 ep->cur_period_frames = params_period_size(params);
 813                 ep->cur_period_bytes = ep->cur_period_frames * ep->cur_frame_bytes;
 814                 ep->cur_buffer_periods = params_periods(params);
 815
 816                 if (ep->type == SND_USB_ENDPOINT_TYPE_SYNC)
 817                         endpoint_set_syncinterval(chip, ep);
 818
 819                 ep->implicit_fb_sync = fp->implicit_fb;
 820                 ep->need_setup = true;
 821
 822                 usb_audio_dbg(chip, "  channels=%d, rate=%d, format=%s, period_bytes=%d, periods=%d, implicit_fb=%d\n",
 823                               ep->cur_channels, ep->cur_rate,
 824                               snd_pcm_format_name(ep->cur_format),
 825                               ep->cur_period_bytes, ep->cur_buffer_periods,
 826                               ep->implicit_fb_sync);
 827
 828         } else {
 829                 if (WARN_ON(!ep->iface_ref)) {
 830                         ep = NULL;
 831                         goto unlock;
 832                 }
 833
 834                 if (!endpoint_compatible(ep, fp, params)) {
 835                         usb_audio_err(chip, "Incompatible EP setup for 0x%x\n",
 836                                       ep_num);
 837                         ep = NULL;
 838                         goto unlock;
 839                 }
 840
 841                 usb_audio_dbg(chip, "Reopened EP 0x%x (count %d)\n",
 842                               ep_num, ep->opened);
 843         }
 844
 845         if (!ep->iface_ref->opened++)
 846                 ep->iface_ref->need_setup = true;
 847
 848         ep->opened++;
 849
 850  unlock:
 851         mutex_unlock(&chip->mutex);
 852         return ep;
 853 }
 854
 855 /*
 856  * snd_usb_endpoint_set_sync: Link data and sync endpoints
 857  *
 858  * Pass NULL to sync_ep to unlink again
 859  */
 860 void snd_usb_endpoint_set_sync(struct snd_usb_audio *chip,
 861                                struct snd_usb_endpoint *data_ep,
 862                                struct snd_usb_endpoint *sync_ep)
 863 {
 864         data_ep->sync_source = sync_ep;
 865 }
 866
 867 /*
 868  * Set data endpoint callbacks and the assigned data stream
 869  *
 870  * Called at PCM trigger and cleanups.
 871  * Pass NULL to deactivate each callback.
 872  */
 873 void snd_usb_endpoint_set_callback(struct snd_usb_endpoint *ep,
 874                                    int (*prepare)(struct snd_usb_substream *subs,
 875                                                   struct urb *urb,
 876                                                   bool in_stream_lock),
 877                                    void (*retire)(struct snd_usb_substream *subs,
 878                                                   struct urb *urb),
 879                                    struct snd_usb_substream *data_subs)
 880 {
 881         ep->prepare_data_urb = prepare;
 882         ep->retire_data_urb = retire;
 883         if (data_subs)
 884                 ep->lowlatency_playback = data_subs->lowlatency_playback;
 885         else
 886                 ep->lowlatency_playback = false;
 887         WRITE_ONCE(ep->data_subs, data_subs);
 888 }
 889
 890 static int endpoint_set_interface(struct snd_usb_audio *chip,
 891                                   struct snd_usb_endpoint *ep,
 892                                   bool set)
 893 {
 894         int altset = set ? ep->altsetting : 0;
 895         int err;
 896
 897         usb_audio_dbg(chip, "Setting usb interface %d:%d for EP 0x%x\n",
 898                       ep->iface, altset, ep->ep_num);
 899         err = usb_set_interface(chip->dev, ep->iface, altset);
 900         if (err < 0) {
 901                 usb_audio_err(chip, "%d:%d: usb_set_interface failed (%d)\n",
 902                               ep->iface, altset, err);
 903                 return err;
 904         }
 905
 906         if (chip->quirk_flags & QUIRK_FLAG_IFACE_DELAY)
 907                 msleep(50);
 908         return 0;
 909 }
 910
 911 /*
 912  * snd_usb_endpoint_close: Close the endpoint
 913  *
 914  * Unreference the already opened endpoint via snd_usb_endpoint_open().
 915  */
 916 void snd_usb_endpoint_close(struct snd_usb_audio *chip,
 917                             struct snd_usb_endpoint *ep)
 918 {
 919         mutex_lock(&chip->mutex);
 920         usb_audio_dbg(chip, "Closing EP 0x%x (count %d)\n",
 921                       ep->ep_num, ep->opened);
 922
 923         if (!--ep->iface_ref->opened)
 924                 endpoint_set_interface(chip, ep, false);
 925
 926         if (!--ep->opened) {
 927                 ep->iface = 0;
 928                 ep->altsetting = 0;
 929                 ep->cur_audiofmt = NULL;
 930                 ep->cur_rate = 0;
 931                 ep->iface_ref = NULL;
 932                 ep->clock_ref = NULL;
 933                 usb_audio_dbg(chip, "EP 0x%x closed\n", ep->ep_num);
 934         }
 935         mutex_unlock(&chip->mutex);
 936 }
 937
 938 /* Prepare for suspening EP, called from the main suspend handler */
 939 void snd_usb_endpoint_suspend(struct snd_usb_endpoint *ep)
 940 {
 941         ep->need_setup = true;
 942         if (ep->iface_ref)
 943                 ep->iface_ref->need_setup = true;
 944         if (ep->clock_ref)
 945                 ep->clock_ref->rate = 0;
 946 }
 947
 948 /*
 949  *  wait until all urbs are processed.
 950  */
 951 static int wait_clear_urbs(struct snd_usb_endpoint *ep)
 952 {
 953         unsigned long end_time = jiffies + msecs_to_jiffies(1000);
 954         int alive;
 955
 956         if (atomic_read(&ep->state) != EP_STATE_STOPPING)
 957                 return 0;
 958
 959         do {
 960                 alive = atomic_read(&ep->submitted_urbs);
 961                 if (!alive)
 962                         break;
 963
 964                 schedule_timeout_uninterruptible(1);
 965         } while (time_before(jiffies, end_time));
 966
 967         if (alive)
 968                 usb_audio_err(ep->chip,
 969                         "timeout: still %d active urbs on EP #%x\n",
 970                         alive, ep->ep_num);
 971
 972         if (ep_state_update(ep, EP_STATE_STOPPING, EP_STATE_STOPPED)) {
 973                 ep->sync_sink = NULL;
 974                 snd_usb_endpoint_set_callback(ep, NULL, NULL, NULL);
 975         }
 976
 977         return 0;
 978 }
 979
 980 /* sync the pending stop operation;
 981  * this function itself doesn't trigger the stop operation
 982  */
 983 void snd_usb_endpoint_sync_pending_stop(struct snd_usb_endpoint *ep)
 984 {
 985         if (ep)
 986                 wait_clear_urbs(ep);
 987 }
 988
 989 /*
 990  * Stop active urbs
 991  *
 992  * This function moves the EP to STOPPING state if it's being RUNNING.
 993  */
 994 static int stop_urbs(struct snd_usb_endpoint *ep, bool force, bool keep_pending)
 995 {
 996         unsigned int i;
 997         unsigned long flags;
 998
 999         if (!force && atomic_read(&ep->running))
1000                 return -EBUSY;
1001
1002         if (!ep_state_update(ep, EP_STATE_RUNNING, EP_STATE_STOPPING))
1003                 return 0;
1004
1005         spin_lock_irqsave(&ep->lock, flags);
1006         INIT_LIST_HEAD(&ep->ready_playback_urbs);
1007         ep->next_packet_head = 0;
1008         ep->next_packet_queued = 0;
1009         spin_unlock_irqrestore(&ep->lock, flags);
1010
1011         if (keep_pending)
1012                 return 0;
1013
1014         for (i = 0; i < ep->nurbs; i++) {
1015                 if (test_bit(i, &ep->active_mask)) {
1016                         if (!test_and_set_bit(i, &ep->unlink_mask)) {
1017                                 struct urb *u = ep->urb[i].urb;
1018                                 usb_unlink_urb(u);
1019                         }
1020                 }
1021         }
1022
1023         return 0;
1024 }
1025
1026 /*
1027  * release an endpoint's urbs
1028  */
1029 static int release_urbs(struct snd_usb_endpoint *ep, bool force)
1030 {
1031         int i, err;
1032
1033         /* route incoming urbs to nirvana */
1034         snd_usb_endpoint_set_callback(ep, NULL, NULL, NULL);
1035
1036         /* stop and unlink urbs */
1037         err = stop_urbs(ep, force, false);
1038         if (err)
1039                 return err;
1040
1041         wait_clear_urbs(ep);
1042
1043         for (i = 0; i < ep->nurbs; i++)
1044                 release_urb_ctx(&ep->urb[i]);
1045
1046         usb_free_coherent(ep->chip->dev, SYNC_URBS * 4,
1047                           ep->syncbuf, ep->sync_dma);
1048
1049         ep->syncbuf = NULL;
1050         ep->nurbs = 0;
1051         return 0;
1052 }
1053
1054 /*
1055  * configure a data endpoint
1056  */
1057 static int data_ep_set_params(struct snd_usb_endpoint *ep)
1058 {
1059         struct snd_usb_audio *chip = ep->chip;
1060         unsigned int maxsize, minsize, packs_per_ms, max_packs_per_urb;
1061         unsigned int max_packs_per_period, urbs_per_period, urb_packs;
1062         unsigned int max_urbs, i;
1063         const struct audioformat *fmt = ep->cur_audiofmt;
1064         int frame_bits = ep->cur_frame_bytes * 8;
1065         int tx_length_quirk = (has_tx_length_quirk(chip) &&
1066                                usb_pipeout(ep->pipe));
1067
1068         usb_audio_dbg(chip, "Setting params for data EP 0x%x, pipe 0x%x\n",
1069                       ep->ep_num, ep->pipe);
1070
1071         if (ep->cur_format == SNDRV_PCM_FORMAT_DSD_U16_LE && fmt->dsd_dop) {
1072                 /*
1073                  * When operating in DSD DOP mode, the size of a sample frame
1074                  * in hardware differs from the actual physical format width
1075                  * because we need to make room for the DOP markers.
1076                  */
1077                 frame_bits += ep->cur_channels << 3;
1078         }
1079
1080         ep->datainterval = fmt->datainterval;
1081         ep->stride = frame_bits >> 3;
1082
1083         switch (ep->cur_format) {
1084         case SNDRV_PCM_FORMAT_U8:
1085                 ep->silence_value = 0x80;
1086                 break;
1087         case SNDRV_PCM_FORMAT_DSD_U8:
1088         case SNDRV_PCM_FORMAT_DSD_U16_LE:
1089         case SNDRV_PCM_FORMAT_DSD_U32_LE:
1090         case SNDRV_PCM_FORMAT_DSD_U16_BE:
1091         case SNDRV_PCM_FORMAT_DSD_U32_BE:
1092                 ep->silence_value = 0x69;
1093                 break;
1094         default:
1095                 ep->silence_value = 0;
1096         }
1097
1098         /* assume max. frequency is 50% higher than nominal */
1099         ep->freqmax = ep->freqn + (ep->freqn >> 1);
1100         /* Round up freqmax to nearest integer in order to calculate maximum
1101          * packet size, which must represent a whole number of frames.
1102          * This is accomplished by adding 0x0.ffff before converting the
1103          * Q16.16 format into integer.
1104          * In order to accurately calculate the maximum packet size when
1105          * the data interval is more than 1 (i.e. ep->datainterval > 0),
1106          * multiply by the data interval prior to rounding. For instance,
1107          * a freqmax of 41 kHz will result in a max packet size of 6 (5.125)
1108          * frames with a data interval of 1, but 11 (10.25) frames with a
1109          * data interval of 2.
1110          * (ep->freqmax << ep->datainterval overflows at 8.192 MHz for the
1111          * maximum datainterval value of 3, at USB full speed, higher for
1112          * USB high speed, noting that ep->freqmax is in units of
1113          * frames per packet in Q16.16 format.)
1114          */
1115         maxsize = (((ep->freqmax << ep->datainterval) + 0xffff) >> 16) *
1116                          (frame_bits >> 3);
1117         if (tx_length_quirk)
1118                 maxsize += sizeof(__le32); /* Space for length descriptor */
1119         /* but wMaxPacketSize might reduce this */
1120         if (ep->maxpacksize && ep->maxpacksize < maxsize) {
1121                 /* whatever fits into a max. size packet */
1122                 unsigned int data_maxsize = maxsize = ep->maxpacksize;
1123
1124                 if (tx_length_quirk)
1125                         /* Need to remove the length descriptor to calc freq */
1126                         data_maxsize -= sizeof(__le32);
1127                 ep->freqmax = (data_maxsize / (frame_bits >> 3))
1128                                 << (16 - ep->datainterval);
1129         }
1130
1131         if (ep->fill_max)
1132                 ep->curpacksize = ep->maxpacksize;
1133         else
1134                 ep->curpacksize = maxsize;
1135
1136         if (snd_usb_get_speed(chip->dev) != USB_SPEED_FULL) {
1137                 packs_per_ms = 8 >> ep->datainterval;
1138                 max_packs_per_urb = MAX_PACKS_HS;
1139         } else {
1140                 packs_per_ms = 1;
1141                 max_packs_per_urb = MAX_PACKS;
1142         }
1143         if (ep->sync_source && !ep->implicit_fb_sync)
1144                 max_packs_per_urb = min(max_packs_per_urb,
1145                                         1U << ep->sync_source->syncinterval);
1146         max_packs_per_urb = max(1u, max_packs_per_urb >> ep->datainterval);
1147
1148         /*
1149          * Capture endpoints need to use small URBs because there's no way
1150          * to tell in advance where the next period will end, and we don't
1151          * want the next URB to complete much after the period ends.
1152          *
1153          * Playback endpoints with implicit sync much use the same parameters
1154          * as their corresponding capture endpoint.
1155          */
1156         if (usb_pipein(ep->pipe) || ep->implicit_fb_sync) {
1157
1158                 urb_packs = packs_per_ms;
1159                 /*
1160                  * Wireless devices can poll at a max rate of once per 4ms.
1161                  * For dataintervals less than 5, increase the packet count to
1162                  * allow the host controller to use bursting to fill in the
1163                  * gaps.
1164                  */
1165                 if (snd_usb_get_speed(chip->dev) == USB_SPEED_WIRELESS) {
1166                         int interval = ep->datainterval;
1167                         while (interval < 5) {
1168                                 urb_packs <<= 1;
1169                                 ++interval;
1170                         }
1171                 }
1172                 /* make capture URBs <= 1 ms and smaller than a period */
1173                 urb_packs = min(max_packs_per_urb, urb_packs);
1174                 while (urb_packs > 1 && urb_packs * maxsize >= ep->cur_period_bytes)
1175                         urb_packs >>= 1;
1176                 ep->nurbs = MAX_URBS;
1177
1178         /*
1179          * Playback endpoints without implicit sync are adjusted so that
1180          * a period fits as evenly as possible in the smallest number of
1181          * URBs.  The total number of URBs is adjusted to the size of the
1182          * ALSA buffer, subject to the MAX_URBS and MAX_QUEUE limits.
1183          */
1184         } else {
1185                 /* determine how small a packet can be */
1186                 minsize = (ep->freqn >> (16 - ep->datainterval)) *
1187                                 (frame_bits >> 3);
1188                 /* with sync from device, assume it can be 12% lower */
1189                 if (ep->sync_source)
1190                         minsize -= minsize >> 3;
1191                 minsize = max(minsize, 1u);
1192
1193                 /* how many packets will contain an entire ALSA period? */
1194                 max_packs_per_period = DIV_ROUND_UP(ep->cur_period_bytes, minsize);
1195
1196                 /* how many URBs will contain a period? */
1197                 urbs_per_period = DIV_ROUND_UP(max_packs_per_period,
1198                                 max_packs_per_urb);
1199                 /* how many packets are needed in each URB? */
1200                 urb_packs = DIV_ROUND_UP(max_packs_per_period, urbs_per_period);
1201
1202                 /* limit the number of frames in a single URB */
1203                 ep->max_urb_frames = DIV_ROUND_UP(ep->cur_period_frames,
1204                                                   urbs_per_period);
1205
1206                 /* try to use enough URBs to contain an entire ALSA buffer */
1207                 max_urbs = min((unsigned) MAX_URBS,
1208                                 MAX_QUEUE * packs_per_ms / urb_packs);
1209                 ep->nurbs = min(max_urbs, urbs_per_period * ep->cur_buffer_periods);
1210         }
1211
1212         /* allocate and initialize data urbs */
1213         for (i = 0; i < ep->nurbs; i++) {
1214                 struct snd_urb_ctx *u = &ep->urb[i];
1215                 u->index = i;
1216                 u->ep = ep;
1217                 u->packets = urb_packs;
1218                 u->buffer_size = maxsize * u->packets;
1219
1220                 if (fmt->fmt_type == UAC_FORMAT_TYPE_II)
1221                         u->packets++; /* for transfer delimiter */
1222                 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
1223                 if (!u->urb)
1224                         goto out_of_memory;
1225
1226                 u->urb->transfer_buffer =
1227                         usb_alloc_coherent(chip->dev, u->buffer_size,
1228                                            GFP_KERNEL, &u->urb->transfer_dma);
1229                 if (!u->urb->transfer_buffer)
1230                         goto out_of_memory;
1231                 u->urb->pipe = ep->pipe;
1232                 u->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
1233                 u->urb->interval = 1 << ep->datainterval;
1234                 u->urb->context = u;
1235                 u->urb->complete = snd_complete_urb;
1236                 INIT_LIST_HEAD(&u->ready_list);
1237         }
1238
1239         return 0;
1240
1241 out_of_memory:
1242         release_urbs(ep, false);
1243         return -ENOMEM;
1244 }
1245
1246 /*
1247  * configure a sync endpoint
1248  */
1249 static int sync_ep_set_params(struct snd_usb_endpoint *ep)
1250 {
1251         struct snd_usb_audio *chip = ep->chip;
1252         int i;
1253
1254         usb_audio_dbg(chip, "Setting params for sync EP 0x%x, pipe 0x%x\n",
1255                       ep->ep_num, ep->pipe);
1256
1257         ep->syncbuf = usb_alloc_coherent(chip->dev, SYNC_URBS * 4,
1258                                          GFP_KERNEL, &ep->sync_dma);
1259         if (!ep->syncbuf)
1260                 return -ENOMEM;
1261
1262         for (i = 0; i < SYNC_URBS; i++) {
1263                 struct snd_urb_ctx *u = &ep->urb[i];
1264                 u->index = i;
1265                 u->ep = ep;
1266                 u->packets = 1;
1267                 u->urb = usb_alloc_urb(1, GFP_KERNEL);
1268                 if (!u->urb)
1269                         goto out_of_memory;
1270                 u->urb->transfer_buffer = ep->syncbuf + i * 4;
1271                 u->urb->transfer_dma = ep->sync_dma + i * 4;
1272                 u->urb->transfer_buffer_length = 4;
1273                 u->urb->pipe = ep->pipe;
1274                 u->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
1275                 u->urb->number_of_packets = 1;
1276                 u->urb->interval = 1 << ep->syncinterval;
1277                 u->urb->context = u;
1278                 u->urb->complete = snd_complete_urb;
1279         }
1280
1281         ep->nurbs = SYNC_URBS;
1282
1283         return 0;
1284
1285 out_of_memory:
1286         release_urbs(ep, false);
1287         return -ENOMEM;
1288 }
1289
1290 /*
1291  * snd_usb_endpoint_set_params: configure an snd_usb_endpoint
1292  *
1293  * Determine the number of URBs to be used on this endpoint.
1294  * An endpoint must be configured before it can be started.
1295  * An endpoint that is already running can not be reconfigured.
1296  */
1297 static int snd_usb_endpoint_set_params(struct snd_usb_audio *chip,
1298                                        struct snd_usb_endpoint *ep)
1299 {
1300         const struct audioformat *fmt = ep->cur_audiofmt;
1301         int err;
1302
1303         /* release old buffers, if any */
1304         err = release_urbs(ep, false);
1305         if (err < 0)
1306                 return err;
1307
1308         ep->datainterval = fmt->datainterval;
1309         ep->maxpacksize = fmt->maxpacksize;
1310         ep->fill_max = !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX);
1311
1312         if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL) {
1313                 ep->freqn = get_usb_full_speed_rate(ep->cur_rate);
1314                 ep->pps = 1000 >> ep->datainterval;
1315         } else {
1316                 ep->freqn = get_usb_high_speed_rate(ep->cur_rate);
1317                 ep->pps = 8000 >> ep->datainterval;
1318         }
1319
1320         ep->sample_rem = ep->cur_rate % ep->pps;
1321         ep->packsize[0] = ep->cur_rate / ep->pps;
1322         ep->packsize[1] = (ep->cur_rate + (ep->pps - 1)) / ep->pps;
1323
1324         /* calculate the frequency in 16.16 format */
1325         ep->freqm = ep->freqn;
1326         ep->freqshift = INT_MIN;
1327
1328         ep->phase = 0;
1329
1330         switch (ep->type) {
1331         case  SND_USB_ENDPOINT_TYPE_DATA:
1332                 err = data_ep_set_params(ep);
1333                 break;
1334         case  SND_USB_ENDPOINT_TYPE_SYNC:
1335                 err = sync_ep_set_params(ep);
1336                 break;
1337         default:
1338                 err = -EINVAL;
1339         }
1340
1341         usb_audio_dbg(chip, "Set up %d URBS, ret=%d\n", ep->nurbs, err);
1342
1343         if (err < 0)
1344                 return err;
1345
1346         /* some unit conversions in runtime */
1347         ep->maxframesize = ep->maxpacksize / ep->cur_frame_bytes;
1348         ep->curframesize = ep->curpacksize / ep->cur_frame_bytes;
1349
1350         return 0;
1351 }
1352
1353 static int init_sample_rate(struct snd_usb_audio *chip,
1354                             struct snd_usb_endpoint *ep)
1355 {
1356         struct snd_usb_clock_ref *clock = ep->clock_ref;
1357         int err;
1358
1359         if (clock) {
1360                 if (atomic_read(&clock->locked))
1361                         return 0;
1362                 if (clock->rate == ep->cur_rate)
1363                         return 0;
1364                 if (clock->rate && clock->rate != ep->cur_rate) {
1365                         usb_audio_dbg(chip, "Mismatched sample rate %d vs %d for EP 0x%x\n",
1366                                       clock->rate, ep->cur_rate, ep->ep_num);
1367                         return -EINVAL;
1368                 }
1369         }
1370
1371         err = snd_usb_init_sample_rate(chip, ep->cur_audiofmt, ep->cur_rate);
1372         if (err < 0)
1373                 return err;
1374
1375         if (clock)
1376                 clock->rate = ep->cur_rate;
1377         return 0;
1378 }
1379
1380 /*
1381  * snd_usb_endpoint_configure: Configure the endpoint
1382  *
1383  * This function sets up the EP to be fully usable state.
1384  * It's called either from hw_params or prepare callback.
1385  * The function checks need_setup flag, and performs nothing unless needed,
1386  * so it's safe to call this multiple times.
1387  *
1388  * This returns zero if unchanged, 1 if the configuration has changed,
1389  * or a negative error code.
1390  */
1391 int snd_usb_endpoint_configure(struct snd_usb_audio *chip,
1392                                struct snd_usb_endpoint *ep)
1393 {
1394         bool iface_first;
1395         int err = 0;
1396
1397         mutex_lock(&chip->mutex);
1398         if (WARN_ON(!ep->iface_ref))
1399                 goto unlock;
1400         if (!ep->need_setup)
1401                 goto unlock;
1402
1403         /* If the interface has been already set up, just set EP parameters */
1404         if (!ep->iface_ref->need_setup) {
1405                 /* sample rate setup of UAC1 is per endpoint, and we need
1406                  * to update at each EP configuration
1407                  */
1408                 if (ep->cur_audiofmt->protocol == UAC_VERSION_1) {
1409                         err = init_sample_rate(chip, ep);
1410                         if (err < 0)
1411                                 goto unlock;
1412                 }
1413                 err = snd_usb_endpoint_set_params(chip, ep);
1414                 if (err < 0)
1415                         goto unlock;
1416                 goto done;
1417         }
1418
1419         /* Need to deselect altsetting at first */
1420         endpoint_set_interface(chip, ep, false);
1421
1422         /* Some UAC1 devices (e.g. Yamaha THR10) need the host interface
1423          * to be set up before parameter setups
1424          */
1425         iface_first = ep->cur_audiofmt->protocol == UAC_VERSION_1;
1426         /* Workaround for devices that require the interface setup at first like UAC1 */
1427         if (chip->quirk_flags & QUIRK_FLAG_SET_IFACE_FIRST)
1428                 iface_first = true;
1429         if (iface_first) {
1430                 err = endpoint_set_interface(chip, ep, true);
1431                 if (err < 0)
1432                         goto unlock;
1433         }
1434
1435         err = snd_usb_init_pitch(chip, ep->cur_audiofmt);
1436         if (err < 0)
1437                 goto unlock;
1438
1439         err = init_sample_rate(chip, ep);
1440         if (err < 0)
1441                 goto unlock;
1442
1443         err = snd_usb_endpoint_set_params(chip, ep);
1444         if (err < 0)
1445                 goto unlock;
1446
1447         err = snd_usb_select_mode_quirk(chip, ep->cur_audiofmt);
1448         if (err < 0)
1449                 goto unlock;
1450
1451         /* for UAC2/3, enable the interface altset here at last */
1452         if (!iface_first) {
1453                 err = endpoint_set_interface(chip, ep, true);
1454                 if (err < 0)
1455                         goto unlock;
1456         }
1457
1458         ep->iface_ref->need_setup = false;
1459
1460  done:
1461         ep->need_setup = false;
1462         err = 1;
1463
1464 unlock:
1465         mutex_unlock(&chip->mutex);
1466         return err;
1467 }
1468
1469 /* get the current rate set to the given clock by any endpoint */
1470 int snd_usb_endpoint_get_clock_rate(struct snd_usb_audio *chip, int clock)
1471 {
1472         struct snd_usb_clock_ref *ref;
1473         int rate = 0;
1474
1475         if (!clock)
1476                 return 0;
1477         mutex_lock(&chip->mutex);
1478         list_for_each_entry(ref, &chip->clock_ref_list, list) {
1479                 if (ref->clock == clock) {
1480                         rate = ref->rate;
1481                         break;
1482                 }
1483         }
1484         mutex_unlock(&chip->mutex);
1485         return rate;
1486 }
1487
1488 /**
1489  * snd_usb_endpoint_start: start an snd_usb_endpoint
1490  *
1491  * @ep: the endpoint to start
1492  *
1493  * A call to this function will increment the running count of the endpoint.
1494  * In case it is not already running, the URBs for this endpoint will be
1495  * submitted. Otherwise, this function does nothing.
1496  *
1497  * Must be balanced to calls of snd_usb_endpoint_stop().
1498  *
1499  * Returns an error if the URB submission failed, 0 in all other cases.
1500  */
1501 int snd_usb_endpoint_start(struct snd_usb_endpoint *ep)
1502 {
1503         bool is_playback = usb_pipeout(ep->pipe);
1504         int err;
1505         unsigned int i;
1506
1507         if (atomic_read(&ep->chip->shutdown))
1508                 return -EBADFD;
1509
1510         if (ep->sync_source)
1511                 WRITE_ONCE(ep->sync_source->sync_sink, ep);
1512
1513         usb_audio_dbg(ep->chip, "Starting %s EP 0x%x (running %d)\n",
1514                       ep_type_name(ep->type), ep->ep_num,
1515                       atomic_read(&ep->running));
1516
1517         /* already running? */
1518         if (atomic_inc_return(&ep->running) != 1)
1519                 return 0;
1520
1521         if (ep->clock_ref)
1522                 atomic_inc(&ep->clock_ref->locked);
1523
1524         ep->active_mask = 0;
1525         ep->unlink_mask = 0;
1526         ep->phase = 0;
1527         ep->sample_accum = 0;
1528
1529         snd_usb_endpoint_start_quirk(ep);
1530
1531         /*
1532          * If this endpoint has a data endpoint as implicit feedback source,
1533          * don't start the urbs here. Instead, mark them all as available,
1534          * wait for the record urbs to return and queue the playback urbs
1535          * from that context.
1536          */
1537
1538         if (!ep_state_update(ep, EP_STATE_STOPPED, EP_STATE_RUNNING))
1539                 goto __error;
1540
1541         if (snd_usb_endpoint_implicit_feedback_sink(ep) &&
1542             !(ep->chip->quirk_flags & QUIRK_FLAG_PLAYBACK_FIRST)) {
1543                 usb_audio_dbg(ep->chip, "No URB submission due to implicit fb sync\n");
1544                 i = 0;
1545                 goto fill_rest;
1546         }
1547
1548         for (i = 0; i < ep->nurbs; i++) {
1549                 struct urb *urb = ep->urb[i].urb;
1550
1551                 if (snd_BUG_ON(!urb))
1552                         goto __error;
1553
1554                 if (is_playback)
1555                         err = prepare_outbound_urb(ep, urb->context, true);
1556                 else
1557                         err = prepare_inbound_urb(ep, urb->context);
1558                 if (err < 0) {
1559                         /* stop filling at applptr */
1560                         if (err == -EAGAIN)
1561                                 break;
1562                         usb_audio_dbg(ep->chip,
1563                                       "EP 0x%x: failed to prepare urb: %d\n",
1564                                       ep->ep_num, err);
1565                         goto __error;
1566                 }
1567
1568                 err = usb_submit_urb(urb, GFP_ATOMIC);
1569                 if (err < 0) {
1570                         usb_audio_err(ep->chip,
1571                                 "cannot submit urb %d, error %d: %s\n",
1572                                 i, err, usb_error_string(err));
1573                         goto __error;
1574                 }
1575                 set_bit(i, &ep->active_mask);
1576                 atomic_inc(&ep->submitted_urbs);
1577         }
1578
1579         if (!i) {
1580                 usb_audio_dbg(ep->chip, "XRUN at starting EP 0x%x\n",
1581                               ep->ep_num);
1582                 goto __error;
1583         }
1584
1585         usb_audio_dbg(ep->chip, "%d URBs submitted for EP 0x%x\n",
1586                       i, ep->ep_num);
1587
1588  fill_rest:
1589         /* put the remaining URBs to ready list */
1590         if (is_playback) {
1591                 for (; i < ep->nurbs; i++)
1592                         push_back_to_ready_list(ep, ep->urb + i);
1593         }
1594
1595         return 0;
1596
1597 __error:
1598         snd_usb_endpoint_stop(ep, false);
1599         return -EPIPE;
1600 }
1601
1602 /**
1603  * snd_usb_endpoint_stop: stop an snd_usb_endpoint
1604  *
1605  * @ep: the endpoint to stop (may be NULL)
1606  * @keep_pending: keep in-flight URBs
1607  *
1608  * A call to this function will decrement the running count of the endpoint.
1609  * In case the last user has requested the endpoint stop, the URBs will
1610  * actually be deactivated.
1611  *
1612  * Must be balanced to calls of snd_usb_endpoint_start().
1613  *
1614  * The caller needs to synchronize the pending stop operation via
1615  * snd_usb_endpoint_sync_pending_stop().
1616  */
1617 void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep, bool keep_pending)
1618 {
1619         if (!ep)
1620                 return;
1621
1622         usb_audio_dbg(ep->chip, "Stopping %s EP 0x%x (running %d)\n",
1623                       ep_type_name(ep->type), ep->ep_num,
1624                       atomic_read(&ep->running));
1625
1626         if (snd_BUG_ON(!atomic_read(&ep->running)))
1627                 return;
1628
1629         if (!atomic_dec_return(&ep->running)) {
1630                 if (ep->sync_source)
1631                         WRITE_ONCE(ep->sync_source->sync_sink, NULL);
1632                 stop_urbs(ep, false, keep_pending);
1633                 if (ep->clock_ref)
1634                         if (!atomic_dec_return(&ep->clock_ref->locked))
1635                                 ep->clock_ref->rate = 0;
1636         }
1637 }
1638
1639 /**
1640  * snd_usb_endpoint_release: Tear down an snd_usb_endpoint
1641  *
1642  * @ep: the endpoint to release
1643  *
1644  * This function does not care for the endpoint's running count but will tear
1645  * down all the streaming URBs immediately.
1646  */
1647 void snd_usb_endpoint_release(struct snd_usb_endpoint *ep)
1648 {
1649         release_urbs(ep, true);
1650 }
1651
1652 /**
1653  * snd_usb_endpoint_free_all: Free the resources of an snd_usb_endpoint
1654  * @chip: The chip
1655  *
1656  * This free all endpoints and those resources
1657  */
1658 void snd_usb_endpoint_free_all(struct snd_usb_audio *chip)
1659 {
1660         struct snd_usb_endpoint *ep, *en;
1661         struct snd_usb_iface_ref *ip, *in;
1662         struct snd_usb_clock_ref *cp, *cn;
1663
1664         list_for_each_entry_safe(ep, en, &chip->ep_list, list)
1665                 kfree(ep);
1666
1667         list_for_each_entry_safe(ip, in, &chip->iface_ref_list, list)
1668                 kfree(ip);
1669
1670         list_for_each_entry_safe(cp, cn, &chip->clock_ref_list, list)
1671                 kfree(cp);
1672 }
1673
1674 /*
1675  * snd_usb_handle_sync_urb: parse an USB sync packet
1676  *
1677  * @ep: the endpoint to handle the packet
1678  * @sender: the sending endpoint
1679  * @urb: the received packet
1680  *
1681  * This function is called from the context of an endpoint that received
1682  * the packet and is used to let another endpoint object handle the payload.
1683  */
1684 static void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
1685                                     struct snd_usb_endpoint *sender,
1686                                     const struct urb *urb)
1687 {
1688         int shift;
1689         unsigned int f;
1690         unsigned long flags;
1691
1692         snd_BUG_ON(ep == sender);
1693
1694         /*
1695          * In case the endpoint is operating in implicit feedback mode, prepare
1696          * a new outbound URB that has the same layout as the received packet
1697          * and add it to the list of pending urbs. queue_pending_output_urbs()
1698          * will take care of them later.
1699          */
1700         if (snd_usb_endpoint_implicit_feedback_sink(ep) &&
1701             atomic_read(&ep->running)) {
1702
1703                 /* implicit feedback case */
1704                 int i, bytes = 0;
1705                 struct snd_urb_ctx *in_ctx;
1706                 struct snd_usb_packet_info *out_packet;
1707
1708                 in_ctx = urb->context;
1709
1710                 /* Count overall packet size */
1711                 for (i = 0; i < in_ctx->packets; i++)
1712                         if (urb->iso_frame_desc[i].status == 0)
1713                                 bytes += urb->iso_frame_desc[i].actual_length;
1714
1715                 /*
1716                  * skip empty packets. At least M-Audio's Fast Track Ultra stops
1717                  * streaming once it received a 0-byte OUT URB
1718                  */
1719                 if (bytes == 0)
1720                         return;
1721
1722                 spin_lock_irqsave(&ep->lock, flags);
1723                 if (ep->next_packet_queued >= ARRAY_SIZE(ep->next_packet)) {
1724                         spin_unlock_irqrestore(&ep->lock, flags);
1725                         usb_audio_err(ep->chip,
1726                                       "next package FIFO overflow EP 0x%x\n",
1727                                       ep->ep_num);
1728                         notify_xrun(ep);
1729                         return;
1730                 }
1731
1732                 out_packet = next_packet_fifo_enqueue(ep);
1733
1734                 /*
1735                  * Iterate through the inbound packet and prepare the lengths
1736                  * for the output packet. The OUT packet we are about to send
1737                  * will have the same amount of payload bytes per stride as the
1738                  * IN packet we just received. Since the actual size is scaled
1739                  * by the stride, use the sender stride to calculate the length
1740                  * in case the number of channels differ between the implicitly
1741                  * fed-back endpoint and the synchronizing endpoint.
1742                  */
1743
1744                 out_packet->packets = in_ctx->packets;
1745                 for (i = 0; i < in_ctx->packets; i++) {
1746                         if (urb->iso_frame_desc[i].status == 0)
1747                                 out_packet->packet_size[i] =
1748                                         urb->iso_frame_desc[i].actual_length / sender->stride;
1749                         else
1750                                 out_packet->packet_size[i] = 0;
1751                 }
1752
1753                 spin_unlock_irqrestore(&ep->lock, flags);
1754                 snd_usb_queue_pending_output_urbs(ep, false);
1755
1756                 return;
1757         }
1758
1759         /*
1760          * process after playback sync complete
1761          *
1762          * Full speed devices report feedback values in 10.14 format as samples
1763          * per frame, high speed devices in 16.16 format as samples per
1764          * microframe.
1765          *
1766          * Because the Audio Class 1 spec was written before USB 2.0, many high
1767          * speed devices use a wrong interpretation, some others use an
1768          * entirely different format.
1769          *
1770          * Therefore, we cannot predict what format any particular device uses
1771          * and must detect it automatically.
1772          */
1773
1774         if (urb->iso_frame_desc[0].status != 0 ||
1775             urb->iso_frame_desc[0].actual_length < 3)
1776                 return;
1777
1778         f = le32_to_cpup(urb->transfer_buffer);
1779         if (urb->iso_frame_desc[0].actual_length == 3)
1780                 f &= 0x00ffffff;
1781         else
1782                 f &= 0x0fffffff;
1783
1784         if (f == 0)
1785                 return;
1786
1787         if (unlikely(sender->tenor_fb_quirk)) {
1788                 /*
1789                  * Devices based on Tenor 8802 chipsets (TEAC UD-H01
1790                  * and others) sometimes change the feedback value
1791                  * by +/- 0x1.0000.
1792                  */
1793                 if (f < ep->freqn - 0x8000)
1794                         f += 0xf000;
1795                 else if (f > ep->freqn + 0x8000)
1796                         f -= 0xf000;
1797         } else if (unlikely(ep->freqshift == INT_MIN)) {
1798                 /*
1799                  * The first time we see a feedback value, determine its format
1800                  * by shifting it left or right until it matches the nominal
1801                  * frequency value.  This assumes that the feedback does not
1802                  * differ from the nominal value more than +50% or -25%.
1803                  */
1804                 shift = 0;
1805                 while (f < ep->freqn - ep->freqn / 4) {
1806                         f <<= 1;
1807                         shift++;
1808                 }
1809                 while (f > ep->freqn + ep->freqn / 2) {
1810                         f >>= 1;
1811                         shift--;
1812                 }
1813                 ep->freqshift = shift;
1814         } else if (ep->freqshift >= 0)
1815                 f <<= ep->freqshift;
1816         else
1817                 f >>= -ep->freqshift;
1818
1819         if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) {
1820                 /*
1821                  * If the frequency looks valid, set it.
1822                  * This value is referred to in prepare_playback_urb().
1823                  */
1824                 spin_lock_irqsave(&ep->lock, flags);
1825                 ep->freqm = f;
1826                 spin_unlock_irqrestore(&ep->lock, flags);
1827         } else {
1828                 /*
1829                  * Out of range; maybe the shift value is wrong.
1830                  * Reset it so that we autodetect again the next time.
1831                  */
1832                 ep->freqshift = INT_MIN;
1833         }
1834 }
1835