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                              struct snd_pcm_hw_params *hw_params,
 588                              struct audioformat *fmt,
 589                              struct snd_usb_endpoint *sync_ep)
 590{
 591        unsigned int maxsize, i, urb_packs, total_packs, packs_per_ms;
 592        int period_bytes = params_period_bytes(hw_params);
 593        int format = params_format(hw_params);
 594        int is_playback = usb_pipeout(ep->pipe);
 595        int frame_bits = snd_pcm_format_physical_width(params_format(hw_params)) *
 596                                                        params_channels(hw_params);
 597
 598        ep->datainterval = fmt->datainterval;
 599        ep->stride = frame_bits >> 3;
 600        ep->silence_value = format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0;
 601
 602        /* calculate max. frequency */
 603        if (ep->maxpacksize) {
 604                /* whatever fits into a max. size packet */
 605                maxsize = ep->maxpacksize;
 606                ep->freqmax = (maxsize / (frame_bits >> 3))
 607                                << (16 - ep->datainterval);
 608        } else {
 609                /* no max. packet size: just take 25% higher than nominal */
 610                ep->freqmax = ep->freqn + (ep->freqn >> 2);
 611                maxsize = ((ep->freqmax + 0xffff) * (frame_bits >> 3))
 612                                >> (16 - ep->datainterval);
 613        }
 614
 615        if (ep->fill_max)
 616                ep->curpacksize = ep->maxpacksize;
 617        else
 618                ep->curpacksize = maxsize;
 619
 620        if (snd_usb_get_speed(ep->chip->dev) != USB_SPEED_FULL)
 621                packs_per_ms = 8 >> ep->datainterval;
 622        else
 623                packs_per_ms = 1;
 624
 625        if (is_playback && !snd_usb_endpoint_implict_feedback_sink(ep)) {
 626                urb_packs = max(ep->chip->nrpacks, 1);
 627                urb_packs = min(urb_packs, (unsigned int) MAX_PACKS);
 628        } else {
 629                urb_packs = 1;
 630        }
 631
 632        urb_packs *= packs_per_ms;
 633
 634        if (sync_ep && !snd_usb_endpoint_implict_feedback_sink(ep))
 635                urb_packs = min(urb_packs, 1U << sync_ep->syncinterval);
 636
 637        /* decide how many packets to be used */
 638        if (is_playback && !snd_usb_endpoint_implict_feedback_sink(ep)) {
 639                unsigned int minsize, maxpacks;
 640                /* determine how small a packet can be */
 641                minsize = (ep->freqn >> (16 - ep->datainterval))
 642                          * (frame_bits >> 3);
 643                /* with sync from device, assume it can be 12% lower */
 644                if (sync_ep)
 645                        minsize -= minsize >> 3;
 646                minsize = max(minsize, 1u);
 647                total_packs = (period_bytes + minsize - 1) / minsize;
 648                /* we need at least two URBs for queueing */
 649                if (total_packs < 2) {
 650                        total_packs = 2;
 651                } else {
 652                        /* and we don't want too long a queue either */
 653                        maxpacks = max(MAX_QUEUE * packs_per_ms, urb_packs * 2);
 654                        total_packs = min(total_packs, maxpacks);
 655                }
 656        } else {
 657                while (urb_packs > 1 && urb_packs * maxsize >= period_bytes)
 658                        urb_packs >>= 1;
 659                total_packs = MAX_URBS * urb_packs;
 660        }
 661
 662        ep->nurbs = (total_packs + urb_packs - 1) / urb_packs;
 663        if (ep->nurbs > MAX_URBS) {
 664                /* too much... */
 665                ep->nurbs = MAX_URBS;
 666                total_packs = MAX_URBS * urb_packs;
 667        } else if (ep->nurbs < 2) {
 668                /* too little - we need at least two packets
 669                 * to ensure contiguous playback/capture
 670                 */
 671                ep->nurbs = 2;
 672        }
 673
 674        /* allocate and initialize data urbs */
 675        for (i = 0; i < ep->nurbs; i++) {
 676                struct snd_urb_ctx *u = &ep->urb[i];
 677                u->index = i;
 678                u->ep = ep;
 679                u->packets = (i + 1) * total_packs / ep->nurbs
 680                        - i * total_packs / ep->nurbs;
 681                u->buffer_size = maxsize * u->packets;
 682
 683                if (fmt->fmt_type == UAC_FORMAT_TYPE_II)
 684                        u->packets++; /* for transfer delimiter */
 685                u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
 686                if (!u->urb)
 687                        goto out_of_memory;
 688
 689                u->urb->transfer_buffer =
 690                        usb_alloc_coherent(ep->chip->dev, u->buffer_size,
 691                                           GFP_KERNEL, &u->urb->transfer_dma);
 692                if (!u->urb->transfer_buffer)
 693                        goto out_of_memory;
 694                u->urb->pipe = ep->pipe;
 695                u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
 696                u->urb->interval = 1 << ep->datainterval;
 697                u->urb->context = u;
 698                u->urb->complete = snd_complete_urb;
 699                INIT_LIST_HEAD(&u->ready_list);
 700        }
 701
 702        return 0;
 703
 704out_of_memory:
 705        release_urbs(ep, 0);
 706        return -ENOMEM;
 707}
 708
 709/*
 710 * configure a sync endpoint
 711 */
 712static int sync_ep_set_params(struct snd_usb_endpoint *ep,
 713                              struct snd_pcm_hw_params *hw_params,
 714                              struct audioformat *fmt)
 715{
 716        int i;
 717
 718        ep->syncbuf = usb_alloc_coherent(ep->chip->dev, SYNC_URBS * 4,
 719                                         GFP_KERNEL, &ep->sync_dma);
 720        if (!ep->syncbuf)
 721                return -ENOMEM;
 722
 723        for (i = 0; i < SYNC_URBS; i++) {
 724                struct snd_urb_ctx *u = &ep->urb[i];
 725                u->index = i;
 726                u->ep = ep;
 727                u->packets = 1;
 728                u->urb = usb_alloc_urb(1, GFP_KERNEL);
 729                if (!u->urb)
 730                        goto out_of_memory;
 731                u->urb->transfer_buffer = ep->syncbuf + i * 4;
 732                u->urb->transfer_dma = ep->sync_dma + i * 4;
 733                u->urb->transfer_buffer_length = 4;
 734                u->urb->pipe = ep->pipe;
 735                u->urb->transfer_flags = URB_ISO_ASAP |
 736                                         URB_NO_TRANSFER_DMA_MAP;
 737                u->urb->number_of_packets = 1;
 738                u->urb->interval = 1 << ep->syncinterval;
 739                u->urb->context = u;
 740                u->urb->complete = snd_complete_urb;
 741        }
 742
 743        ep->nurbs = SYNC_URBS;
 744
 745        return 0;
 746
 747out_of_memory:
 748        release_urbs(ep, 0);
 749        return -ENOMEM;
 750}
 751
 752/**
 753 * snd_usb_endpoint_set_params: configure an snd_usb_endpoint
 754 *
 755 * @ep: the snd_usb_endpoint to configure
 756 * @hw_params: the hardware parameters
 757 * @fmt: the USB audio format information
 758 * @sync_ep: the sync endpoint to use, if any
 759 *
 760 * Determine the number of URBs to be used on this endpoint.
 761 * An endpoint must be configured before it can be started.
 762 * An endpoint that is already running can not be reconfigured.
 763 */
 764int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep,
 765                                struct snd_pcm_hw_params *hw_params,
 766                                struct audioformat *fmt,
 767                                struct snd_usb_endpoint *sync_ep)
 768{
 769        int err;
 770
 771        if (ep->use_count != 0) {
 772                snd_printk(KERN_WARNING "Unable to change format on ep #%x: already in use\n",
 773                           ep->ep_num);
 774                return -EBUSY;
 775        }
 776
 777        /* release old buffers, if any */
 778        release_urbs(ep, 0);
 779
 780        ep->datainterval = fmt->datainterval;
 781        ep->maxpacksize = fmt->maxpacksize;
 782        ep->fill_max = !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX);
 783
 784        if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_FULL)
 785                ep->freqn = get_usb_full_speed_rate(params_rate(hw_params));
 786        else
 787                ep->freqn = get_usb_high_speed_rate(params_rate(hw_params));
 788
 789        /* calculate the frequency in 16.16 format */
 790        ep->freqm = ep->freqn;
 791        ep->freqshift = INT_MIN;
 792
 793        ep->phase = 0;
 794
 795        switch (ep->type) {
 796        case  SND_USB_ENDPOINT_TYPE_DATA:
 797                err = data_ep_set_params(ep, hw_params, fmt, sync_ep);
 798                break;
 799        case  SND_USB_ENDPOINT_TYPE_SYNC:
 800                err = sync_ep_set_params(ep, hw_params, fmt);
 801                break;
 802        default:
 803                err = -EINVAL;
 804        }
 805
 806        snd_printdd(KERN_DEBUG "Setting params for ep #%x (type %d, %d urbs), ret=%d\n",
 807                   ep->ep_num, ep->type, ep->nurbs, err);
 808
 809        return err;
 810}
 811
 812/**
 813 * snd_usb_endpoint_start: start an snd_usb_endpoint
 814 *
 815 * @ep:         the endpoint to start
 816 * @can_sleep:  flag indicating whether the operation is executed in
 817 *              non-atomic context
 818 *
 819 * A call to this function will increment the use count of the endpoint.
 820 * In case it is not already running, the URBs for this endpoint will be
 821 * submitted. Otherwise, this function does nothing.
 822 *
 823 * Must be balanced to calls of snd_usb_endpoint_stop().
 824 *
 825 * Returns an error if the URB submission failed, 0 in all other cases.
 826 */
 827int snd_usb_endpoint_start(struct snd_usb_endpoint *ep, int can_sleep)
 828{
 829        int err;
 830        unsigned int i;
 831
 832        if (ep->chip->shutdown)
 833                return -EBADFD;
 834
 835        /* already running? */
 836        if (++ep->use_count != 1)
 837                return 0;
 838
 839        /* just to be sure */
 840        deactivate_urbs(ep, 0, can_sleep);
 841        if (can_sleep)
 842                wait_clear_urbs(ep);
 843
 844        ep->active_mask = 0;
 845        ep->unlink_mask = 0;
 846        ep->phase = 0;
 847
 848        snd_usb_endpoint_start_quirk(ep);
 849
 850        /*
 851         * If this endpoint has a data endpoint as implicit feedback source,
 852         * don't start the urbs here. Instead, mark them all as available,
 853         * wait for the record urbs to return and queue the playback urbs
 854         * from that context.
 855         */
 856
 857        set_bit(EP_FLAG_RUNNING, &ep->flags);
 858
 859        if (snd_usb_endpoint_implict_feedback_sink(ep)) {
 860                for (i = 0; i < ep->nurbs; i++) {
 861                        struct snd_urb_ctx *ctx = ep->urb + i;
 862                        list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
 863                }
 864
 865                return 0;
 866        }
 867
 868        for (i = 0; i < ep->nurbs; i++) {
 869                struct urb *urb = ep->urb[i].urb;
 870
 871                if (snd_BUG_ON(!urb))
 872                        goto __error;
 873
 874                if (usb_pipeout(ep->pipe)) {
 875                        prepare_outbound_urb(ep, urb->context);
 876                } else {
 877                        prepare_inbound_urb(ep, urb->context);
 878                }
 879
 880                err = usb_submit_urb(urb, GFP_ATOMIC);
 881                if (err < 0) {
 882                        snd_printk(KERN_ERR "cannot submit urb %d, error %d: %s\n",
 883                                   i, err, usb_error_string(err));
 884                        goto __error;
 885                }
 886                set_bit(i, &ep->active_mask);
 887        }
 888
 889        return 0;
 890
 891__error:
 892        clear_bit(EP_FLAG_RUNNING, &ep->flags);
 893        ep->use_count--;
 894        deactivate_urbs(ep, 0, 0);
 895        return -EPIPE;
 896}
 897
 898/**
 899 * snd_usb_endpoint_stop: stop an snd_usb_endpoint
 900 *
 901 * @ep: the endpoint to stop (may be NULL)
 902 *
 903 * A call to this function will decrement the use count of the endpoint.
 904 * In case the last user has requested the endpoint stop, the URBs will
 905 * actually be deactivated.
 906 *
 907 * Must be balanced to calls of snd_usb_endpoint_start().
 908 */
 909void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep,
 910                           int force, int can_sleep, int wait)
 911{
 912        if (!ep)
 913                return;
 914
 915        if (snd_BUG_ON(ep->use_count == 0))
 916                return;
 917
 918        if (--ep->use_count == 0) {
 919                deactivate_urbs(ep, force, can_sleep);
 920                ep->data_subs = NULL;
 921                ep->sync_slave = NULL;
 922                ep->retire_data_urb = NULL;
 923                ep->prepare_data_urb = NULL;
 924
 925                if (wait)
 926                        wait_clear_urbs(ep);
 927                else
 928                        set_bit(EP_FLAG_STOPPING, &ep->flags);
 929        }
 930}
 931
 932/**
 933 * snd_usb_endpoint_deactivate: deactivate an snd_usb_endpoint
 934 *
 935 * @ep: the endpoint to deactivate
 936 *
 937 * If the endpoint is not currently in use, this functions will select the
 938 * alternate interface setting 0 for the interface of this endpoint.
 939 *
 940 * In case of any active users, this functions does nothing.
 941 *
 942 * Returns an error if usb_set_interface() failed, 0 in all other
 943 * cases.
 944 */
 945int snd_usb_endpoint_deactivate(struct snd_usb_endpoint *ep)
 946{
 947        if (!ep)
 948                return -EINVAL;
 949
 950        deactivate_urbs(ep, 1, 1);
 951        wait_clear_urbs(ep);
 952
 953        if (ep->use_count != 0)
 954                return 0;
 955
 956        clear_bit(EP_FLAG_ACTIVATED, &ep->flags);
 957
 958        return 0;
 959}
 960
 961/**
 962 * snd_usb_endpoint_free: Free the resources of an snd_usb_endpoint
 963 *
 964 * @ep: the list header of the endpoint to free
 965 *
 966 * This function does not care for the endpoint's use count but will tear
 967 * down all the streaming URBs immediately and free all resources.
 968 */
 969void snd_usb_endpoint_free(struct list_head *head)
 970{
 971        struct snd_usb_endpoint *ep;
 972
 973        ep = list_entry(head, struct snd_usb_endpoint, list);
 974        release_urbs(ep, 1);
 975        kfree(ep);
 976}
 977
 978/**
 979 * snd_usb_handle_sync_urb: parse an USB sync packet
 980 *
 981 * @ep: the endpoint to handle the packet
 982 * @sender: the sending endpoint
 983 * @urb: the received packet
 984 *
 985 * This function is called from the context of an endpoint that received
 986 * the packet and is used to let another endpoint object handle the payload.
 987 */
 988void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
 989                             struct snd_usb_endpoint *sender,
 990                             const struct urb *urb)
 991{
 992        int shift;
 993        unsigned int f;
 994        unsigned long flags;
 995
 996        snd_BUG_ON(ep == sender);
 997
 998        /*
 999         * In case the endpoint is operating in implicit feedback mode, prepare
1000         * a new outbound URB that has the same layout as the received packet
1001         * and add it to the list of pending urbs. queue_pending_output_urbs()
1002         * will take care of them later.
1003         */
1004        if (snd_usb_endpoint_implict_feedback_sink(ep) &&
1005            ep->use_count != 0) {
1006
1007                /* implicit feedback case */
1008                int i, bytes = 0;
1009                struct snd_urb_ctx *in_ctx;
1010                struct snd_usb_packet_info *out_packet;
1011
1012                in_ctx = urb->context;
1013
1014                /* Count overall packet size */
1015                for (i = 0; i < in_ctx->packets; i++)
1016                        if (urb->iso_frame_desc[i].status == 0)
1017                                bytes += urb->iso_frame_desc[i].actual_length;
1018
1019                /*
1020                 * skip empty packets. At least M-Audio's Fast Track Ultra stops
1021                 * streaming once it received a 0-byte OUT URB
1022                 */
1023                if (bytes == 0)
1024                        return;
1025
1026                spin_lock_irqsave(&ep->lock, flags);
1027                out_packet = ep->next_packet + ep->next_packet_write_pos;
1028
1029                /*
1030                 * Iterate through the inbound packet and prepare the lengths
1031                 * for the output packet. The OUT packet we are about to send
1032                 * will have the same amount of payload bytes than the IN
1033                 * packet we just received.
1034                 */
1035
1036                out_packet->packets = in_ctx->packets;
1037                for (i = 0; i < in_ctx->packets; i++) {
1038                        if (urb->iso_frame_desc[i].status == 0)
1039                                out_packet->packet_size[i] =
1040                                        urb->iso_frame_desc[i].actual_length / ep->stride;
1041                        else
1042                                out_packet->packet_size[i] = 0;
1043                }
1044
1045                ep->next_packet_write_pos++;
1046                ep->next_packet_write_pos %= MAX_URBS;
1047                spin_unlock_irqrestore(&ep->lock, flags);
1048                queue_pending_output_urbs(ep);
1049
1050                return;
1051        }
1052
1053        /*
1054         * process after playback sync complete
1055         *
1056         * Full speed devices report feedback values in 10.14 format as samples
1057         * per frame, high speed devices in 16.16 format as samples per
1058         * microframe.
1059         *
1060         * Because the Audio Class 1 spec was written before USB 2.0, many high
1061         * speed devices use a wrong interpretation, some others use an
1062         * entirely different format.
1063         *
1064         * Therefore, we cannot predict what format any particular device uses
1065         * and must detect it automatically.
1066         */
1067
1068        if (urb->iso_frame_desc[0].status != 0 ||
1069            urb->iso_frame_desc[0].actual_length < 3)
1070                return;
1071
1072        f = le32_to_cpup(urb->transfer_buffer);
1073        if (urb->iso_frame_desc[0].actual_length == 3)
1074                f &= 0x00ffffff;
1075        else
1076                f &= 0x0fffffff;
1077
1078        if (f == 0)
1079                return;
1080
1081        if (unlikely(ep->freqshift == INT_MIN)) {
1082                /*
1083                 * The first time we see a feedback value, determine its format
1084                 * by shifting it left or right until it matches the nominal
1085                 * frequency value.  This assumes that the feedback does not
1086                 * differ from the nominal value more than +50% or -25%.
1087                 */
1088                shift = 0;
1089                while (f < ep->freqn - ep->freqn / 4) {
1090                        f <<= 1;
1091                        shift++;
1092                }
1093                while (f > ep->freqn + ep->freqn / 2) {
1094                        f >>= 1;
1095                        shift--;
1096                }
1097                ep->freqshift = shift;
1098        } else if (ep->freqshift >= 0)
1099                f <<= ep->freqshift;
1100        else
1101                f >>= -ep->freqshift;
1102
1103        if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) {
1104                /*
1105                 * If the frequency looks valid, set it.
1106                 * This value is referred to in prepare_playback_urb().
1107                 */
1108                spin_lock_irqsave(&ep->lock, flags);
1109                ep->freqm = f;
1110                spin_unlock_irqrestore(&ep->lock, flags);
1111        } else {
1112                /*
1113                 * Out of range; maybe the shift value is wrong.
1114                 * Reset it so that we autodetect again the next time.
1115                 */
1116                ep->freqshift = INT_MIN;
1117        }
1118}
1119
1120
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.