linux/sound/usb/pcm.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#include <linux/init.h>
  18#include <linux/slab.h>
  19#include <linux/ratelimit.h>
  20#include <linux/usb.h>
  21#include <linux/usb/audio.h>
  22#include <linux/usb/audio-v2.h>
  23
  24#include <sound/core.h>
  25#include <sound/pcm.h>
  26#include <sound/pcm_params.h>
  27
  28#include "usbaudio.h"
  29#include "card.h"
  30#include "quirks.h"
  31#include "debug.h"
  32#include "endpoint.h"
  33#include "helper.h"
  34#include "pcm.h"
  35#include "clock.h"
  36#include "power.h"
  37
  38#define SUBSTREAM_FLAG_DATA_EP_STARTED  0
  39#define SUBSTREAM_FLAG_SYNC_EP_STARTED  1
  40
  41/* return the estimated delay based on USB frame counters */
  42snd_pcm_uframes_t snd_usb_pcm_delay(struct snd_usb_substream *subs,
  43                                    unsigned int rate)
  44{
  45        int current_frame_number;
  46        int frame_diff;
  47        int est_delay;
  48
  49        current_frame_number = usb_get_current_frame_number(subs->dev);
  50        /*
  51         * HCD implementations use different widths, use lower 8 bits.
  52         * The delay will be managed up to 256ms, which is more than
  53         * enough
  54         */
  55        frame_diff = (current_frame_number - subs->last_frame_number) & 0xff;
  56
  57        /* Approximation based on number of samples per USB frame (ms),
  58           some truncation for 44.1 but the estimate is good enough */
  59        est_delay =  subs->last_delay - (frame_diff * rate / 1000);
  60        if (est_delay < 0)
  61                est_delay = 0;
  62        return est_delay;
  63}
  64
  65/*
  66 * return the current pcm pointer.  just based on the hwptr_done value.
  67 */
  68static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream)
  69{
  70        struct snd_usb_substream *subs;
  71        unsigned int hwptr_done;
  72
  73        subs = (struct snd_usb_substream *)substream->runtime->private_data;
  74        if (subs->stream->chip->shutdown)
  75                return SNDRV_PCM_POS_XRUN;
  76        spin_lock(&subs->lock);
  77        hwptr_done = subs->hwptr_done;
  78        substream->runtime->delay = snd_usb_pcm_delay(subs,
  79                                                substream->runtime->rate);
  80        spin_unlock(&subs->lock);
  81        return hwptr_done / (substream->runtime->frame_bits >> 3);
  82}
  83
  84/*
  85 * find a matching audio format
  86 */
  87static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned int format,
  88                                       unsigned int rate, unsigned int channels)
  89{
  90        struct list_head *p;
  91        struct audioformat *found = NULL;
  92        int cur_attr = 0, attr;
  93
  94        list_for_each(p, &subs->fmt_list) {
  95                struct audioformat *fp;
  96                fp = list_entry(p, struct audioformat, list);
  97                if (!(fp->formats & (1uLL << format)))
  98                        continue;
  99                if (fp->channels != channels)
 100                        continue;
 101                if (rate < fp->rate_min || rate > fp->rate_max)
 102                        continue;
 103                if (! (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) {
 104                        unsigned int i;
 105                        for (i = 0; i < fp->nr_rates; i++)
 106                                if (fp->rate_table[i] == rate)
 107                                        break;
 108                        if (i >= fp->nr_rates)
 109                                continue;
 110                }
 111                attr = fp->ep_attr & USB_ENDPOINT_SYNCTYPE;
 112                if (! found) {
 113                        found = fp;
 114                        cur_attr = attr;
 115                        continue;
 116                }
 117                /* avoid async out and adaptive in if the other method
 118                 * supports the same format.
 119                 * this is a workaround for the case like
 120                 * M-audio audiophile USB.
 121                 */
 122                if (attr != cur_attr) {
 123                        if ((attr == USB_ENDPOINT_SYNC_ASYNC &&
 124                             subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
 125                            (attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
 126                             subs->direction == SNDRV_PCM_STREAM_CAPTURE))
 127                                continue;
 128                        if ((cur_attr == USB_ENDPOINT_SYNC_ASYNC &&
 129                             subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
 130                            (cur_attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
 131                             subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
 132                                found = fp;
 133                                cur_attr = attr;
 134                                continue;
 135                        }
 136                }
 137                /* find the format with the largest max. packet size */
 138                if (fp->maxpacksize > found->maxpacksize) {
 139                        found = fp;
 140                        cur_attr = attr;
 141                }
 142        }
 143        return found;
 144}
 145
 146static int init_pitch_v1(struct snd_usb_audio *chip, int iface,
 147                         struct usb_host_interface *alts,
 148                         struct audioformat *fmt)
 149{
 150        struct usb_device *dev = chip->dev;
 151        unsigned int ep;
 152        unsigned char data[1];
 153        int err;
 154
 155        ep = get_endpoint(alts, 0)->bEndpointAddress;
 156
 157        data[0] = 1;
 158        if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
 159                                   USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
 160                                   UAC_EP_CS_ATTR_PITCH_CONTROL << 8, ep,
 161                                   data, sizeof(data))) < 0) {
 162                snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
 163                           dev->devnum, iface, ep);
 164                return err;
 165        }
 166
 167        return 0;
 168}
 169
 170static int init_pitch_v2(struct snd_usb_audio *chip, int iface,
 171                         struct usb_host_interface *alts,
 172                         struct audioformat *fmt)
 173{
 174        struct usb_device *dev = chip->dev;
 175        unsigned char data[1];
 176        unsigned int ep;
 177        int err;
 178
 179        ep = get_endpoint(alts, 0)->bEndpointAddress;
 180
 181        data[0] = 1;
 182        if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR,
 183                                   USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,
 184                                   UAC2_EP_CS_PITCH << 8, 0,
 185                                   data, sizeof(data))) < 0) {
 186                snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH (v2)\n",
 187                           dev->devnum, iface, fmt->altsetting);
 188                return err;
 189        }
 190
 191        return 0;
 192}
 193
 194/*
 195 * initialize the pitch control and sample rate
 196 */
 197int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface,
 198                       struct usb_host_interface *alts,
 199                       struct audioformat *fmt)
 200{
 201        struct usb_interface_descriptor *altsd = get_iface_desc(alts);
 202
 203        /* if endpoint doesn't have pitch control, bail out */
 204        if (!(fmt->attributes & UAC_EP_CS_ATTR_PITCH_CONTROL))
 205                return 0;
 206
 207        switch (altsd->bInterfaceProtocol) {
 208        case UAC_VERSION_1:
 209        default:
 210                return init_pitch_v1(chip, iface, alts, fmt);
 211
 212        case UAC_VERSION_2:
 213                return init_pitch_v2(chip, iface, alts, fmt);
 214        }
 215}
 216
 217static int start_endpoints(struct snd_usb_substream *subs, int can_sleep)
 218{
 219        int err;
 220
 221        if (!subs->data_endpoint)
 222                return -EINVAL;
 223
 224        if (!test_and_set_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags)) {
 225                struct snd_usb_endpoint *ep = subs->data_endpoint;
 226
 227                snd_printdd(KERN_DEBUG "Starting data EP @%p\n", ep);
 228
 229                ep->data_subs = subs;
 230                err = snd_usb_endpoint_start(ep, can_sleep);
 231                if (err < 0) {
 232                        clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags);
 233                        return err;
 234                }
 235        }
 236
 237        if (subs->sync_endpoint &&
 238            !test_and_set_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags)) {
 239                struct snd_usb_endpoint *ep = subs->sync_endpoint;
 240
 241                if (subs->data_endpoint->iface != subs->sync_endpoint->iface ||
 242                    subs->data_endpoint->alt_idx != subs->sync_endpoint->alt_idx) {
 243                        err = usb_set_interface(subs->dev,
 244                                                subs->sync_endpoint->iface,
 245                                                subs->sync_endpoint->alt_idx);
 246                        if (err < 0) {
 247                                snd_printk(KERN_ERR
 248                                           "%d:%d:%d: cannot set interface (%d)\n",
 249                                           subs->dev->devnum,
 250                                           subs->sync_endpoint->iface,
 251                                           subs->sync_endpoint->alt_idx, err);
 252                                return -EIO;
 253                        }
 254                }
 255
 256                snd_printdd(KERN_DEBUG "Starting sync EP @%p\n", ep);
 257
 258                ep->sync_slave = subs->data_endpoint;
 259                err = snd_usb_endpoint_start(ep, can_sleep);
 260                if (err < 0) {
 261                        clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags);
 262                        return err;
 263                }
 264        }
 265
 266        return 0;
 267}
 268
 269static void stop_endpoints(struct snd_usb_substream *subs,
 270                           int force, int can_sleep, int wait)
 271{
 272        if (test_and_clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags))
 273                snd_usb_endpoint_stop(subs->sync_endpoint,
 274                                      force, can_sleep, wait);
 275
 276        if (test_and_clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags))
 277                snd_usb_endpoint_stop(subs->data_endpoint,
 278                                      force, can_sleep, wait);
 279}
 280
 281static int deactivate_endpoints(struct snd_usb_substream *subs)
 282{
 283        int reta, retb;
 284
 285        reta = snd_usb_endpoint_deactivate(subs->sync_endpoint);
 286        retb = snd_usb_endpoint_deactivate(subs->data_endpoint);
 287
 288        if (reta < 0)
 289                return reta;
 290
 291        if (retb < 0)
 292                return retb;
 293
 294        return 0;
 295}
 296
 297/*
 298 * find a matching format and set up the interface
 299 */
 300static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
 301{
 302        struct usb_device *dev = subs->dev;
 303        struct usb_host_interface *alts;
 304        struct usb_interface_descriptor *altsd;
 305        struct usb_interface *iface;
 306        unsigned int ep, attr;
 307        int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
 308        int err, implicit_fb = 0;
 309
 310        iface = usb_ifnum_to_if(dev, fmt->iface);
 311        if (WARN_ON(!iface))
 312                return -EINVAL;
 313        alts = &iface->altsetting[fmt->altset_idx];
 314        altsd = get_iface_desc(alts);
 315        if (WARN_ON(altsd->bAlternateSetting != fmt->altsetting))
 316                return -EINVAL;
 317
 318        if (fmt == subs->cur_audiofmt)
 319                return 0;
 320
 321        /* close the old interface */
 322        if (subs->interface >= 0 && subs->interface != fmt->iface) {
 323                err = usb_set_interface(subs->dev, subs->interface, 0);
 324                if (err < 0) {
 325                        snd_printk(KERN_ERR "%d:%d:%d: return to setting 0 failed (%d)\n",
 326                                dev->devnum, fmt->iface, fmt->altsetting, err);
 327                        return -EIO;
 328                }
 329                subs->interface = -1;
 330                subs->altset_idx = 0;
 331        }
 332
 333        /* set interface */
 334        if (subs->interface != fmt->iface ||
 335            subs->altset_idx != fmt->altset_idx) {
 336                err = usb_set_interface(dev, fmt->iface, fmt->altsetting);
 337                if (err < 0) {
 338                        snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed (%d)\n",
 339                                   dev->devnum, fmt->iface, fmt->altsetting, err);
 340                        return -EIO;
 341                }
 342                snd_printdd(KERN_INFO "setting usb interface %d:%d\n",
 343                                fmt->iface, fmt->altsetting);
 344                subs->interface = fmt->iface;
 345                subs->altset_idx = fmt->altset_idx;
 346        }
 347
 348        subs->data_endpoint = snd_usb_add_endpoint(subs->stream->chip,
 349                                                   alts, fmt->endpoint, subs->direction,
 350                                                   SND_USB_ENDPOINT_TYPE_DATA);
 351        if (!subs->data_endpoint)
 352                return -EINVAL;
 353
 354        /* we need a sync pipe in async OUT or adaptive IN mode */
 355        /* check the number of EP, since some devices have broken
 356         * descriptors which fool us.  if it has only one EP,
 357         * assume it as adaptive-out or sync-in.
 358         */
 359        attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE;
 360
 361        switch (subs->stream->chip->usb_id) {
 362        case USB_ID(0x0763, 0x2080): /* M-Audio FastTrack Ultra */
 363        case USB_ID(0x0763, 0x2081):
 364                if (is_playback) {
 365                        implicit_fb = 1;
 366                        ep = 0x81;
 367                        iface = usb_ifnum_to_if(dev, 2);
 368
 369                        if (!iface || iface->num_altsetting == 0)
 370                                return -EINVAL;
 371
 372                        alts = &iface->altsetting[1];
 373                        goto add_sync_ep;
 374                }
 375        }
 376
 377        if (((is_playback && attr == USB_ENDPOINT_SYNC_ASYNC) ||
 378             (!is_playback && attr == USB_ENDPOINT_SYNC_ADAPTIVE)) &&
 379            altsd->bNumEndpoints >= 2) {
 380                /* check sync-pipe endpoint */
 381                /* ... and check descriptor size before accessing bSynchAddress
 382                   because there is a version of the SB Audigy 2 NX firmware lacking
 383                   the audio fields in the endpoint descriptors */
 384                if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 0x01 ||
 385                    (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
 386                     get_endpoint(alts, 1)->bSynchAddress != 0 &&
 387                     !implicit_fb)) {
 388                        snd_printk(KERN_ERR "%d:%d:%d : invalid sync pipe. bmAttributes %02x, bLength %d, bSynchAddress %02x\n",
 389                                   dev->devnum, fmt->iface, fmt->altsetting,
 390                                   get_endpoint(alts, 1)->bmAttributes,
 391                                   get_endpoint(alts, 1)->bLength,
 392                                   get_endpoint(alts, 1)->bSynchAddress);
 393                        return -EINVAL;
 394                }
 395                ep = get_endpoint(alts, 1)->bEndpointAddress;
 396                if (!implicit_fb &&
 397                    get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
 398                    (( is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
 399                     (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
 400                        snd_printk(KERN_ERR "%d:%d:%d : invalid sync pipe. is_playback %d, ep %02x, bSynchAddress %02x\n",
 401                                   dev->devnum, fmt->iface, fmt->altsetting,
 402                                   is_playback, ep, get_endpoint(alts, 0)->bSynchAddress);
 403                        return -EINVAL;
 404                }
 405
 406                implicit_fb = (get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_USAGE_MASK)
 407                                == USB_ENDPOINT_USAGE_IMPLICIT_FB;
 408
 409add_sync_ep:
 410                subs->sync_endpoint = snd_usb_add_endpoint(subs->stream->chip,
 411                                                           alts, ep, !subs->direction,
 412                                                           implicit_fb ?
 413                                                                SND_USB_ENDPOINT_TYPE_DATA :
 414                                                                SND_USB_ENDPOINT_TYPE_SYNC);
 415                if (!subs->sync_endpoint)
 416                        return -EINVAL;
 417
 418                subs->data_endpoint->sync_master = subs->sync_endpoint;
 419        }
 420
 421        if ((err = snd_usb_init_pitch(subs->stream->chip, fmt->iface, alts, fmt)) < 0)
 422                return err;
 423
 424        subs->cur_audiofmt = fmt;
 425
 426        snd_usb_set_format_quirk(subs, fmt);
 427
 428#if 0
 429        printk(KERN_DEBUG
 430               "setting done: format = %d, rate = %d..%d, channels = %d\n",
 431               fmt->format, fmt->rate_min, fmt->rate_max, fmt->channels);
 432        printk(KERN_DEBUG
 433               "  datapipe = 0x%0x, syncpipe = 0x%0x\n",
 434               subs->datapipe, subs->syncpipe);
 435#endif
 436
 437        return 0;
 438}
 439
 440/*
 441 * hw_params callback
 442 *
 443 * allocate a buffer and set the given audio format.
 444 *
 445 * so far we use a physically linear buffer although packetize transfer
 446 * doesn't need a continuous area.
 447 * if sg buffer is supported on the later version of alsa, we'll follow
 448 * that.
 449 */
 450static int snd_usb_hw_params(struct snd_pcm_substream *substream,
 451                             struct snd_pcm_hw_params *hw_params)
 452{
 453        struct snd_usb_substream *subs = substream->runtime->private_data;
 454        struct audioformat *fmt;
 455        unsigned int channels, rate, format;
 456        int ret, changed;
 457
 458        ret = snd_pcm_lib_alloc_vmalloc_buffer(substream,
 459                                               params_buffer_bytes(hw_params));
 460        if (ret < 0)
 461                return ret;
 462
 463        format = params_format(hw_params);
 464        rate = params_rate(hw_params);
 465        channels = params_channels(hw_params);
 466        fmt = find_format(subs, format, rate, channels);
 467        if (!fmt) {
 468                snd_printd(KERN_DEBUG "cannot set format: format = %#x, rate = %d, channels = %d\n",
 469                           format, rate, channels);
 470                return -EINVAL;
 471        }
 472
 473        changed = subs->cur_audiofmt != fmt ||
 474                subs->period_bytes != params_period_bytes(hw_params) ||
 475                subs->cur_rate != rate;
 476
 477        down_read(&subs->stream->chip->shutdown_rwsem);
 478        if (subs->stream->chip->shutdown) {
 479                ret = -ENODEV;
 480                goto unlock;
 481        }
 482        if ((ret = set_format(subs, fmt)) < 0)
 483                goto unlock;
 484
 485        if (subs->cur_rate != rate) {
 486                struct usb_host_interface *alts;
 487                struct usb_interface *iface;
 488                iface = usb_ifnum_to_if(subs->dev, fmt->iface);
 489                alts = &iface->altsetting[fmt->altset_idx];
 490                ret = snd_usb_init_sample_rate(subs->stream->chip, fmt->iface, alts, fmt, rate);
 491                if (ret < 0)
 492                        goto unlock;
 493                subs->cur_rate = rate;
 494        }
 495
 496        if (changed) {
 497                /* format changed */
 498                stop_endpoints(subs, 0, 0, 0);
 499                ret = snd_usb_endpoint_set_params(subs->data_endpoint, hw_params, fmt,
 500                                                  subs->sync_endpoint);
 501                if (ret < 0)
 502                        goto unlock;
 503
 504                if (subs->sync_endpoint)
 505                        ret = snd_usb_endpoint_set_params(subs->sync_endpoint,
 506                                                          hw_params, fmt, NULL);
 507        }
 508
 509        if (ret == 0) {
 510                subs->interface = fmt->iface;
 511                subs->altset_idx = fmt->altset_idx;
 512        }
 513
 514unlock:
 515        up_read(&subs->stream->chip->shutdown_rwsem);
 516        return ret;
 517}
 518
 519/*
 520 * hw_free callback
 521 *
 522 * reset the audio format and release the buffer
 523 */
 524static int snd_usb_hw_free(struct snd_pcm_substream *substream)
 525{
 526        struct snd_usb_substream *subs = substream->runtime->private_data;
 527
 528        subs->cur_audiofmt = NULL;
 529        subs->cur_rate = 0;
 530        subs->period_bytes = 0;
 531        down_read(&subs->stream->chip->shutdown_rwsem);
 532        if (!subs->stream->chip->shutdown) {
 533                stop_endpoints(subs, 0, 1, 1);
 534                deactivate_endpoints(subs);
 535        }
 536        up_read(&subs->stream->chip->shutdown_rwsem);
 537        return snd_pcm_lib_free_vmalloc_buffer(substream);
 538}
 539
 540/*
 541 * prepare callback
 542 *
 543 * only a few subtle things...
 544 */
 545static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream)
 546{
 547        struct snd_pcm_runtime *runtime = substream->runtime;
 548        struct snd_usb_substream *subs = runtime->private_data;
 549        int ret = 0;
 550
 551        if (! subs->cur_audiofmt) {
 552                snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
 553                return -ENXIO;
 554        }
 555
 556        down_read(&subs->stream->chip->shutdown_rwsem);
 557        if (subs->stream->chip->shutdown) {
 558                ret = -ENODEV;
 559                goto unlock;
 560        }
 561        if (snd_BUG_ON(!subs->data_endpoint)) {
 562                ret = -EIO;
 563                goto unlock;
 564        }
 565
 566        snd_usb_endpoint_sync_pending_stop(subs->sync_endpoint);
 567        snd_usb_endpoint_sync_pending_stop(subs->data_endpoint);
 568
 569        /* some unit conversions in runtime */
 570        subs->data_endpoint->maxframesize =
 571                bytes_to_frames(runtime, subs->data_endpoint->maxpacksize);
 572        subs->data_endpoint->curframesize =
 573                bytes_to_frames(runtime, subs->data_endpoint->curpacksize);
 574
 575        /* reset the pointer */
 576        subs->hwptr_done = 0;
 577        subs->transfer_done = 0;
 578        subs->last_delay = 0;
 579        subs->last_frame_number = 0;
 580        runtime->delay = 0;
 581
 582        /* for playback, submit the URBs now; otherwise, the first hwptr_done
 583         * updates for all URBs would happen at the same time when starting */
 584        if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK)
 585                ret = start_endpoints(subs, 1);
 586
 587 unlock:
 588        up_read(&subs->stream->chip->shutdown_rwsem);
 589        return ret;
 590}
 591
 592static struct snd_pcm_hardware snd_usb_hardware =
 593{
 594        .info =                 SNDRV_PCM_INFO_MMAP |
 595                                SNDRV_PCM_INFO_MMAP_VALID |
 596                                SNDRV_PCM_INFO_BATCH |
 597                                SNDRV_PCM_INFO_INTERLEAVED |
 598                                SNDRV_PCM_INFO_BLOCK_TRANSFER |
 599                                SNDRV_PCM_INFO_PAUSE,
 600        .buffer_bytes_max =     1024 * 1024,
 601        .period_bytes_min =     64,
 602        .period_bytes_max =     512 * 1024,
 603        .periods_min =          2,
 604        .periods_max =          1024,
 605};
 606
 607static int hw_check_valid_format(struct snd_usb_substream *subs,
 608                                 struct snd_pcm_hw_params *params,
 609                                 struct audioformat *fp)
 610{
 611        struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
 612        struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
 613        struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 614        struct snd_interval *pt = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
 615        struct snd_mask check_fmts;
 616        unsigned int ptime;
 617
 618        /* check the format */
 619        snd_mask_none(&check_fmts);
 620        check_fmts.bits[0] = (u32)fp->formats;
 621        check_fmts.bits[1] = (u32)(fp->formats >> 32);
 622        snd_mask_intersect(&check_fmts, fmts);
 623        if (snd_mask_empty(&check_fmts)) {
 624                hwc_debug("   > check: no supported format %d\n", fp->format);
 625                return 0;
 626        }
 627        /* check the channels */
 628        if (fp->channels < ct->min || fp->channels > ct->max) {
 629                hwc_debug("   > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max);
 630                return 0;
 631        }
 632        /* check the rate is within the range */
 633        if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) {
 634                hwc_debug("   > check: rate_min %d > max %d\n", fp->rate_min, it->max);
 635                return 0;
 636        }
 637        if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) {
 638                hwc_debug("   > check: rate_max %d < min %d\n", fp->rate_max, it->min);
 639                return 0;
 640        }
 641        /* check whether the period time is >= the data packet interval */
 642        if (subs->speed != USB_SPEED_FULL) {
 643                ptime = 125 * (1 << fp->datainterval);
 644                if (ptime > pt->max || (ptime == pt->max && pt->openmax)) {
 645                        hwc_debug("   > check: ptime %u > max %u\n", ptime, pt->max);
 646                        return 0;
 647                }
 648        }
 649        return 1;
 650}
 651
 652static int hw_rule_rate(struct snd_pcm_hw_params *params,
 653                        struct snd_pcm_hw_rule *rule)
 654{
 655        struct snd_usb_substream *subs = rule->private;
 656        struct list_head *p;
 657        struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
 658        unsigned int rmin, rmax;
 659        int changed;
 660
 661        hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max);
 662        changed = 0;
 663        rmin = rmax = 0;
 664        list_for_each(p, &subs->fmt_list) {
 665                struct audioformat *fp;
 666                fp = list_entry(p, struct audioformat, list);
 667                if (!hw_check_valid_format(subs, params, fp))
 668                        continue;
 669                if (changed++) {
 670                        if (rmin > fp->rate_min)
 671                                rmin = fp->rate_min;
 672                        if (rmax < fp->rate_max)
 673                                rmax = fp->rate_max;
 674                } else {
 675                        rmin = fp->rate_min;
 676                        rmax = fp->rate_max;
 677                }
 678        }
 679
 680        if (!changed) {
 681                hwc_debug("  --> get empty\n");
 682                it->empty = 1;
 683                return -EINVAL;
 684        }
 685
 686        changed = 0;
 687        if (it->min < rmin) {
 688                it->min = rmin;
 689                it->openmin = 0;
 690                changed = 1;
 691        }
 692        if (it->max > rmax) {
 693                it->max = rmax;
 694                it->openmax = 0;
 695                changed = 1;
 696        }
 697        if (snd_interval_checkempty(it)) {
 698                it->empty = 1;
 699                return -EINVAL;
 700        }
 701        hwc_debug("  --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
 702        return changed;
 703}
 704
 705
 706static int hw_rule_channels(struct snd_pcm_hw_params *params,
 707                            struct snd_pcm_hw_rule *rule)
 708{
 709        struct snd_usb_substream *subs = rule->private;
 710        struct list_head *p;
 711        struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
 712        unsigned int rmin, rmax;
 713        int changed;
 714
 715        hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max);
 716        changed = 0;
 717        rmin = rmax = 0;
 718        list_for_each(p, &subs->fmt_list) {
 719                struct audioformat *fp;
 720                fp = list_entry(p, struct audioformat, list);
 721                if (!hw_check_valid_format(subs, params, fp))
 722                        continue;
 723                if (changed++) {
 724                        if (rmin > fp->channels)
 725                                rmin = fp->channels;
 726                        if (rmax < fp->channels)
 727                                rmax = fp->channels;
 728                } else {
 729                        rmin = fp->channels;
 730                        rmax = fp->channels;
 731                }
 732        }
 733
 734        if (!changed) {
 735                hwc_debug("  --> get empty\n");
 736                it->empty = 1;
 737                return -EINVAL;
 738        }
 739
 740        changed = 0;
 741        if (it->min < rmin) {
 742                it->min = rmin;
 743                it->openmin = 0;
 744                changed = 1;
 745        }
 746        if (it->max > rmax) {
 747                it->max = rmax;
 748                it->openmax = 0;
 749                changed = 1;
 750        }
 751        if (snd_interval_checkempty(it)) {
 752                it->empty = 1;
 753                return -EINVAL;
 754        }
 755        hwc_debug("  --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
 756        return changed;
 757}
 758
 759static int hw_rule_format(struct snd_pcm_hw_params *params,
 760                          struct snd_pcm_hw_rule *rule)
 761{
 762        struct snd_usb_substream *subs = rule->private;
 763        struct list_head *p;
 764        struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 765        u64 fbits;
 766        u32 oldbits[2];
 767        int changed;
 768
 769        hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]);
 770        fbits = 0;
 771        list_for_each(p, &subs->fmt_list) {
 772                struct audioformat *fp;
 773                fp = list_entry(p, struct audioformat, list);
 774                if (!hw_check_valid_format(subs, params, fp))
 775                        continue;
 776                fbits |= fp->formats;
 777        }
 778
 779        oldbits[0] = fmt->bits[0];
 780        oldbits[1] = fmt->bits[1];
 781        fmt->bits[0] &= (u32)fbits;
 782        fmt->bits[1] &= (u32)(fbits >> 32);
 783        if (!fmt->bits[0] && !fmt->bits[1]) {
 784                hwc_debug("  --> get empty\n");
 785                return -EINVAL;
 786        }
 787        changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]);
 788        hwc_debug("  --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed);
 789        return changed;
 790}
 791
 792static int hw_rule_period_time(struct snd_pcm_hw_params *params,
 793                               struct snd_pcm_hw_rule *rule)
 794{
 795        struct snd_usb_substream *subs = rule->private;
 796        struct audioformat *fp;
 797        struct snd_interval *it;
 798        unsigned char min_datainterval;
 799        unsigned int pmin;
 800        int changed;
 801
 802        it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
 803        hwc_debug("hw_rule_period_time: (%u,%u)\n", it->min, it->max);
 804        min_datainterval = 0xff;
 805        list_for_each_entry(fp, &subs->fmt_list, list) {
 806                if (!hw_check_valid_format(subs, params, fp))
 807                        continue;
 808                min_datainterval = min(min_datainterval, fp->datainterval);
 809        }
 810        if (min_datainterval == 0xff) {
 811                hwc_debug("  --> get empty\n");
 812                it->empty = 1;
 813                return -EINVAL;
 814        }
 815        pmin = 125 * (1 << min_datainterval);
 816        changed = 0;
 817        if (it->min < pmin) {
 818                it->min = pmin;
 819                it->openmin = 0;
 820                changed = 1;
 821        }
 822        if (snd_interval_checkempty(it)) {
 823                it->empty = 1;
 824                return -EINVAL;
 825        }
 826        hwc_debug("  --> (%u,%u) (changed = %d)\n", it->min, it->max, changed);
 827        return changed;
 828}
 829
 830/*
 831 *  If the device supports unusual bit rates, does the request meet these?
 832 */
 833static int snd_usb_pcm_check_knot(struct snd_pcm_runtime *runtime,
 834                                  struct snd_usb_substream *subs)
 835{
 836        struct audioformat *fp;
 837        int *rate_list;
 838        int count = 0, needs_knot = 0;
 839        int err;
 840
 841        kfree(subs->rate_list.list);
 842        subs->rate_list.list = NULL;
 843
 844        list_for_each_entry(fp, &subs->fmt_list, list) {
 845                if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)
 846                        return 0;
 847                count += fp->nr_rates;
 848                if (fp->rates & SNDRV_PCM_RATE_KNOT)
 849                        needs_knot = 1;
 850        }
 851        if (!needs_knot)
 852                return 0;
 853
 854        subs->rate_list.list = rate_list =
 855                kmalloc(sizeof(int) * count, GFP_KERNEL);
 856        if (!subs->rate_list.list)
 857                return -ENOMEM;
 858        subs->rate_list.count = count;
 859        subs->rate_list.mask = 0;
 860        count = 0;
 861        list_for_each_entry(fp, &subs->fmt_list, list) {
 862                int i;
 863                for (i = 0; i < fp->nr_rates; i++)
 864                        rate_list[count++] = fp->rate_table[i];
 865        }
 866        err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 867                                         &subs->rate_list);
 868        if (err < 0)
 869                return err;
 870
 871        return 0;
 872}
 873
 874
 875/*
 876 * set up the runtime hardware information.
 877 */
 878
 879static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs)
 880{
 881        struct list_head *p;
 882        unsigned int pt, ptmin;
 883        int param_period_time_if_needed;
 884        int err;
 885
 886        runtime->hw.formats = subs->formats;
 887
 888        runtime->hw.rate_min = 0x7fffffff;
 889        runtime->hw.rate_max = 0;
 890        runtime->hw.channels_min = 256;
 891        runtime->hw.channels_max = 0;
 892        runtime->hw.rates = 0;
 893        ptmin = UINT_MAX;
 894        /* check min/max rates and channels */
 895        list_for_each(p, &subs->fmt_list) {
 896                struct audioformat *fp;
 897                fp = list_entry(p, struct audioformat, list);
 898                runtime->hw.rates |= fp->rates;
 899                if (runtime->hw.rate_min > fp->rate_min)
 900                        runtime->hw.rate_min = fp->rate_min;
 901                if (runtime->hw.rate_max < fp->rate_max)
 902                        runtime->hw.rate_max = fp->rate_max;
 903                if (runtime->hw.channels_min > fp->channels)
 904                        runtime->hw.channels_min = fp->channels;
 905                if (runtime->hw.channels_max < fp->channels)
 906                        runtime->hw.channels_max = fp->channels;
 907                if (fp->fmt_type == UAC_FORMAT_TYPE_II && fp->frame_size > 0) {
 908                        /* FIXME: there might be more than one audio formats... */
 909                        runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
 910                                fp->frame_size;
 911                }
 912                pt = 125 * (1 << fp->datainterval);
 913                ptmin = min(ptmin, pt);
 914        }
 915        err = snd_usb_autoresume(subs->stream->chip);
 916        if (err < 0)
 917                return err;
 918
 919        param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME;
 920        if (subs->speed == USB_SPEED_FULL)
 921                /* full speed devices have fixed data packet interval */
 922                ptmin = 1000;
 923        if (ptmin == 1000)
 924                /* if period time doesn't go below 1 ms, no rules needed */
 925                param_period_time_if_needed = -1;
 926        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
 927                                     ptmin, UINT_MAX);
 928
 929        if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 930                                       hw_rule_rate, subs,
 931                                       SNDRV_PCM_HW_PARAM_FORMAT,
 932                                       SNDRV_PCM_HW_PARAM_CHANNELS,
 933                                       param_period_time_if_needed,
 934                                       -1)) < 0)
 935                goto rep_err;
 936        if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
 937                                       hw_rule_channels, subs,
 938                                       SNDRV_PCM_HW_PARAM_FORMAT,
 939                                       SNDRV_PCM_HW_PARAM_RATE,
 940                                       param_period_time_if_needed,
 941                                       -1)) < 0)
 942                goto rep_err;
 943        if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
 944                                       hw_rule_format, subs,
 945                                       SNDRV_PCM_HW_PARAM_RATE,
 946                                       SNDRV_PCM_HW_PARAM_CHANNELS,
 947                                       param_period_time_if_needed,
 948                                       -1)) < 0)
 949                goto rep_err;
 950        if (param_period_time_if_needed >= 0) {
 951                err = snd_pcm_hw_rule_add(runtime, 0,
 952                                          SNDRV_PCM_HW_PARAM_PERIOD_TIME,
 953                                          hw_rule_period_time, subs,
 954                                          SNDRV_PCM_HW_PARAM_FORMAT,
 955                                          SNDRV_PCM_HW_PARAM_CHANNELS,
 956                                          SNDRV_PCM_HW_PARAM_RATE,
 957                                          -1);
 958                if (err < 0)
 959                        goto rep_err;
 960        }
 961        if ((err = snd_usb_pcm_check_knot(runtime, subs)) < 0)
 962                goto rep_err;
 963        return 0;
 964
 965rep_err:
 966        snd_usb_autosuspend(subs->stream->chip);
 967        return err;
 968}
 969
 970static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction)
 971{
 972        struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
 973        struct snd_pcm_runtime *runtime = substream->runtime;
 974        struct snd_usb_substream *subs = &as->substream[direction];
 975
 976        subs->interface = -1;
 977        subs->altset_idx = 0;
 978        runtime->hw = snd_usb_hardware;
 979        runtime->private_data = subs;
 980        subs->pcm_substream = substream;
 981        /* runtime PM is also done there */
 982        return setup_hw_info(runtime, subs);
 983}
 984
 985static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction)
 986{
 987        struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
 988        struct snd_usb_substream *subs = &as->substream[direction];
 989
 990        stop_endpoints(subs, 0, 0, 0);
 991
 992        if (!as->chip->shutdown && subs->interface >= 0) {
 993                usb_set_interface(subs->dev, subs->interface, 0);
 994                subs->interface = -1;
 995        }
 996
 997        subs->pcm_substream = NULL;
 998        snd_usb_autosuspend(subs->stream->chip);
 999
1000        return 0;
1001}
1002
1003/* Since a URB can handle only a single linear buffer, we must use double
1004 * buffering when the data to be transferred overflows the buffer boundary.
1005 * To avoid inconsistencies when updating hwptr_done, we use double buffering
1006 * for all URBs.
1007 */
1008static void retire_capture_urb(struct snd_usb_substream *subs,
1009                               struct urb *urb)
1010{
1011        struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
1012        unsigned int stride, frames, bytes, oldptr;
1013        int i, period_elapsed = 0;
1014        unsigned long flags;
1015        unsigned char *cp;
1016
1017        stride = runtime->frame_bits >> 3;
1018
1019        for (i = 0; i < urb->number_of_packets; i++) {
1020                cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
1021                if (urb->iso_frame_desc[i].status && printk_ratelimit()) {
1022                        snd_printdd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
1023                        // continue;
1024                }
1025                bytes = urb->iso_frame_desc[i].actual_length;
1026                frames = bytes / stride;
1027                if (!subs->txfr_quirk)
1028                        bytes = frames * stride;
1029                if (bytes % (runtime->sample_bits >> 3) != 0) {
1030#ifdef CONFIG_SND_DEBUG_VERBOSE
1031                        int oldbytes = bytes;
1032#endif
1033                        bytes = frames * stride;
1034                        snd_printdd(KERN_ERR "Corrected urb data len. %d->%d\n",
1035                                                        oldbytes, bytes);
1036                }
1037                /* update the current pointer */
1038                spin_lock_irqsave(&subs->lock, flags);
1039                oldptr = subs->hwptr_done;
1040                subs->hwptr_done += bytes;
1041                if (subs->hwptr_done >= runtime->buffer_size * stride)
1042                        subs->hwptr_done -= runtime->buffer_size * stride;
1043                frames = (bytes + (oldptr % stride)) / stride;
1044                subs->transfer_done += frames;
1045                if (subs->transfer_done >= runtime->period_size) {
1046                        subs->transfer_done -= runtime->period_size;
1047                        period_elapsed = 1;
1048                }
1049                spin_unlock_irqrestore(&subs->lock, flags);
1050                /* copy a data chunk */
1051                if (oldptr + bytes > runtime->buffer_size * stride) {
1052                        unsigned int bytes1 =
1053                                        runtime->buffer_size * stride - oldptr;
1054                        memcpy(runtime->dma_area + oldptr, cp, bytes1);
1055                        memcpy(runtime->dma_area, cp + bytes1, bytes - bytes1);
1056                } else {
1057                        memcpy(runtime->dma_area + oldptr, cp, bytes);
1058                }
1059        }
1060
1061        if (period_elapsed)
1062                snd_pcm_period_elapsed(subs->pcm_substream);
1063}
1064
1065static void prepare_playback_urb(struct snd_usb_substream *subs,
1066                                 struct urb *urb)
1067{
1068        struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
1069        struct snd_usb_endpoint *ep = subs->data_endpoint;
1070        struct snd_urb_ctx *ctx = urb->context;
1071        unsigned int counts, frames, bytes;
1072        int i, stride, period_elapsed = 0;
1073        unsigned long flags;
1074
1075        stride = runtime->frame_bits >> 3;
1076
1077        frames = 0;
1078        urb->number_of_packets = 0;
1079        spin_lock_irqsave(&subs->lock, flags);
1080        for (i = 0; i < ctx->packets; i++) {
1081                if (ctx->packet_size[i])
1082                        counts = ctx->packet_size[i];
1083                else
1084                        counts = snd_usb_endpoint_next_packet_size(ep);
1085
1086                /* set up descriptor */
1087                urb->iso_frame_desc[i].offset = frames * stride;
1088                urb->iso_frame_desc[i].length = counts * stride;
1089                frames += counts;
1090                urb->number_of_packets++;
1091                subs->transfer_done += counts;
1092                if (subs->transfer_done >= runtime->period_size) {
1093                        subs->transfer_done -= runtime->period_size;
1094                        period_elapsed = 1;
1095                        if (subs->fmt_type == UAC_FORMAT_TYPE_II) {
1096                                if (subs->transfer_done > 0) {
1097                                        /* FIXME: fill-max mode is not
1098                                         * supported yet */
1099                                        frames -= subs->transfer_done;
1100                                        counts -= subs->transfer_done;
1101                                        urb->iso_frame_desc[i].length =
1102                                                counts * stride;
1103                                        subs->transfer_done = 0;
1104                                }
1105                                i++;
1106                                if (i < ctx->packets) {
1107                                        /* add a transfer delimiter */
1108                                        urb->iso_frame_desc[i].offset =
1109                                                frames * stride;
1110                                        urb->iso_frame_desc[i].length = 0;
1111                                        urb->number_of_packets++;
1112                                }
1113                                break;
1114                        }
1115                }
1116                if (period_elapsed &&
1117                    !snd_usb_endpoint_implict_feedback_sink(subs->data_endpoint)) /* finish at the period boundary */
1118                        break;
1119        }
1120        bytes = frames * stride;
1121        if (subs->hwptr_done + bytes > runtime->buffer_size * stride) {
1122                /* err, the transferred area goes over buffer boundary. */
1123                unsigned int bytes1 =
1124                        runtime->buffer_size * stride - subs->hwptr_done;
1125                memcpy(urb->transfer_buffer,
1126                       runtime->dma_area + subs->hwptr_done, bytes1);
1127                memcpy(urb->transfer_buffer + bytes1,
1128                       runtime->dma_area, bytes - bytes1);
1129        } else {
1130                memcpy(urb->transfer_buffer,
1131                       runtime->dma_area + subs->hwptr_done, bytes);
1132        }
1133        subs->hwptr_done += bytes;
1134        if (subs->hwptr_done >= runtime->buffer_size * stride)
1135                subs->hwptr_done -= runtime->buffer_size * stride;
1136
1137        /* update delay with exact number of samples queued */
1138        runtime->delay = subs->last_delay;
1139        runtime->delay += frames;
1140        subs->last_delay = runtime->delay;
1141
1142        /* realign last_frame_number */
1143        subs->last_frame_number = usb_get_current_frame_number(subs->dev);
1144        subs->last_frame_number &= 0xFF; /* keep 8 LSBs */
1145
1146        spin_unlock_irqrestore(&subs->lock, flags);
1147        urb->transfer_buffer_length = bytes;
1148        if (period_elapsed)
1149                snd_pcm_period_elapsed(subs->pcm_substream);
1150}
1151
1152/*
1153 * process after playback data complete
1154 * - decrease the delay count again
1155 */
1156static void retire_playback_urb(struct snd_usb_substream *subs,
1157                               struct urb *urb)
1158{
1159        unsigned long flags;
1160        struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
1161        int stride = runtime->frame_bits >> 3;
1162        int processed = urb->transfer_buffer_length / stride;
1163        int est_delay;
1164
1165        /* ignore the delay accounting when procssed=0 is given, i.e.
1166         * silent payloads are procssed before handling the actual data
1167         */
1168        if (!processed)
1169                return;
1170
1171        spin_lock_irqsave(&subs->lock, flags);
1172        est_delay = snd_usb_pcm_delay(subs, runtime->rate);
1173        /* update delay with exact number of samples played */
1174        if (processed > subs->last_delay)
1175                subs->last_delay = 0;
1176        else
1177                subs->last_delay -= processed;
1178        runtime->delay = subs->last_delay;
1179
1180        /*
1181         * Report when delay estimate is off by more than 2ms.
1182         * The error should be lower than 2ms since the estimate relies
1183         * on two reads of a counter updated every ms.
1184         */
1185        if (abs(est_delay - subs->last_delay) * 1000 > runtime->rate * 2)
1186                snd_printk(KERN_DEBUG "delay: estimated %d, actual %d\n",
1187                        est_delay, subs->last_delay);
1188
1189        spin_unlock_irqrestore(&subs->lock, flags);
1190}
1191
1192static int snd_usb_playback_open(struct snd_pcm_substream *substream)
1193{
1194        return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK);
1195}
1196
1197static int snd_usb_playback_close(struct snd_pcm_substream *substream)
1198{
1199        return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK);
1200}
1201
1202static int snd_usb_capture_open(struct snd_pcm_substream *substream)
1203{
1204        return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE);
1205}
1206
1207static int snd_usb_capture_close(struct snd_pcm_substream *substream)
1208{
1209        return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE);
1210}
1211
1212static int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream,
1213                                              int cmd)
1214{
1215        struct snd_usb_substream *subs = substream->runtime->private_data;
1216
1217        switch (cmd) {
1218        case SNDRV_PCM_TRIGGER_START:
1219        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1220                subs->data_endpoint->prepare_data_urb = prepare_playback_urb;
1221                subs->data_endpoint->retire_data_urb = retire_playback_urb;
1222                subs->running = 1;
1223                return 0;
1224        case SNDRV_PCM_TRIGGER_STOP:
1225                stop_endpoints(subs, 0, 0, 0);
1226                subs->running = 0;
1227                return 0;
1228        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1229                subs->data_endpoint->prepare_data_urb = NULL;
1230                subs->data_endpoint->retire_data_urb = NULL;
1231                subs->running = 0;
1232                return 0;
1233        }
1234
1235        return -EINVAL;
1236}
1237
1238static int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream,
1239                                             int cmd)
1240{
1241        int err;
1242        struct snd_usb_substream *subs = substream->runtime->private_data;
1243
1244        switch (cmd) {
1245        case SNDRV_PCM_TRIGGER_START:
1246                err = start_endpoints(subs, 0);
1247                if (err < 0)
1248                        return err;
1249
1250                subs->data_endpoint->retire_data_urb = retire_capture_urb;
1251                subs->running = 1;
1252                return 0;
1253        case SNDRV_PCM_TRIGGER_STOP:
1254                stop_endpoints(subs, 0, 0, 0);
1255                subs->running = 0;
1256                return 0;
1257        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1258                subs->data_endpoint->retire_data_urb = NULL;
1259                subs->running = 0;
1260                return 0;
1261        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1262                subs->data_endpoint->retire_data_urb = retire_capture_urb;
1263                subs->running = 1;
1264                return 0;
1265        }
1266
1267        return -EINVAL;
1268}
1269
1270static struct snd_pcm_ops snd_usb_playback_ops = {
1271        .open =         snd_usb_playback_open,
1272        .close =        snd_usb_playback_close,
1273        .ioctl =        snd_pcm_lib_ioctl,
1274        .hw_params =    snd_usb_hw_params,
1275        .hw_free =      snd_usb_hw_free,
1276        .prepare =      snd_usb_pcm_prepare,
1277        .trigger =      snd_usb_substream_playback_trigger,
1278        .pointer =      snd_usb_pcm_pointer,
1279        .page =         snd_pcm_lib_get_vmalloc_page,
1280        .mmap =         snd_pcm_lib_mmap_vmalloc,
1281};
1282
1283static struct snd_pcm_ops snd_usb_capture_ops = {
1284        .open =         snd_usb_capture_open,
1285        .close =        snd_usb_capture_close,
1286        .ioctl =        snd_pcm_lib_ioctl,
1287        .hw_params =    snd_usb_hw_params,
1288        .hw_free =      snd_usb_hw_free,
1289        .prepare =      snd_usb_pcm_prepare,
1290        .trigger =      snd_usb_substream_capture_trigger,
1291        .pointer =      snd_usb_pcm_pointer,
1292        .page =         snd_pcm_lib_get_vmalloc_page,
1293        .mmap =         snd_pcm_lib_mmap_vmalloc,
1294};
1295
1296void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream)
1297{
1298        snd_pcm_set_ops(pcm, stream,
1299                        stream == SNDRV_PCM_STREAM_PLAYBACK ?
1300                        &snd_usb_playback_ops : &snd_usb_capture_ops);
1301}
1302
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.