linux/sound/usb/endpoint.c
<<
>>
Prefs
   1/*
   2 *   This program is free software; you can redistribute it and/or modify
   3 *   it under the terms of the GNU General Public License as published by
   4 *   the Free Software Foundation; either version 2 of the License, or
   5 *   (at your option) any later version.
   6 *
   7 *   This program is distributed in the hope that it will be useful,
   8 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10 *   GNU General Public License for more details.
  11 *
  12 *   You should have received a copy of the GNU General Public License
  13 *   along with this program; if not, write to the Free Software
  14 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  15 *
  16 */
  17
  18#include <linux/gfp.h>
  19#include <linux/init.h>
  20#include <linux/ratelimit.h>
  21#include <linux/usb.h>
  22#include <linux/usb/audio.h>
  23#include <linux/slab.h>
  24
  25#include <sound/core.h>
  26#include <sound/pcm.h>
  27#include <sound/pcm_params.h>
  28
  29#include "usbaudio.h"
  30#include "helper.h"
  31#include "card.h"
  32#include "endpoint.h"
  33#include "pcm.h"
  34#include "quirks.h"
  35
  36#define EP_FLAG_ACTIVATED       0
  37#define EP_FLAG_RUNNING         1
  38#define EP_FLAG_STOPPING        2
  39
  40/*
  41 * snd_usb_endpoint is a model that abstracts everything related to an
  42 * USB endpoint and its streaming.
  43 *
  44 * There are functions to activate and deactivate the streaming URBs and
  45 * optional callbacks to let the pcm logic handle the actual content of the
  46 * packets for playback and record. Thus, the bus streaming and the audio
  47 * handlers are fully decoupled.
  48 *
  49 * There are two different types of endpoints in audio applications.
  50 *
  51 * SND_USB_ENDPOINT_TYPE_DATA handles full audio data payload for both
  52 * inbound and outbound traffic.
  53 *
  54 * SND_USB_ENDPOINT_TYPE_SYNC endpoints are for inbound traffic only and
  55 * expect the payload to carry Q10.14 / Q16.16 formatted sync information
  56 * (3 or 4 bytes).
  57 *
  58 * Each endpoint has to be configured prior to being used by calling
  59 * snd_usb_endpoint_set_params().
  60 *
  61 * The model incorporates a reference counting, so that multiple users
  62 * can call snd_usb_endpoint_start() and snd_usb_endpoint_stop(), and
  63 * only the first user will effectively start the URBs, and only the last
  64 * one to stop it will tear the URBs down again.
  65 */
  66
  67/*
  68 * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
  69 * this will overflow at approx 524 kHz
  70 */
  71static inline unsigned get_usb_full_speed_rate(unsigned int rate)
  72{
  73        return ((rate << 13) + 62) / 125;
  74}
  75
  76/*
  77 * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
  78 * this will overflow at approx 4 MHz
  79 */
  80static inline unsigned get_usb_high_speed_rate(unsigned int rate)
  81{
  82        return ((rate << 10) + 62) / 125;
  83}
  84
  85/*
  86 * release a urb data
  87 */
  88static void release_urb_ctx(struct snd_urb_ctx *u)
  89{
  90        if (u->buffer_size)
  91                usb_free_coherent(u->ep->chip->dev, u->buffer_size,
  92                                  u->urb->transfer_buffer,
  93                                  u->urb->transfer_dma);
  94        usb_free_urb(u->urb);
  95        u->urb = NULL;
  96}
  97
  98static const char *usb_error_string(int err)
  99{
 100        switch (err) {
 101        case -ENODEV:
 102                return "no device";
 103        case -ENOENT:
 104                return "endpoint not enabled";
 105        case -EPIPE:
 106                return "endpoint stalled";
 107        case -ENOSPC:
 108                return "not enough bandwidth";
 109        case -ESHUTDOWN:
 110                return "device disabled";
 111        case -EHOSTUNREACH:
 112                return "device suspended";
 113        case -EINVAL:
 114        case -EAGAIN:
 115        case -EFBIG:
 116        case -EMSGSIZE:
 117                return "internal error";
 118        default:
 119                return "unknown error";
 120        }
 121}
 122
 123/**
 124 * snd_usb_endpoint_implicit_feedback_sink: Report endpoint usage type
 125 *
 126 * @ep: The snd_usb_endpoint
 127 *
 128 * Determine whether an endpoint is driven by an implicit feedback
 129 * data endpoint source.
 130 */
 131int snd_usb_endpoint_implict_feedback_sink(struct snd_usb_endpoint *ep)
 132{
 133        return  ep->sync_master &&
 134                ep->sync_master->type == SND_USB_ENDPOINT_TYPE_DATA &&
 135                ep->type == SND_USB_ENDPOINT_TYPE_DATA &&
 136                usb_pipeout(ep->pipe);
 137}
 138
 139/*
 140 * For streaming based on information derived from sync endpoints,
 141 * prepare_outbound_urb_sizes() will call next_packet_size() to
 142 * determine the number of samples to be sent in the next packet.
 143 *
 144 * For implicit feedback, next_packet_size() is unused.
 145 */
 146int snd_usb_endpoint_next_packet_size(struct snd_usb_endpoint *ep)
 147{
 148        unsigned long flags;
 149        int ret;
 150
 151        if (ep->fill_max)
 152                return ep->maxframesize;
 153
 154        spin_lock_irqsave(&ep->lock, flags);
 155        ep->phase = (ep->phase & 0xffff)
 156                + (ep->freqm << ep->datainterval);
 157        ret = min(ep->phase >> 16, ep->maxframesize);
 158        spin_unlock_irqrestore(&ep->lock, flags);
 159
 160        return ret;
 161}
 162
 163static void retire_outbound_urb(struct snd_usb_endpoint *ep,
 164                                struct snd_urb_ctx *urb_ctx)
 165{
 166        if (ep->retire_data_urb)
 167                ep->retire_data_urb(ep->data_subs, urb_ctx->urb);
 168}
 169
 170static void retire_inbound_urb(struct snd_usb_endpoint *ep,
 171                               struct snd_urb_ctx *urb_ctx)
 172{
 173        struct urb *urb = urb_ctx->urb;
 174
 175        if (unlikely(ep->skip_packets > 0)) {
 176                ep->skip_packets--;
 177                return;
 178        }
 179
 180        if (ep->sync_slave)
 181                snd_usb_handle_sync_urb(ep->sync_slave, ep, urb);
 182
 183        if (ep->retire_data_urb)
 184                ep->retire_data_urb(ep->data_subs, urb);
 185}
 186
 187/*
 188 * Prepare a PLAYBACK urb for submission to the bus.
 189 */
 190static void prepare_outbound_urb(struct snd_usb_endpoint *ep,
 191                                 struct snd_urb_ctx *ctx)
 192{
 193        int i;
 194        struct urb *urb = ctx->urb;
 195        unsigned char *cp = urb->transfer_buffer;
 196
 197        urb->dev = ep->chip->dev; /* we need to set this at each time */
 198
 199        switch (ep->type) {
 200        case SND_USB_ENDPOINT_TYPE_DATA:
 201                if (ep->prepare_data_urb) {
 202                        ep->prepare_data_urb(ep->data_subs, urb);
 203                } else {
 204                        /* no data provider, so send silence */
 205                        unsigned int offs = 0;
 206                        for (i = 0; i < ctx->packets; ++i) {
 207                                int counts;
 208
 209                                if (ctx->packet_size[i])
 210                                        counts = ctx->packet_size[i];
 211                                else
 212                                        counts = snd_usb_endpoint_next_packet_size(ep);
 213
 214                                urb->iso_frame_desc[i].offset = offs * ep->stride;
 215                                urb->iso_frame_desc[i].length = counts * ep->stride;
 216                                offs += counts;
 217                        }
 218
 219                        urb->number_of_packets = ctx->packets;
 220                        urb->transfer_buffer_length = offs * ep->stride;
 221                        memset(urb->transfer_buffer, ep->silence_value,
 222                               offs * ep->stride);
 223                }
 224                break;
 225
 226        case SND_USB_ENDPOINT_TYPE_SYNC:
 227                if (snd_usb_get_speed(ep->chip->dev) >= USB_SPEED_HIGH) {
 228                        /*
 229                         * fill the length and offset of each urb descriptor.
 230                         * the fixed 12.13 frequency is passed as 16.16 through the pipe.
 231                         */
 232                        urb->iso_frame_desc[0].length = 4;
 233                        urb->iso_frame_desc[0].offset = 0;
 234                        cp[0] = ep->freqn;
 235                        cp[1] = ep->freqn >> 8;
 236                        cp[2] = ep->freqn >> 16;
 237                        cp[3] = ep->freqn >> 24;
 238                } else {
 239                        /*
 240                         * fill the length and offset of each urb descriptor.
 241                         * the fixed 10.14 frequency is passed through the pipe.
 242                         */
 243                        urb->iso_frame_desc[0].length = 3;
 244                        urb->iso_frame_desc[0].offset = 0;
 245                        cp[0] = ep->freqn >> 2;
 246                        cp[1] = ep->freqn >> 10;
 247                        cp[2] = ep->freqn >> 18;
 248                }
 249
 250                break;
 251        }
 252}
 253
 254/*
 255 * Prepare a CAPTURE or SYNC urb for submission to the bus.
 256 */
 257static inline void prepare_inbound_urb(struct snd_usb_endpoint *ep,
 258                                       struct snd_urb_ctx *urb_ctx)
 259{
 260        int i, offs;
 261        struct urb *urb = urb_ctx->urb;
 262
 263        urb->dev = ep->chip->dev; /* we need to set this at each time */
 264
 265        switch (ep->type) {
 266        case SND_USB_ENDPOINT_TYPE_DATA:
 267                offs = 0;
 268                for (i = 0; i < urb_ctx->packets; i++) {
 269                        urb->iso_frame_desc[i].offset = offs;
 270                        urb->iso_frame_desc[i].length = ep->curpacksize;
 271                        offs += ep->curpacksize;
 272                }
 273
 274                urb->transfer_buffer_length = offs;
 275                urb->number_of_packets = urb_ctx->packets;
 276                break;
 277
 278        case SND_USB_ENDPOINT_TYPE_SYNC:
 279                urb->iso_frame_desc[0].length = min(4u, ep->syncmaxsize);
 280                urb->iso_frame_desc[0].offset = 0;
 281                break;
 282        }
 283}
 284
 285/*
 286 * Send output urbs that have been prepared previously. URBs are dequeued
 287 * from ep->ready_playback_urbs and in case there there aren't any available
 288 * or there are no packets that have been prepared, this function does
 289 * nothing.
 290 *
 291 * The reason why the functionality of sending and preparing URBs is separated
 292 * is that host controllers don't guarantee the order in which they return
 293 * inbound and outbound packets to their submitters.
 294 *
 295 * This function is only used for implicit feedback endpoints. For endpoints
 296 * driven by dedicated sync endpoints, URBs are immediately re-submitted
 297 * from their completion handler.
 298 */
 299static void queue_pending_output_urbs(struct snd_usb_endpoint *ep)
 300{
 301        while (test_bit(EP_FLAG_RUNNING, &ep->flags)) {
 302
 303                unsigned long flags;
 304                struct snd_usb_packet_info *uninitialized_var(packet);
 305                struct snd_urb_ctx *ctx = NULL;
 306                struct urb *urb;
 307                int err, i;
 308
 309                spin_lock_irqsave(&ep->lock, flags);
 310                if (ep->next_packet_read_pos != ep->next_packet_write_pos) {
 311                        packet = ep->next_packet + ep->next_packet_read_pos;
 312                        ep->next_packet_read_pos++;
 313                        ep->next_packet_read_pos %= MAX_URBS;
 314
 315                        /* take URB out of FIFO */
 316                        if (!list_empty(&ep->ready_playback_urbs))
 317                                ctx = list_first_entry(&ep->ready_playback_urbs,
 318                                               struct snd_urb_ctx, ready_list);
 319                }
 320                spin_unlock_irqrestore(&ep->lock, flags);
 321
 322                if (ctx == NULL)
 323                        return;
 324
 325                list_del_init(&ctx->ready_list);
 326                urb = ctx->urb;
 327
 328                /* copy over the length information */
 329                for (i = 0; i < packet->packets; i++)
 330                        ctx->packet_size[i] = packet->packet_size[i];
 331
 332                /* call the data handler to fill in playback data */
 333                prepare_outbound_urb(ep, ctx);
 334
 335                err = usb_submit_urb(ctx->urb, GFP_ATOMIC);
 336                if (err < 0)
 337                        snd_printk(KERN_ERR "Unable to submit urb #%d: %d (urb %p)\n",
 338                                   ctx->index, err, ctx->urb);
 339                else
 340                        set_bit(ctx->index, &ep->active_mask);
 341        }
 342}
 343
 344/*
 345 * complete callback for urbs
 346 */
 347static void snd_complete_urb(struct urb *urb)
 348{
 349        struct snd_urb_ctx *ctx = urb->context;
 350        struct snd_usb_endpoint *ep = ctx->ep;
 351        int err;
 352
 353        if (unlikely(urb->status == -ENOENT ||          /* unlinked */
 354                     urb->status == -ENODEV ||          /* device removed */
 355                     urb->status == -ECONNRESET ||      /* unlinked */
 356                     urb->status == -ESHUTDOWN ||       /* device disabled */
 357                     ep->chip->shutdown))               /* device disconnected */
 358                goto exit_clear;
 359
 360        if (usb_pipeout(ep->pipe)) {
 361                retire_outbound_urb(ep, ctx);
 362                /* can be stopped during retire callback */
 363                if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
 364                        goto exit_clear;
 365
 366                if (snd_usb_endpoint_implict_feedback_sink(ep)) {
 367                        unsigned long flags;
 368
 369                        spin_lock_irqsave(&ep->lock, flags);
 370                        list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
 371                        spin_unlock_irqrestore(&ep->lock, flags);
 372                        queue_pending_output_urbs(ep);
 373
 374                        goto exit_clear;
 375                }
 376
 377                prepare_outbound_urb(ep, ctx);
 378        } else {
 379                retire_inbound_urb(ep, ctx);
 380                /* can be stopped during retire callback */
 381                if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
 382                        goto exit_clear;
 383
 384                prepare_inbound_urb(ep, ctx);
 385        }
 386
 387        err = usb_submit_urb(urb, GFP_ATOMIC);
 388        if (err == 0)
 389                return;
 390
 391        snd_printk(KERN_ERR "cannot submit urb (err = %d)\n", err);
 392        //snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
 393
 394exit_clear:
 395        clear_bit(ctx->index, &ep->active_mask);
 396}
 397
 398/**
 399 * snd_usb_add_endpoint: Add an endpoint to an USB audio chip
 400 *
 401 * @chip: The chip
 402 * @alts: The USB host interface
 403 * @ep_num: The number of the endpoint to use
 404 * @direction: SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE
 405 * @type: SND_USB_ENDPOINT_TYPE_DATA or SND_USB_ENDPOINT_TYPE_SYNC
 406 *
 407 * If the requested endpoint has not been added to the given chip before,
 408 * a new instance is created. Otherwise, a pointer to the previoulsy
 409 * created instance is returned. In case of any error, NULL is returned.
 410 *
 411 * New endpoints will be added to chip->ep_list and must be freed by
 412 * calling snd_usb_endpoint_free().
 413 */
 414struct snd_usb_endpoint *snd_usb_add_endpoint(struct snd_usb_audio *chip,
 415                                              struct usb_host_interface *alts,
 416                                              int ep_num, int direction, int type)
 417{
 418        struct list_head *p;
 419        struct snd_usb_endpoint *ep;
 420        int is_playback = direction == SNDRV_PCM_STREAM_PLAYBACK;
 421
 422        mutex_lock(&chip->mutex);
 423
 424        list_for_each(p, &chip->ep_list) {
 425                ep = list_entry(p, struct snd_usb_endpoint, list);
 426                if (ep->ep_num == ep_num &&
 427                    ep->iface == alts->desc.bInterfaceNumber &&
 428                    ep->alt_idx == alts->desc.bAlternateSetting) {
 429                        snd_printdd(KERN_DEBUG "Re-using EP %x in iface %d,%d @%p\n",
 430                                        ep_num, ep->iface, ep->alt_idx, ep);
 431                        goto __exit_unlock;
 432                }
 433        }
 434
 435        snd_printdd(KERN_DEBUG "Creating new %s %s endpoint #%x\n",
 436                    is_playback ? "playback" : "capture",
 437                    type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync",
 438                    ep_num);
 439
 440        ep = kzalloc(sizeof(*ep), GFP_KERNEL);
 441        if (!ep)
 442                goto __exit_unlock;
 443
 444        ep->chip = chip;
 445        spin_lock_init(&ep->lock);
 446        ep->type = type;
 447        ep->ep_num = ep_num;
 448        ep->iface = alts->desc.bInterfaceNumber;
 449        ep->alt_idx = alts->desc.bAlternateSetting;
 450        INIT_LIST_HEAD(&ep->ready_playback_urbs);
 451        ep_num &= USB_ENDPOINT_NUMBER_MASK;
 452
 453        if (is_playback)
 454                ep->pipe = usb_sndisocpipe(chip->dev, ep_num);
 455        else
 456                ep->pipe = usb_rcvisocpipe(chip->dev, ep_num);
 457
 458        if (type == SND_USB_ENDPOINT_TYPE_SYNC) {
 459                if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
 460                    get_endpoint(alts, 1)->bRefresh >= 1 &&
 461                    get_endpoint(alts, 1)->bRefresh <= 9)
 462                        ep->syncinterval = get_endpoint(alts, 1)->bRefresh;
 463                else if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL)
 464                        ep->syncinterval = 1;
 465                else if (get_endpoint(alts, 1)->bInterval >= 1 &&
 466                         get_endpoint(alts, 1)->bInterval <= 16)
 467                        ep->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
 468                else
 469                        ep->syncinterval = 3;
 470
 471                ep->syncmaxsize = le16_to_cpu(get_endpoint(alts, 1)->wMaxPacketSize);
 472        }
 473
 474        list_add_tail(&ep->list, &chip->ep_list);
 475
 476__exit_unlock:
 477        mutex_unlock(&chip->mutex);
 478
 479        return ep;
 480}
 481
 482/*
 483 *  wait until all urbs are processed.
 484 */
 485static int wait_clear_urbs(struct snd_usb_endpoint *ep)
 486{
 487        unsigned long end_time = jiffies + msecs_to_jiffies(1000);
 488        unsigned int i;
 489        int alive;
 490
 491        do {
 492                alive = 0;
 493                for (i = 0; i < ep->nurbs; i++)
 494                        if (test_bit(i, &ep->active_mask))
 495                                alive++;
 496
 497                if (!alive)
 498                        break;
 499
 500                schedule_timeout_uninterruptible(1);
 501        } while (time_before(jiffies, end_time));
 502
 503        if (alive)
 504                snd_printk(KERN_ERR "timeout: still %d active urbs on EP #%x\n",
 505                                        alive, ep->ep_num);
 506        clear_bit(EP_FLAG_STOPPING, &ep->flags);
 507
 508        return 0;
 509}
 510
 511/* sync the pending stop operation;
 512 * this function itself doesn't trigger the stop operation
 513 */
 514void snd_usb_endpoint_sync_pending_stop(struct snd_usb_endpoint *ep)
 515{
 516        if (ep && test_bit(EP_FLAG_STOPPING, &ep->flags))
 517                wait_clear_urbs(ep);
 518}
 519
 520/*
 521 * unlink active urbs.
 522 */
 523static int deactivate_urbs(struct snd_usb_endpoint *ep, int force, int can_sleep)
 524{
 525        unsigned int i;
 526        int async;
 527
 528        if (!force && ep->chip->shutdown) /* to be sure... */
 529                return -EBADFD;
 530
 531        async = !can_sleep && ep->chip->async_unlink;
 532
 533        clear_bit(EP_FLAG_RUNNING, &ep->flags);
 534
 535        INIT_LIST_HEAD(&ep->ready_playback_urbs);
 536        ep->next_packet_read_pos = 0;
 537        ep->next_packet_write_pos = 0;
 538
 539        if (!async && in_interrupt())
 540                return 0;
 541
 542        for (i = 0; i < ep->nurbs; i++) {
 543                if (test_bit(i, &ep->active_mask)) {
 544                        if (!test_and_set_bit(i, &ep->unlink_mask)) {
 545                                struct urb *u = ep->urb[i].urb;
 546                                if (async)
 547                                        usb_unlink_urb(u);
 548                                else
 549                                        usb_kill_urb(u);
 550                        }
 551                }
 552        }
 553
 554        return 0;
 555}
 556
 557/*
 558 * release an endpoint's urbs
 559 */
 560static void release_urbs(struct snd_usb_endpoint *ep, int force)
 561{
 562        int i;
 563
 564        /* route incoming urbs to nirvana */
 565        ep->retire_data_urb = NULL;
 566        ep->prepare_data_urb = NULL;
 567
 568        /* stop urbs */
 569        deactivate_urbs(ep, force, 1);
 570        wait_clear_urbs(ep);
 571
 572        for (i = 0; i < ep->nurbs; i++)
 573                release_urb_ctx(&ep->urb[i]);
 574
 575        if (ep->syncbuf)
 576                usb_free_coherent(ep->chip->dev, SYNC_URBS * 4,
 577                                  ep->syncbuf, ep->sync_dma);
 578
 579        ep->syncbuf = NULL;
 580        ep->nurbs = 0;
 581}
 582
 583/*
 584 * configure a data endpoint
 585 */
 586static int data_ep_set_params(struct snd_usb_endpoint *ep,
 587                              snd_pcm_format_t pcm_format,
 588                              unsigned int channels,
 589                              unsigned int period_bytes,
 590                              struct audioformat *fmt,
 591                              struct snd_usb_endpoint *sync_ep)
 592{
 593        unsigned int maxsize, i, urb_packs, total_packs, packs_per_ms;
 594        int is_playback = usb_pipeout(ep->pipe);
 595        int frame_bits = snd_pcm_format_physical_width(pcm_format) * channels;
 596
 597        ep->datainterval = fmt->datainterval;
 598        ep->stride = frame_bits >> 3;
 599        ep->silence_value = pcm_format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0;
 600
 601        /* calculate max. frequency */
 602        if (ep->maxpacksize) {
 603                /* whatever fits into a max. size packet */
 604                maxsize = ep->maxpacksize;
 605                ep->freqmax = (maxsize / (frame_bits >> 3))
 606                                << (16 - ep->datainterval);
 607        } else {
 608                /* no max. packet size: just take 25% higher than nominal */
 609                ep->freqmax = ep->freqn + (ep->freqn >> 2);
 610                maxsize = ((ep->freqmax + 0xffff) * (frame_bits >> 3))
 611                                >> (16 - ep->datainterval);
 612        }
 613
 614        if (ep->fill_max)
 615                ep->curpacksize = ep->maxpacksize;
 616        else
 617                ep->curpacksize = maxsize;
 618
 619        if (snd_usb_get_speed(ep->chip->dev) != USB_SPEED_FULL)
 620                packs_per_ms = 8 >> ep->datainterval;
 621        else
 622                packs_per_ms = 1;
 623
 624        if (is_playback && !snd_usb_endpoint_implict_feedback_sink(ep)) {
 625                urb_packs = max(ep->chip->nrpacks, 1);
 626                urb_packs = min(urb_packs, (unsigned int) MAX_PACKS);
 627        } else {
 628                urb_packs = 1;
 629        }
 630
 631        urb_packs *= packs_per_ms;
 632
 633        if (sync_ep && !snd_usb_endpoint_implict_feedback_sink(ep))
 634                urb_packs = min(urb_packs, 1U << sync_ep->syncinterval);
 635
 636        /* decide how many packets to be used */
 637        if (is_playback && !snd_usb_endpoint_implict_feedback_sink(ep)) {
 638                unsigned int minsize, maxpacks;
 639                /* determine how small a packet can be */
 640                minsize = (ep->freqn >> (16 - ep->datainterval))
 641                          * (frame_bits >> 3);
 642                /* with sync from device, assume it can be 12% lower */
 643                if (sync_ep)
 644                        minsize -= minsize >> 3;
 645                minsize = max(minsize, 1u);
 646                total_packs = (period_bytes + minsize - 1) / minsize;
 647                /* we need at least two URBs for queueing */
 648                if (total_packs < 2) {
 649                        total_packs = 2;
 650                } else {
 651                        /* and we don't want too long a queue either */
 652                        maxpacks = max(MAX_QUEUE * packs_per_ms, urb_packs * 2);
 653                        total_packs = min(total_packs, maxpacks);
 654                }
 655        } else {
 656                while (urb_packs > 1 && urb_packs * maxsize >= period_bytes)
 657                        urb_packs >>= 1;
 658                total_packs = MAX_URBS * urb_packs;
 659        }
 660
 661        ep->nurbs = (total_packs + urb_packs - 1) / urb_packs;
 662        if (ep->nurbs > MAX_URBS) {
 663                /* too much... */
 664                ep->nurbs = MAX_URBS;
 665                total_packs = MAX_URBS * urb_packs;
 666        } else if (ep->nurbs < 2) {
 667                /* too little - we need at least two packets
 668                 * to ensure contiguous playback/capture
 669                 */
 670                ep->nurbs = 2;
 671        }
 672
 673        /* allocate and initialize data urbs */
 674        for (i = 0; i < ep->nurbs; i++) {
 675                struct snd_urb_ctx *u = &ep->urb[i];
 676                u->index = i;
 677                u->ep = ep;
 678                u->packets = (i + 1) * total_packs / ep->nurbs
 679                        - i * total_packs / ep->nurbs;
 680                u->buffer_size = maxsize * u->packets;
 681
 682                if (fmt->fmt_type == UAC_FORMAT_TYPE_II)
 683                        u->packets++; /* for transfer delimiter */
 684                u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
 685                if (!u->urb)
 686                        goto out_of_memory;
 687
 688                u->urb->transfer_buffer =
 689                        usb_alloc_coherent(ep->chip->dev, u->buffer_size,
 690                                           GFP_KERNEL, &u->urb->transfer_dma);
 691                if (!u->urb->transfer_buffer)
 692                        goto out_of_memory;
 693                u->urb->pipe = ep->pipe;
 694                u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
 695                u->urb->interval = 1 << ep->datainterval;
 696                u->urb->context = u;
 697                u->urb->complete = snd_complete_urb;
 698                INIT_LIST_HEAD(&u->ready_list);
 699        }
 700
 701        return 0;
 702
 703out_of_memory:
 704        release_urbs(ep, 0);
 705        return -ENOMEM;
 706}
 707
 708/*
 709 * configure a sync endpoint
 710 */
 711static int sync_ep_set_params(struct snd_usb_endpoint *ep,
 712                              struct audioformat *fmt)
 713{
 714        int i;
 715
 716        ep->syncbuf = usb_alloc_coherent(ep->chip->dev, SYNC_URBS * 4,
 717                                         GFP_KERNEL, &ep->sync_dma);
 718        if (!ep->syncbuf)
 719                return -ENOMEM;
 720
 721        for (i = 0; i < SYNC_URBS; i++) {
 722                struct snd_urb_ctx *u = &ep->urb[i];
 723                u->index = i;
 724                u->ep = ep;
 725                u->packets = 1;
 726                u->urb = usb_alloc_urb(1, GFP_KERNEL);
 727                if (!u->urb)
 728                        goto out_of_memory;
 729                u->urb->transfer_buffer = ep->syncbuf + i * 4;
 730                u->urb->transfer_dma = ep->sync_dma + i * 4;
 731                u->urb->transfer_buffer_length = 4;
 732                u->urb->pipe = ep->pipe;
 733                u->urb->transfer_flags = URB_ISO_ASAP |
 734                                         URB_NO_TRANSFER_DMA_MAP;
 735                u->urb->number_of_packets = 1;
 736                u->urb->interval = 1 << ep->syncinterval;
 737                u->urb->context = u;
 738                u->urb->complete = snd_complete_urb;
 739        }
 740
 741        ep->nurbs = SYNC_URBS;
 742
 743        return 0;
 744
 745out_of_memory:
 746        release_urbs(ep, 0);
 747        return -ENOMEM;
 748}
 749
 750/**
 751 * snd_usb_endpoint_set_params: configure an snd_usb_endpoint
 752 *
 753 * @ep: the snd_usb_endpoint to configure
 754 * @pcm_format: the audio fomat.
 755 * @channels: the number of audio channels.
 756 * @period_bytes: the number of bytes in one alsa period.
 757 * @rate: the frame rate.
 758 * @fmt: the USB audio format information
 759 * @sync_ep: the sync endpoint to use, if any
 760 *
 761 * Determine the number of URBs to be used on this endpoint.
 762 * An endpoint must be configured before it can be started.
 763 * An endpoint that is already running can not be reconfigured.
 764 */
 765int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep,
 766                                snd_pcm_format_t pcm_format,
 767                                unsigned int channels,
 768                                unsigned int period_bytes,
 769                                unsigned int rate,
 770                                struct audioformat *fmt,
 771                                struct snd_usb_endpoint *sync_ep)
 772{
 773        int err;
 774
 775        if (ep->use_count != 0) {
 776                snd_printk(KERN_WARNING "Unable to change format on ep #%x: already in use\n",
 777                           ep->ep_num);
 778                return -EBUSY;
 779        }
 780
 781        /* release old buffers, if any */
 782        release_urbs(ep, 0);
 783
 784        ep->datainterval = fmt->datainterval;
 785        ep->maxpacksize = fmt->maxpacksize;
 786        ep->fill_max = !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX);
 787
 788        if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_FULL)
 789                ep->freqn = get_usb_full_speed_rate(rate);
 790        else
 791                ep->freqn = get_usb_high_speed_rate(rate);
 792
 793        /* calculate the frequency in 16.16 format */
 794        ep->freqm = ep->freqn;
 795        ep->freqshift = INT_MIN;
 796
 797        ep->phase = 0;
 798
 799        switch (ep->type) {
 800        case  SND_USB_ENDPOINT_TYPE_DATA:
 801                err = data_ep_set_params(ep, pcm_format, channels,
 802                                         period_bytes, fmt, sync_ep);
 803                break;
 804        case  SND_USB_ENDPOINT_TYPE_SYNC:
 805                err = sync_ep_set_params(ep, fmt);
 806                break;
 807        default:
 808                err = -EINVAL;
 809        }
 810
 811        snd_printdd(KERN_DEBUG "Setting params for ep #%x (type %d, %d urbs), ret=%d\n",
 812                   ep->ep_num, ep->type, ep->nurbs, err);
 813
 814        return err;
 815}
 816
 817/**
 818 * snd_usb_endpoint_start: start an snd_usb_endpoint
 819 *
 820 * @ep:         the endpoint to start
 821 * @can_sleep:  flag indicating whether the operation is executed in
 822 *              non-atomic context
 823 *
 824 * A call to this function will increment the use count of the endpoint.
 825 * In case it is not already running, the URBs for this endpoint will be
 826 * submitted. Otherwise, this function does nothing.
 827 *
 828 * Must be balanced to calls of snd_usb_endpoint_stop().
 829 *
 830 * Returns an error if the URB submission failed, 0 in all other cases.
 831 */
 832int snd_usb_endpoint_start(struct snd_usb_endpoint *ep, int can_sleep)
 833{
 834        int err;
 835        unsigned int i;
 836
 837        if (ep->chip->shutdown)
 838                return -EBADFD;
 839
 840        /* already running? */
 841        if (++ep->use_count != 1)
 842                return 0;
 843
 844        /* just to be sure */
 845        deactivate_urbs(ep, 0, can_sleep);
 846        if (can_sleep)
 847                wait_clear_urbs(ep);
 848
 849        ep->active_mask = 0;
 850        ep->unlink_mask = 0;
 851        ep->phase = 0;
 852
 853        snd_usb_endpoint_start_quirk(ep);
 854
 855        /*
 856         * If this endpoint has a data endpoint as implicit feedback source,
 857         * don't start the urbs here. Instead, mark them all as available,
 858         * wait for the record urbs to return and queue the playback urbs
 859         * from that context.
 860         */
 861
 862        set_bit(EP_FLAG_RUNNING, &ep->flags);
 863
 864        if (snd_usb_endpoint_implict_feedback_sink(ep)) {
 865                for (i = 0; i < ep->nurbs; i++) {
 866                        struct snd_urb_ctx *ctx = ep->urb + i;
 867                        list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
 868                }
 869
 870                return 0;
 871        }
 872
 873        for (i = 0; i < ep->nurbs; i++) {
 874                struct urb *urb = ep->urb[i].urb;
 875
 876                if (snd_BUG_ON(!urb))
 877                        goto __error;
 878
 879                if (usb_pipeout(ep->pipe)) {
 880                        prepare_outbound_urb(ep, urb->context);
 881                } else {
 882                        prepare_inbound_urb(ep, urb->context);
 883                }
 884
 885                err = usb_submit_urb(urb, GFP_ATOMIC);
 886                if (err < 0) {
 887                        snd_printk(KERN_ERR "cannot submit urb %d, error %d: %s\n",
 888                                   i, err, usb_error_string(err));
 889                        goto __error;
 890                }
 891                set_bit(i, &ep->active_mask);
 892        }
 893
 894        return 0;
 895
 896__error:
 897        clear_bit(EP_FLAG_RUNNING, &ep->flags);
 898        ep->use_count--;
 899        deactivate_urbs(ep, 0, 0);
 900        return -EPIPE;
 901}
 902
 903/**
 904 * snd_usb_endpoint_stop: stop an snd_usb_endpoint
 905 *
 906 * @ep: the endpoint to stop (may be NULL)
 907 *
 908 * A call to this function will decrement the use count of the endpoint.
 909 * In case the last user has requested the endpoint stop, the URBs will
 910 * actually be deactivated.
 911 *
 912 * Must be balanced to calls of snd_usb_endpoint_start().
 913 */
 914void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep,
 915                           int force, int can_sleep, int wait)
 916{
 917        if (!ep)
 918                return;
 919
 920        if (snd_BUG_ON(ep->use_count == 0))
 921                return;
 922
 923        if (--ep->use_count == 0) {
 924                deactivate_urbs(ep, force, can_sleep);
 925                ep->data_subs = NULL;
 926                ep->sync_slave = NULL;
 927                ep->retire_data_urb = NULL;
 928                ep->prepare_data_urb = NULL;
 929
 930                if (wait)
 931                        wait_clear_urbs(ep);
 932                else
 933                        set_bit(EP_FLAG_STOPPING, &ep->flags);
 934        }
 935}
 936
 937/**
 938 * snd_usb_endpoint_deactivate: deactivate an snd_usb_endpoint
 939 *
 940 * @ep: the endpoint to deactivate
 941 *
 942 * If the endpoint is not currently in use, this functions will select the
 943 * alternate interface setting 0 for the interface of this endpoint.
 944 *
 945 * In case of any active users, this functions does nothing.
 946 *
 947 * Returns an error if usb_set_interface() failed, 0 in all other
 948 * cases.
 949 */
 950int snd_usb_endpoint_deactivate(struct snd_usb_endpoint *ep)
 951{
 952        if (!ep)
 953                return -EINVAL;
 954
 955        deactivate_urbs(ep, 1, 1);
 956        wait_clear_urbs(ep);
 957
 958        if (ep->use_count != 0)
 959                return 0;
 960
 961        clear_bit(EP_FLAG_ACTIVATED, &ep->flags);
 962
 963        return 0;
 964}
 965
 966/**
 967 * snd_usb_endpoint_free: Free the resources of an snd_usb_endpoint
 968 *
 969 * @ep: the list header of the endpoint to free
 970 *
 971 * This function does not care for the endpoint's use count but will tear
 972 * down all the streaming URBs immediately and free all resources.
 973 */
 974void snd_usb_endpoint_free(struct list_head *head)
 975{
 976        struct snd_usb_endpoint *ep;
 977
 978        ep = list_entry(head, struct snd_usb_endpoint, list);
 979        release_urbs(ep, 1);
 980        kfree(ep);
 981}
 982
 983/**
 984 * snd_usb_handle_sync_urb: parse an USB sync packet
 985 *
 986 * @ep: the endpoint to handle the packet
 987 * @sender: the sending endpoint
 988 * @urb: the received packet
 989 *
 990 * This function is called from the context of an endpoint that received
 991 * the packet and is used to let another endpoint object handle the payload.
 992 */
 993void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
 994                             struct snd_usb_endpoint *sender,
 995                             const struct urb *urb)
 996{
 997        int shift;
 998        unsigned int f;
 999        unsigned long flags;
1000
1001        snd_BUG_ON(ep == sender);
1002
1003        /*
1004         * In case the endpoint is operating in implicit feedback mode, prepare
1005         * a new outbound URB that has the same layout as the received packet
1006         * and add it to the list of pending urbs. queue_pending_output_urbs()
1007         * will take care of them later.
1008         */
1009        if (snd_usb_endpoint_implict_feedback_sink(ep) &&
1010            ep->use_count != 0) {
1011
1012                /* implicit feedback case */
1013                int i, bytes = 0;
1014                struct snd_urb_ctx *in_ctx;
1015                struct snd_usb_packet_info *out_packet;
1016
1017                in_ctx = urb->context;
1018
1019                /* Count overall packet size */
1020                for (i = 0; i < in_ctx->packets; i++)
1021                        if (urb->iso_frame_desc[i].status == 0)
1022                                bytes += urb->iso_frame_desc[i].actual_length;
1023
1024                /*
1025                 * skip empty packets. At least M-Audio's Fast Track Ultra stops
1026                 * streaming once it received a 0-byte OUT URB
1027                 */
1028                if (bytes == 0)
1029                        return;
1030
1031                spin_lock_irqsave(&ep->lock, flags);
1032                out_packet = ep->next_packet + ep->next_packet_write_pos;
1033
1034                /*
1035                 * Iterate through the inbound packet and prepare the lengths
1036                 * for the output packet. The OUT packet we are about to send
1037                 * will have the same amount of payload bytes than the IN
1038                 * packet we just received.
1039                 */
1040
1041                out_packet->packets = in_ctx->packets;
1042                for (i = 0; i < in_ctx->packets; i++) {
1043                        if (urb->iso_frame_desc[i].status == 0)
1044                                out_packet->packet_size[i] =
1045                                        urb->iso_frame_desc[i].actual_length / ep->stride;
1046                        else
1047                                out_packet->packet_size[i] = 0;
1048                }
1049
1050                ep->next_packet_write_pos++;
1051                ep->next_packet_write_pos %= MAX_URBS;
1052                spin_unlock_irqrestore(&ep->lock, flags);
1053                queue_pending_output_urbs(ep);
1054
1055                return;
1056        }
1057
1058        /*
1059         * process after playback sync complete
1060         *
1061         * Full speed devices report feedback values in 10.14 format as samples
1062         * per frame, high speed devices in 16.16 format as samples per
1063         * microframe.
1064         *
1065         * Because the Audio Class 1 spec was written before USB 2.0, many high
1066         * speed devices use a wrong interpretation, some others use an
1067         * entirely different format.
1068         *
1069         * Therefore, we cannot predict what format any particular device uses
1070         * and must detect it automatically.
1071         */
1072
1073        if (urb->iso_frame_desc[0].status != 0 ||
1074            urb->iso_frame_desc[0].actual_length < 3)
1075                return;
1076
1077        f = le32_to_cpup(urb->transfer_buffer);
1078        if (urb->iso_frame_desc[0].actual_length == 3)
1079                f &= 0x00ffffff;
1080        else
1081                f &= 0x0fffffff;
1082
1083        if (f == 0)
1084                return;
1085
1086        if (unlikely(ep->freqshift == INT_MIN)) {
1087                /*
1088                 * The first time we see a feedback value, determine its format
1089                 * by shifting it left or right until it matches the nominal
1090                 * frequency value.  This assumes that the feedback does not
1091                 * differ from the nominal value more than +50% or -25%.
1092                 */
1093                shift = 0;
1094                while (f < ep->freqn - ep->freqn / 4) {
1095                        f <<= 1;
1096                        shift++;
1097                }
1098                while (f > ep->freqn + ep->freqn / 2) {
1099                        f >>= 1;
1100                        shift--;
1101                }
1102                ep->freqshift = shift;
1103        } else if (ep->freqshift >= 0)
1104                f <<= ep->freqshift;
1105        else
1106                f >>= -ep->freqshift;
1107
1108        if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) {
1109                /*
1110                 * If the frequency looks valid, set it.
1111                 * This value is referred to in prepare_playback_urb().
1112                 */
1113                spin_lock_irqsave(&ep->lock, flags);
1114                ep->freqm = f;
1115                spin_unlock_irqrestore(&ep->lock, flags);
1116        } else {
1117                /*
1118                 * Out of range; maybe the shift value is wrong.
1119                 * Reset it so that we autodetect again the next time.
1120                 */
1121                ep->freqshift = INT_MIN;
1122        }
1123}
1124
1125
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.