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