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