linux/sound/core/pcm_native.c
<<
>>
Prefs
   1/*
   2 *  Digital Audio (PCM) abstract layer
   3 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   4 *
   5 *
   6 *   This program is free software; you can redistribute it and/or modify
   7 *   it under the terms of the GNU General Public License as published by
   8 *   the Free Software Foundation; either version 2 of the License, or
   9 *   (at your option) any later version.
  10 *
  11 *   This program is distributed in the hope that it will be useful,
  12 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 *   GNU General Public License for more details.
  15 *
  16 *   You should have received a copy of the GNU General Public License
  17 *   along with this program; if not, write to the Free Software
  18 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 *
  20 */
  21
  22#include <linux/mm.h>
  23#include <linux/module.h>
  24#include <linux/file.h>
  25#include <linux/slab.h>
  26#include <linux/time.h>
  27#include <linux/pm_qos.h>
  28#include <linux/uio.h>
  29#include <linux/dma-mapping.h>
  30#include <sound/core.h>
  31#include <sound/control.h>
  32#include <sound/info.h>
  33#include <sound/pcm.h>
  34#include <sound/pcm_params.h>
  35#include <sound/timer.h>
  36#include <sound/minors.h>
  37#include <asm/io.h>
  38#if defined(CONFIG_MIPS) && defined(CONFIG_DMA_NONCOHERENT)
  39#include <dma-coherence.h>
  40#endif
  41
  42/*
  43 *  Compatibility
  44 */
  45
  46struct snd_pcm_hw_params_old {
  47        unsigned int flags;
  48        unsigned int masks[SNDRV_PCM_HW_PARAM_SUBFORMAT -
  49                           SNDRV_PCM_HW_PARAM_ACCESS + 1];
  50        struct snd_interval intervals[SNDRV_PCM_HW_PARAM_TICK_TIME -
  51                                        SNDRV_PCM_HW_PARAM_SAMPLE_BITS + 1];
  52        unsigned int rmask;
  53        unsigned int cmask;
  54        unsigned int info;
  55        unsigned int msbits;
  56        unsigned int rate_num;
  57        unsigned int rate_den;
  58        snd_pcm_uframes_t fifo_size;
  59        unsigned char reserved[64];
  60};
  61
  62#ifdef CONFIG_SND_SUPPORT_OLD_API
  63#define SNDRV_PCM_IOCTL_HW_REFINE_OLD _IOWR('A', 0x10, struct snd_pcm_hw_params_old)
  64#define SNDRV_PCM_IOCTL_HW_PARAMS_OLD _IOWR('A', 0x11, struct snd_pcm_hw_params_old)
  65
  66static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream,
  67                                      struct snd_pcm_hw_params_old __user * _oparams);
  68static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream,
  69                                      struct snd_pcm_hw_params_old __user * _oparams);
  70#endif
  71static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream);
  72
  73/*
  74 *
  75 */
  76
  77DEFINE_RWLOCK(snd_pcm_link_rwlock);
  78EXPORT_SYMBOL(snd_pcm_link_rwlock);
  79
  80static DECLARE_RWSEM(snd_pcm_link_rwsem);
  81
  82static inline mm_segment_t snd_enter_user(void)
  83{
  84        mm_segment_t fs = get_fs();
  85        set_fs(get_ds());
  86        return fs;
  87}
  88
  89static inline void snd_leave_user(mm_segment_t fs)
  90{
  91        set_fs(fs);
  92}
  93
  94
  95
  96int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info)
  97{
  98        struct snd_pcm_runtime *runtime;
  99        struct snd_pcm *pcm = substream->pcm;
 100        struct snd_pcm_str *pstr = substream->pstr;
 101
 102        memset(info, 0, sizeof(*info));
 103        info->card = pcm->card->number;
 104        info->device = pcm->device;
 105        info->stream = substream->stream;
 106        info->subdevice = substream->number;
 107        strlcpy(info->id, pcm->id, sizeof(info->id));
 108        strlcpy(info->name, pcm->name, sizeof(info->name));
 109        info->dev_class = pcm->dev_class;
 110        info->dev_subclass = pcm->dev_subclass;
 111        info->subdevices_count = pstr->substream_count;
 112        info->subdevices_avail = pstr->substream_count - pstr->substream_opened;
 113        strlcpy(info->subname, substream->name, sizeof(info->subname));
 114        runtime = substream->runtime;
 115        /* AB: FIXME!!! This is definitely nonsense */
 116        if (runtime) {
 117                info->sync = runtime->sync;
 118                substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_INFO, info);
 119        }
 120        return 0;
 121}
 122
 123int snd_pcm_info_user(struct snd_pcm_substream *substream,
 124                      struct snd_pcm_info __user * _info)
 125{
 126        struct snd_pcm_info *info;
 127        int err;
 128
 129        info = kmalloc(sizeof(*info), GFP_KERNEL);
 130        if (! info)
 131                return -ENOMEM;
 132        err = snd_pcm_info(substream, info);
 133        if (err >= 0) {
 134                if (copy_to_user(_info, info, sizeof(*info)))
 135                        err = -EFAULT;
 136        }
 137        kfree(info);
 138        return err;
 139}
 140
 141#undef RULES_DEBUG
 142
 143#ifdef RULES_DEBUG
 144#define HW_PARAM(v) [SNDRV_PCM_HW_PARAM_##v] = #v
 145static const char * const snd_pcm_hw_param_names[] = {
 146        HW_PARAM(ACCESS),
 147        HW_PARAM(FORMAT),
 148        HW_PARAM(SUBFORMAT),
 149        HW_PARAM(SAMPLE_BITS),
 150        HW_PARAM(FRAME_BITS),
 151        HW_PARAM(CHANNELS),
 152        HW_PARAM(RATE),
 153        HW_PARAM(PERIOD_TIME),
 154        HW_PARAM(PERIOD_SIZE),
 155        HW_PARAM(PERIOD_BYTES),
 156        HW_PARAM(PERIODS),
 157        HW_PARAM(BUFFER_TIME),
 158        HW_PARAM(BUFFER_SIZE),
 159        HW_PARAM(BUFFER_BYTES),
 160        HW_PARAM(TICK_TIME),
 161};
 162#endif
 163
 164int snd_pcm_hw_refine(struct snd_pcm_substream *substream, 
 165                      struct snd_pcm_hw_params *params)
 166{
 167        unsigned int k;
 168        struct snd_pcm_hardware *hw;
 169        struct snd_interval *i = NULL;
 170        struct snd_mask *m = NULL;
 171        struct snd_pcm_hw_constraints *constrs = &substream->runtime->hw_constraints;
 172        unsigned int rstamps[constrs->rules_num];
 173        unsigned int vstamps[SNDRV_PCM_HW_PARAM_LAST_INTERVAL + 1];
 174        unsigned int stamp = 2;
 175        int changed, again;
 176
 177        params->info = 0;
 178        params->fifo_size = 0;
 179        if (params->rmask & (1 << SNDRV_PCM_HW_PARAM_SAMPLE_BITS))
 180                params->msbits = 0;
 181        if (params->rmask & (1 << SNDRV_PCM_HW_PARAM_RATE)) {
 182                params->rate_num = 0;
 183                params->rate_den = 0;
 184        }
 185
 186        for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) {
 187                m = hw_param_mask(params, k);
 188                if (snd_mask_empty(m))
 189                        return -EINVAL;
 190                if (!(params->rmask & (1 << k)))
 191                        continue;
 192#ifdef RULES_DEBUG
 193                printk(KERN_DEBUG "%s = ", snd_pcm_hw_param_names[k]);
 194                printk("%04x%04x%04x%04x -> ", m->bits[3], m->bits[2], m->bits[1], m->bits[0]);
 195#endif
 196                changed = snd_mask_refine(m, constrs_mask(constrs, k));
 197#ifdef RULES_DEBUG
 198                printk("%04x%04x%04x%04x\n", m->bits[3], m->bits[2], m->bits[1], m->bits[0]);
 199#endif
 200                if (changed)
 201                        params->cmask |= 1 << k;
 202                if (changed < 0)
 203                        return changed;
 204        }
 205
 206        for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) {
 207                i = hw_param_interval(params, k);
 208                if (snd_interval_empty(i))
 209                        return -EINVAL;
 210                if (!(params->rmask & (1 << k)))
 211                        continue;
 212#ifdef RULES_DEBUG
 213                printk(KERN_DEBUG "%s = ", snd_pcm_hw_param_names[k]);
 214                if (i->empty)
 215                        printk("empty");
 216                else
 217                        printk("%c%u %u%c", 
 218                               i->openmin ? '(' : '[', i->min,
 219                               i->max, i->openmax ? ')' : ']');
 220                printk(" -> ");
 221#endif
 222                changed = snd_interval_refine(i, constrs_interval(constrs, k));
 223#ifdef RULES_DEBUG
 224                if (i->empty)
 225                        printk("empty\n");
 226                else 
 227                        printk("%c%u %u%c\n", 
 228                               i->openmin ? '(' : '[', i->min,
 229                               i->max, i->openmax ? ')' : ']');
 230#endif
 231                if (changed)
 232                        params->cmask |= 1 << k;
 233                if (changed < 0)
 234                        return changed;
 235        }
 236
 237        for (k = 0; k < constrs->rules_num; k++)
 238                rstamps[k] = 0;
 239        for (k = 0; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) 
 240                vstamps[k] = (params->rmask & (1 << k)) ? 1 : 0;
 241        do {
 242                again = 0;
 243                for (k = 0; k < constrs->rules_num; k++) {
 244                        struct snd_pcm_hw_rule *r = &constrs->rules[k];
 245                        unsigned int d;
 246                        int doit = 0;
 247                        if (r->cond && !(r->cond & params->flags))
 248                                continue;
 249                        for (d = 0; r->deps[d] >= 0; d++) {
 250                                if (vstamps[r->deps[d]] > rstamps[k]) {
 251                                        doit = 1;
 252                                        break;
 253                                }
 254                        }
 255                        if (!doit)
 256                                continue;
 257#ifdef RULES_DEBUG
 258                        printk(KERN_DEBUG "Rule %d [%p]: ", k, r->func);
 259                        if (r->var >= 0) {
 260                                printk("%s = ", snd_pcm_hw_param_names[r->var]);
 261                                if (hw_is_mask(r->var)) {
 262                                        m = hw_param_mask(params, r->var);
 263                                        printk("%x", *m->bits);
 264                                } else {
 265                                        i = hw_param_interval(params, r->var);
 266                                        if (i->empty)
 267                                                printk("empty");
 268                                        else
 269                                                printk("%c%u %u%c", 
 270                                                       i->openmin ? '(' : '[', i->min,
 271                                                       i->max, i->openmax ? ')' : ']');
 272                                }
 273                        }
 274#endif
 275                        changed = r->func(params, r);
 276#ifdef RULES_DEBUG
 277                        if (r->var >= 0) {
 278                                printk(" -> ");
 279                                if (hw_is_mask(r->var))
 280                                        printk("%x", *m->bits);
 281                                else {
 282                                        if (i->empty)
 283                                                printk("empty");
 284                                        else
 285                                                printk("%c%u %u%c", 
 286                                                       i->openmin ? '(' : '[', i->min,
 287                                                       i->max, i->openmax ? ')' : ']');
 288                                }
 289                        }
 290                        printk("\n");
 291#endif
 292                        rstamps[k] = stamp;
 293                        if (changed && r->var >= 0) {
 294                                params->cmask |= (1 << r->var);
 295                                vstamps[r->var] = stamp;
 296                                again = 1;
 297                        }
 298                        if (changed < 0)
 299                                return changed;
 300                        stamp++;
 301                }
 302        } while (again);
 303        if (!params->msbits) {
 304                i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
 305                if (snd_interval_single(i))
 306                        params->msbits = snd_interval_value(i);
 307        }
 308
 309        if (!params->rate_den) {
 310                i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
 311                if (snd_interval_single(i)) {
 312                        params->rate_num = snd_interval_value(i);
 313                        params->rate_den = 1;
 314                }
 315        }
 316
 317        hw = &substream->runtime->hw;
 318        if (!params->info)
 319                params->info = hw->info & ~SNDRV_PCM_INFO_FIFO_IN_FRAMES;
 320        if (!params->fifo_size) {
 321                m = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
 322                i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
 323                if (snd_mask_min(m) == snd_mask_max(m) &&
 324                    snd_interval_min(i) == snd_interval_max(i)) {
 325                        changed = substream->ops->ioctl(substream,
 326                                        SNDRV_PCM_IOCTL1_FIFO_SIZE, params);
 327                        if (changed < 0)
 328                                return changed;
 329                }
 330        }
 331        params->rmask = 0;
 332        return 0;
 333}
 334
 335EXPORT_SYMBOL(snd_pcm_hw_refine);
 336
 337static int snd_pcm_hw_refine_user(struct snd_pcm_substream *substream,
 338                                  struct snd_pcm_hw_params __user * _params)
 339{
 340        struct snd_pcm_hw_params *params;
 341        int err;
 342
 343        params = memdup_user(_params, sizeof(*params));
 344        if (IS_ERR(params))
 345                return PTR_ERR(params);
 346
 347        err = snd_pcm_hw_refine(substream, params);
 348        if (copy_to_user(_params, params, sizeof(*params))) {
 349                if (!err)
 350                        err = -EFAULT;
 351        }
 352
 353        kfree(params);
 354        return err;
 355}
 356
 357static int period_to_usecs(struct snd_pcm_runtime *runtime)
 358{
 359        int usecs;
 360
 361        if (! runtime->rate)
 362                return -1; /* invalid */
 363
 364        /* take 75% of period time as the deadline */
 365        usecs = (750000 / runtime->rate) * runtime->period_size;
 366        usecs += ((750000 % runtime->rate) * runtime->period_size) /
 367                runtime->rate;
 368
 369        return usecs;
 370}
 371
 372static void snd_pcm_set_state(struct snd_pcm_substream *substream, int state)
 373{
 374        snd_pcm_stream_lock_irq(substream);
 375        if (substream->runtime->status->state != SNDRV_PCM_STATE_DISCONNECTED)
 376                substream->runtime->status->state = state;
 377        snd_pcm_stream_unlock_irq(substream);
 378}
 379
 380static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
 381                             struct snd_pcm_hw_params *params)
 382{
 383        struct snd_pcm_runtime *runtime;
 384        int err, usecs;
 385        unsigned int bits;
 386        snd_pcm_uframes_t frames;
 387
 388        if (PCM_RUNTIME_CHECK(substream))
 389                return -ENXIO;
 390        runtime = substream->runtime;
 391        snd_pcm_stream_lock_irq(substream);
 392        switch (runtime->status->state) {
 393        case SNDRV_PCM_STATE_OPEN:
 394        case SNDRV_PCM_STATE_SETUP:
 395        case SNDRV_PCM_STATE_PREPARED:
 396                break;
 397        default:
 398                snd_pcm_stream_unlock_irq(substream);
 399                return -EBADFD;
 400        }
 401        snd_pcm_stream_unlock_irq(substream);
 402#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
 403        if (!substream->oss.oss)
 404#endif
 405                if (atomic_read(&substream->mmap_count))
 406                        return -EBADFD;
 407
 408        params->rmask = ~0U;
 409        err = snd_pcm_hw_refine(substream, params);
 410        if (err < 0)
 411                goto _error;
 412
 413        err = snd_pcm_hw_params_choose(substream, params);
 414        if (err < 0)
 415                goto _error;
 416
 417        if (substream->ops->hw_params != NULL) {
 418                err = substream->ops->hw_params(substream, params);
 419                if (err < 0)
 420                        goto _error;
 421        }
 422
 423        runtime->access = params_access(params);
 424        runtime->format = params_format(params);
 425        runtime->subformat = params_subformat(params);
 426        runtime->channels = params_channels(params);
 427        runtime->rate = params_rate(params);
 428        runtime->period_size = params_period_size(params);
 429        runtime->periods = params_periods(params);
 430        runtime->buffer_size = params_buffer_size(params);
 431        runtime->info = params->info;
 432        runtime->rate_num = params->rate_num;
 433        runtime->rate_den = params->rate_den;
 434        runtime->no_period_wakeup =
 435                        (params->info & SNDRV_PCM_INFO_NO_PERIOD_WAKEUP) &&
 436                        (params->flags & SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP);
 437
 438        bits = snd_pcm_format_physical_width(runtime->format);
 439        runtime->sample_bits = bits;
 440        bits *= runtime->channels;
 441        runtime->frame_bits = bits;
 442        frames = 1;
 443        while (bits % 8 != 0) {
 444                bits *= 2;
 445                frames *= 2;
 446        }
 447        runtime->byte_align = bits / 8;
 448        runtime->min_align = frames;
 449
 450        /* Default sw params */
 451        runtime->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
 452        runtime->period_step = 1;
 453        runtime->control->avail_min = runtime->period_size;
 454        runtime->start_threshold = 1;
 455        runtime->stop_threshold = runtime->buffer_size;
 456        runtime->silence_threshold = 0;
 457        runtime->silence_size = 0;
 458        runtime->boundary = runtime->buffer_size;
 459        while (runtime->boundary * 2 <= LONG_MAX - runtime->buffer_size)
 460                runtime->boundary *= 2;
 461
 462        snd_pcm_timer_resolution_change(substream);
 463        snd_pcm_set_state(substream, SNDRV_PCM_STATE_SETUP);
 464
 465        if (pm_qos_request_active(&substream->latency_pm_qos_req))
 466                pm_qos_remove_request(&substream->latency_pm_qos_req);
 467        if ((usecs = period_to_usecs(runtime)) >= 0)
 468                pm_qos_add_request(&substream->latency_pm_qos_req,
 469                                   PM_QOS_CPU_DMA_LATENCY, usecs);
 470        return 0;
 471 _error:
 472        /* hardware might be unusable from this time,
 473           so we force application to retry to set
 474           the correct hardware parameter settings */
 475        snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN);
 476        if (substream->ops->hw_free != NULL)
 477                substream->ops->hw_free(substream);
 478        return err;
 479}
 480
 481static int snd_pcm_hw_params_user(struct snd_pcm_substream *substream,
 482                                  struct snd_pcm_hw_params __user * _params)
 483{
 484        struct snd_pcm_hw_params *params;
 485        int err;
 486
 487        params = memdup_user(_params, sizeof(*params));
 488        if (IS_ERR(params))
 489                return PTR_ERR(params);
 490
 491        err = snd_pcm_hw_params(substream, params);
 492        if (copy_to_user(_params, params, sizeof(*params))) {
 493                if (!err)
 494                        err = -EFAULT;
 495        }
 496
 497        kfree(params);
 498        return err;
 499}
 500
 501static int snd_pcm_hw_free(struct snd_pcm_substream *substream)
 502{
 503        struct snd_pcm_runtime *runtime;
 504        int result = 0;
 505
 506        if (PCM_RUNTIME_CHECK(substream))
 507                return -ENXIO;
 508        runtime = substream->runtime;
 509        snd_pcm_stream_lock_irq(substream);
 510        switch (runtime->status->state) {
 511        case SNDRV_PCM_STATE_SETUP:
 512        case SNDRV_PCM_STATE_PREPARED:
 513                break;
 514        default:
 515                snd_pcm_stream_unlock_irq(substream);
 516                return -EBADFD;
 517        }
 518        snd_pcm_stream_unlock_irq(substream);
 519        if (atomic_read(&substream->mmap_count))
 520                return -EBADFD;
 521        if (substream->ops->hw_free)
 522                result = substream->ops->hw_free(substream);
 523        snd_pcm_set_state(substream, SNDRV_PCM_STATE_OPEN);
 524        pm_qos_remove_request(&substream->latency_pm_qos_req);
 525        return result;
 526}
 527
 528static int snd_pcm_sw_params(struct snd_pcm_substream *substream,
 529                             struct snd_pcm_sw_params *params)
 530{
 531        struct snd_pcm_runtime *runtime;
 532        int err;
 533
 534        if (PCM_RUNTIME_CHECK(substream))
 535                return -ENXIO;
 536        runtime = substream->runtime;
 537        snd_pcm_stream_lock_irq(substream);
 538        if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
 539                snd_pcm_stream_unlock_irq(substream);
 540                return -EBADFD;
 541        }
 542        snd_pcm_stream_unlock_irq(substream);
 543
 544        if (params->tstamp_mode > SNDRV_PCM_TSTAMP_LAST)
 545                return -EINVAL;
 546        if (params->avail_min == 0)
 547                return -EINVAL;
 548        if (params->silence_size >= runtime->boundary) {
 549                if (params->silence_threshold != 0)
 550                        return -EINVAL;
 551        } else {
 552                if (params->silence_size > params->silence_threshold)
 553                        return -EINVAL;
 554                if (params->silence_threshold > runtime->buffer_size)
 555                        return -EINVAL;
 556        }
 557        err = 0;
 558        snd_pcm_stream_lock_irq(substream);
 559        runtime->tstamp_mode = params->tstamp_mode;
 560        runtime->period_step = params->period_step;
 561        runtime->control->avail_min = params->avail_min;
 562        runtime->start_threshold = params->start_threshold;
 563        runtime->stop_threshold = params->stop_threshold;
 564        runtime->silence_threshold = params->silence_threshold;
 565        runtime->silence_size = params->silence_size;
 566        params->boundary = runtime->boundary;
 567        if (snd_pcm_running(substream)) {
 568                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
 569                    runtime->silence_size > 0)
 570                        snd_pcm_playback_silence(substream, ULONG_MAX);
 571                err = snd_pcm_update_state(substream, runtime);
 572        }
 573        snd_pcm_stream_unlock_irq(substream);
 574        return err;
 575}
 576
 577static int snd_pcm_sw_params_user(struct snd_pcm_substream *substream,
 578                                  struct snd_pcm_sw_params __user * _params)
 579{
 580        struct snd_pcm_sw_params params;
 581        int err;
 582        if (copy_from_user(&params, _params, sizeof(params)))
 583                return -EFAULT;
 584        err = snd_pcm_sw_params(substream, &params);
 585        if (copy_to_user(_params, &params, sizeof(params)))
 586                return -EFAULT;
 587        return err;
 588}
 589
 590int snd_pcm_status(struct snd_pcm_substream *substream,
 591                   struct snd_pcm_status *status)
 592{
 593        struct snd_pcm_runtime *runtime = substream->runtime;
 594
 595        snd_pcm_stream_lock_irq(substream);
 596        status->state = runtime->status->state;
 597        status->suspended_state = runtime->status->suspended_state;
 598        if (status->state == SNDRV_PCM_STATE_OPEN)
 599                goto _end;
 600        status->trigger_tstamp = runtime->trigger_tstamp;
 601        if (snd_pcm_running(substream)) {
 602                snd_pcm_update_hw_ptr(substream);
 603                if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) {
 604                        status->tstamp = runtime->status->tstamp;
 605                        goto _tstamp_end;
 606                }
 607        }
 608        snd_pcm_gettime(runtime, &status->tstamp);
 609 _tstamp_end:
 610        status->appl_ptr = runtime->control->appl_ptr;
 611        status->hw_ptr = runtime->status->hw_ptr;
 612        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 613                status->avail = snd_pcm_playback_avail(runtime);
 614                if (runtime->status->state == SNDRV_PCM_STATE_RUNNING ||
 615                    runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
 616                        status->delay = runtime->buffer_size - status->avail;
 617                        status->delay += runtime->delay;
 618                } else
 619                        status->delay = 0;
 620        } else {
 621                status->avail = snd_pcm_capture_avail(runtime);
 622                if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
 623                        status->delay = status->avail + runtime->delay;
 624                else
 625                        status->delay = 0;
 626        }
 627        status->avail_max = runtime->avail_max;
 628        status->overrange = runtime->overrange;
 629        runtime->avail_max = 0;
 630        runtime->overrange = 0;
 631 _end:
 632        snd_pcm_stream_unlock_irq(substream);
 633        return 0;
 634}
 635
 636static int snd_pcm_status_user(struct snd_pcm_substream *substream,
 637                               struct snd_pcm_status __user * _status)
 638{
 639        struct snd_pcm_status status;
 640        int res;
 641        
 642        memset(&status, 0, sizeof(status));
 643        res = snd_pcm_status(substream, &status);
 644        if (res < 0)
 645                return res;
 646        if (copy_to_user(_status, &status, sizeof(status)))
 647                return -EFAULT;
 648        return 0;
 649}
 650
 651static int snd_pcm_channel_info(struct snd_pcm_substream *substream,
 652                                struct snd_pcm_channel_info * info)
 653{
 654        struct snd_pcm_runtime *runtime;
 655        unsigned int channel;
 656        
 657        channel = info->channel;
 658        runtime = substream->runtime;
 659        snd_pcm_stream_lock_irq(substream);
 660        if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
 661                snd_pcm_stream_unlock_irq(substream);
 662                return -EBADFD;
 663        }
 664        snd_pcm_stream_unlock_irq(substream);
 665        if (channel >= runtime->channels)
 666                return -EINVAL;
 667        memset(info, 0, sizeof(*info));
 668        info->channel = channel;
 669        return substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_CHANNEL_INFO, info);
 670}
 671
 672static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream,
 673                                     struct snd_pcm_channel_info __user * _info)
 674{
 675        struct snd_pcm_channel_info info;
 676        int res;
 677        
 678        if (copy_from_user(&info, _info, sizeof(info)))
 679                return -EFAULT;
 680        res = snd_pcm_channel_info(substream, &info);
 681        if (res < 0)
 682                return res;
 683        if (copy_to_user(_info, &info, sizeof(info)))
 684                return -EFAULT;
 685        return 0;
 686}
 687
 688static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream)
 689{
 690        struct snd_pcm_runtime *runtime = substream->runtime;
 691        if (runtime->trigger_master == NULL)
 692                return;
 693        if (runtime->trigger_master == substream) {
 694                snd_pcm_gettime(runtime, &runtime->trigger_tstamp);
 695        } else {
 696                snd_pcm_trigger_tstamp(runtime->trigger_master);
 697                runtime->trigger_tstamp = runtime->trigger_master->runtime->trigger_tstamp;
 698        }
 699        runtime->trigger_master = NULL;
 700}
 701
 702struct action_ops {
 703        int (*pre_action)(struct snd_pcm_substream *substream, int state);
 704        int (*do_action)(struct snd_pcm_substream *substream, int state);
 705        void (*undo_action)(struct snd_pcm_substream *substream, int state);
 706        void (*post_action)(struct snd_pcm_substream *substream, int state);
 707};
 708
 709/*
 710 *  this functions is core for handling of linked stream
 711 *  Note: the stream state might be changed also on failure
 712 *  Note2: call with calling stream lock + link lock
 713 */
 714static int snd_pcm_action_group(struct action_ops *ops,
 715                                struct snd_pcm_substream *substream,
 716                                int state, int do_lock)
 717{
 718        struct snd_pcm_substream *s = NULL;
 719        struct snd_pcm_substream *s1;
 720        int res = 0;
 721
 722        snd_pcm_group_for_each_entry(s, substream) {
 723                if (do_lock && s != substream)
 724                        spin_lock_nested(&s->self_group.lock,
 725                                         SINGLE_DEPTH_NESTING);
 726                res = ops->pre_action(s, state);
 727                if (res < 0)
 728                        goto _unlock;
 729        }
 730        snd_pcm_group_for_each_entry(s, substream) {
 731                res = ops->do_action(s, state);
 732                if (res < 0) {
 733                        if (ops->undo_action) {
 734                                snd_pcm_group_for_each_entry(s1, substream) {
 735                                        if (s1 == s) /* failed stream */
 736                                                break;
 737                                        ops->undo_action(s1, state);
 738                                }
 739                        }
 740                        s = NULL; /* unlock all */
 741                        goto _unlock;
 742                }
 743        }
 744        snd_pcm_group_for_each_entry(s, substream) {
 745                ops->post_action(s, state);
 746        }
 747 _unlock:
 748        if (do_lock) {
 749                /* unlock streams */
 750                snd_pcm_group_for_each_entry(s1, substream) {
 751                        if (s1 != substream)
 752                                spin_unlock(&s1->self_group.lock);
 753                        if (s1 == s)    /* end */
 754                                break;
 755                }
 756        }
 757        return res;
 758}
 759
 760/*
 761 *  Note: call with stream lock
 762 */
 763static int snd_pcm_action_single(struct action_ops *ops,
 764                                 struct snd_pcm_substream *substream,
 765                                 int state)
 766{
 767        int res;
 768        
 769        res = ops->pre_action(substream, state);
 770        if (res < 0)
 771                return res;
 772        res = ops->do_action(substream, state);
 773        if (res == 0)
 774                ops->post_action(substream, state);
 775        else if (ops->undo_action)
 776                ops->undo_action(substream, state);
 777        return res;
 778}
 779
 780/*
 781 *  Note: call with stream lock
 782 */
 783static int snd_pcm_action(struct action_ops *ops,
 784                          struct snd_pcm_substream *substream,
 785                          int state)
 786{
 787        int res;
 788
 789        if (snd_pcm_stream_linked(substream)) {
 790                if (!spin_trylock(&substream->group->lock)) {
 791                        spin_unlock(&substream->self_group.lock);
 792                        spin_lock(&substream->group->lock);
 793                        spin_lock(&substream->self_group.lock);
 794                }
 795                res = snd_pcm_action_group(ops, substream, state, 1);
 796                spin_unlock(&substream->group->lock);
 797        } else {
 798                res = snd_pcm_action_single(ops, substream, state);
 799        }
 800        return res;
 801}
 802
 803/*
 804 *  Note: don't use any locks before
 805 */
 806static int snd_pcm_action_lock_irq(struct action_ops *ops,
 807                                   struct snd_pcm_substream *substream,
 808                                   int state)
 809{
 810        int res;
 811
 812        read_lock_irq(&snd_pcm_link_rwlock);
 813        if (snd_pcm_stream_linked(substream)) {
 814                spin_lock(&substream->group->lock);
 815                spin_lock(&substream->self_group.lock);
 816                res = snd_pcm_action_group(ops, substream, state, 1);
 817                spin_unlock(&substream->self_group.lock);
 818                spin_unlock(&substream->group->lock);
 819        } else {
 820                spin_lock(&substream->self_group.lock);
 821                res = snd_pcm_action_single(ops, substream, state);
 822                spin_unlock(&substream->self_group.lock);
 823        }
 824        read_unlock_irq(&snd_pcm_link_rwlock);
 825        return res;
 826}
 827
 828/*
 829 */
 830static int snd_pcm_action_nonatomic(struct action_ops *ops,
 831                                    struct snd_pcm_substream *substream,
 832                                    int state)
 833{
 834        int res;
 835
 836        down_read(&snd_pcm_link_rwsem);
 837        if (snd_pcm_stream_linked(substream))
 838                res = snd_pcm_action_group(ops, substream, state, 0);
 839        else
 840                res = snd_pcm_action_single(ops, substream, state);
 841        up_read(&snd_pcm_link_rwsem);
 842        return res;
 843}
 844
 845/*
 846 * start callbacks
 847 */
 848static int snd_pcm_pre_start(struct snd_pcm_substream *substream, int state)
 849{
 850        struct snd_pcm_runtime *runtime = substream->runtime;
 851        if (runtime->status->state != SNDRV_PCM_STATE_PREPARED)
 852                return -EBADFD;
 853        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
 854            !snd_pcm_playback_data(substream))
 855                return -EPIPE;
 856        runtime->trigger_master = substream;
 857        return 0;
 858}
 859
 860static int snd_pcm_do_start(struct snd_pcm_substream *substream, int state)
 861{
 862        if (substream->runtime->trigger_master != substream)
 863                return 0;
 864        return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_START);
 865}
 866
 867static void snd_pcm_undo_start(struct snd_pcm_substream *substream, int state)
 868{
 869        if (substream->runtime->trigger_master == substream)
 870                substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP);
 871}
 872
 873static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state)
 874{
 875        struct snd_pcm_runtime *runtime = substream->runtime;
 876        snd_pcm_trigger_tstamp(substream);
 877        runtime->hw_ptr_jiffies = jiffies;
 878        runtime->hw_ptr_buffer_jiffies = (runtime->buffer_size * HZ) / 
 879                                                            runtime->rate;
 880        runtime->status->state = state;
 881        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
 882            runtime->silence_size > 0)
 883                snd_pcm_playback_silence(substream, ULONG_MAX);
 884        if (substream->timer)
 885                snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTART,
 886                                 &runtime->trigger_tstamp);
 887}
 888
 889static struct action_ops snd_pcm_action_start = {
 890        .pre_action = snd_pcm_pre_start,
 891        .do_action = snd_pcm_do_start,
 892        .undo_action = snd_pcm_undo_start,
 893        .post_action = snd_pcm_post_start
 894};
 895
 896/**
 897 * snd_pcm_start - start all linked streams
 898 * @substream: the PCM substream instance
 899 */
 900int snd_pcm_start(struct snd_pcm_substream *substream)
 901{
 902        return snd_pcm_action(&snd_pcm_action_start, substream,
 903                              SNDRV_PCM_STATE_RUNNING);
 904}
 905
 906/*
 907 * stop callbacks
 908 */
 909static int snd_pcm_pre_stop(struct snd_pcm_substream *substream, int state)
 910{
 911        struct snd_pcm_runtime *runtime = substream->runtime;
 912        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
 913                return -EBADFD;
 914        runtime->trigger_master = substream;
 915        return 0;
 916}
 917
 918static int snd_pcm_do_stop(struct snd_pcm_substream *substream, int state)
 919{
 920        if (substream->runtime->trigger_master == substream &&
 921            snd_pcm_running(substream))
 922                substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP);
 923        return 0; /* unconditonally stop all substreams */
 924}
 925
 926static void snd_pcm_post_stop(struct snd_pcm_substream *substream, int state)
 927{
 928        struct snd_pcm_runtime *runtime = substream->runtime;
 929        if (runtime->status->state != state) {
 930                snd_pcm_trigger_tstamp(substream);
 931                if (substream->timer)
 932                        snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTOP,
 933                                         &runtime->trigger_tstamp);
 934                runtime->status->state = state;
 935        }
 936        wake_up(&runtime->sleep);
 937        wake_up(&runtime->tsleep);
 938}
 939
 940static struct action_ops snd_pcm_action_stop = {
 941        .pre_action = snd_pcm_pre_stop,
 942        .do_action = snd_pcm_do_stop,
 943        .post_action = snd_pcm_post_stop
 944};
 945
 946/**
 947 * snd_pcm_stop - try to stop all running streams in the substream group
 948 * @substream: the PCM substream instance
 949 * @state: PCM state after stopping the stream
 950 *
 951 * The state of each stream is then changed to the given state unconditionally.
 952 */
 953int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t state)
 954{
 955        return snd_pcm_action(&snd_pcm_action_stop, substream, state);
 956}
 957
 958EXPORT_SYMBOL(snd_pcm_stop);
 959
 960/**
 961 * snd_pcm_drain_done - stop the DMA only when the given stream is playback
 962 * @substream: the PCM substream
 963 *
 964 * After stopping, the state is changed to SETUP.
 965 * Unlike snd_pcm_stop(), this affects only the given stream.
 966 */
 967int snd_pcm_drain_done(struct snd_pcm_substream *substream)
 968{
 969        return snd_pcm_action_single(&snd_pcm_action_stop, substream,
 970                                     SNDRV_PCM_STATE_SETUP);
 971}
 972
 973/*
 974 * pause callbacks
 975 */
 976static int snd_pcm_pre_pause(struct snd_pcm_substream *substream, int push)
 977{
 978        struct snd_pcm_runtime *runtime = substream->runtime;
 979        if (!(runtime->info & SNDRV_PCM_INFO_PAUSE))
 980                return -ENOSYS;
 981        if (push) {
 982                if (runtime->status->state != SNDRV_PCM_STATE_RUNNING)
 983                        return -EBADFD;
 984        } else if (runtime->status->state != SNDRV_PCM_STATE_PAUSED)
 985                return -EBADFD;
 986        runtime->trigger_master = substream;
 987        return 0;
 988}
 989
 990static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push)
 991{
 992        if (substream->runtime->trigger_master != substream)
 993                return 0;
 994        /* some drivers might use hw_ptr to recover from the pause -
 995           update the hw_ptr now */
 996        if (push)
 997                snd_pcm_update_hw_ptr(substream);
 998        /* The jiffies check in snd_pcm_update_hw_ptr*() is done by
 999         * a delta between the current jiffies, this gives a large enough
1000         * delta, effectively to skip the check once.
1001         */
1002        substream->runtime->hw_ptr_jiffies = jiffies - HZ * 1000;
1003        return substream->ops->trigger(substream,
1004                                       push ? SNDRV_PCM_TRIGGER_PAUSE_PUSH :
1005                                              SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
1006}
1007
1008static void snd_pcm_undo_pause(struct snd_pcm_substream *substream, int push)
1009{
1010        if (substream->runtime->trigger_master == substream)
1011                substream->ops->trigger(substream,
1012                                        push ? SNDRV_PCM_TRIGGER_PAUSE_RELEASE :
1013                                        SNDRV_PCM_TRIGGER_PAUSE_PUSH);
1014}
1015
1016static void snd_pcm_post_pause(struct snd_pcm_substream *substream, int push)
1017{
1018        struct snd_pcm_runtime *runtime = substream->runtime;
1019        snd_pcm_trigger_tstamp(substream);
1020        if (push) {
1021                runtime->status->state = SNDRV_PCM_STATE_PAUSED;
1022                if (substream->timer)
1023                        snd_timer_notify(substream->timer,
1024                                         SNDRV_TIMER_EVENT_MPAUSE,
1025                                         &runtime->trigger_tstamp);
1026                wake_up(&runtime->sleep);
1027                wake_up(&runtime->tsleep);
1028        } else {
1029                runtime->status->state = SNDRV_PCM_STATE_RUNNING;
1030                if (substream->timer)
1031                        snd_timer_notify(substream->timer,
1032                                         SNDRV_TIMER_EVENT_MCONTINUE,
1033                                         &runtime->trigger_tstamp);
1034        }
1035}
1036
1037static struct action_ops snd_pcm_action_pause = {
1038        .pre_action = snd_pcm_pre_pause,
1039        .do_action = snd_pcm_do_pause,
1040        .undo_action = snd_pcm_undo_pause,
1041        .post_action = snd_pcm_post_pause
1042};
1043
1044/*
1045 * Push/release the pause for all linked streams.
1046 */
1047static int snd_pcm_pause(struct snd_pcm_substream *substream, int push)
1048{
1049        return snd_pcm_action(&snd_pcm_action_pause, substream, push);
1050}
1051
1052#ifdef CONFIG_PM
1053/* suspend */
1054
1055static int snd_pcm_pre_suspend(struct snd_pcm_substream *substream, int state)
1056{
1057        struct snd_pcm_runtime *runtime = substream->runtime;
1058        if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
1059                return -EBUSY;
1060        runtime->trigger_master = substream;
1061        return 0;
1062}
1063
1064static int snd_pcm_do_suspend(struct snd_pcm_substream *substream, int state)
1065{
1066        struct snd_pcm_runtime *runtime = substream->runtime;
1067        if (runtime->trigger_master != substream)
1068                return 0;
1069        if (! snd_pcm_running(substream))
1070                return 0;
1071        substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND);
1072        return 0; /* suspend unconditionally */
1073}
1074
1075static void snd_pcm_post_suspend(struct snd_pcm_substream *substream, int state)
1076{
1077        struct snd_pcm_runtime *runtime = substream->runtime;
1078        snd_pcm_trigger_tstamp(substream);
1079        if (substream->timer)
1080                snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSUSPEND,
1081                                 &runtime->trigger_tstamp);
1082        runtime->status->suspended_state = runtime->status->state;
1083        runtime->status->state = SNDRV_PCM_STATE_SUSPENDED;
1084        wake_up(&runtime->sleep);
1085        wake_up(&runtime->tsleep);
1086}
1087
1088static struct action_ops snd_pcm_action_suspend = {
1089        .pre_action = snd_pcm_pre_suspend,
1090        .do_action = snd_pcm_do_suspend,
1091        .post_action = snd_pcm_post_suspend
1092};
1093
1094/**
1095 * snd_pcm_suspend - trigger SUSPEND to all linked streams
1096 * @substream: the PCM substream
1097 *
1098 * After this call, all streams are changed to SUSPENDED state.
1099 */
1100int snd_pcm_suspend(struct snd_pcm_substream *substream)
1101{
1102        int err;
1103        unsigned long flags;
1104
1105        if (! substream)
1106                return 0;
1107
1108        snd_pcm_stream_lock_irqsave(substream, flags);
1109        err = snd_pcm_action(&snd_pcm_action_suspend, substream, 0);
1110        snd_pcm_stream_unlock_irqrestore(substream, flags);
1111        return err;
1112}
1113
1114EXPORT_SYMBOL(snd_pcm_suspend);
1115
1116/**
1117 * snd_pcm_suspend_all - trigger SUSPEND to all substreams in the given pcm
1118 * @pcm: the PCM instance
1119 *
1120 * After this call, all streams are changed to SUSPENDED state.
1121 */
1122int snd_pcm_suspend_all(struct snd_pcm *pcm)
1123{
1124        struct snd_pcm_substream *substream;
1125        int stream, err = 0;
1126
1127        if (! pcm)
1128                return 0;
1129
1130        for (stream = 0; stream < 2; stream++) {
1131                for (substream = pcm->streams[stream].substream;
1132                     substream; substream = substream->next) {
1133                        /* FIXME: the open/close code should lock this as well */
1134                        if (substream->runtime == NULL)
1135                                continue;
1136                        err = snd_pcm_suspend(substream);
1137                        if (err < 0 && err != -EBUSY)
1138                                return err;
1139                }
1140        }
1141        return 0;
1142}
1143
1144EXPORT_SYMBOL(snd_pcm_suspend_all);
1145
1146/* resume */
1147
1148static int snd_pcm_pre_resume(struct snd_pcm_substream *substream, int state)
1149{
1150        struct snd_pcm_runtime *runtime = substream->runtime;
1151        if (!(runtime->info & SNDRV_PCM_INFO_RESUME))
1152                return -ENOSYS;
1153        runtime->trigger_master = substream;
1154        return 0;
1155}
1156
1157static int snd_pcm_do_resume(struct snd_pcm_substream *substream, int state)
1158{
1159        struct snd_pcm_runtime *runtime = substream->runtime;
1160        if (runtime->trigger_master != substream)
1161                return 0;
1162        /* DMA not running previously? */
1163        if (runtime->status->suspended_state != SNDRV_PCM_STATE_RUNNING &&
1164            (runtime->status->suspended_state != SNDRV_PCM_STATE_DRAINING ||
1165             substream->stream != SNDRV_PCM_STREAM_PLAYBACK))
1166                return 0;
1167        return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_RESUME);
1168}
1169
1170static void snd_pcm_undo_resume(struct snd_pcm_substream *substream, int state)
1171{
1172        if (substream->runtime->trigger_master == substream &&
1173            snd_pcm_running(substream))
1174                substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND);
1175}
1176
1177static void snd_pcm_post_resume(struct snd_pcm_substream *substream, int state)
1178{
1179        struct snd_pcm_runtime *runtime = substream->runtime;
1180        snd_pcm_trigger_tstamp(substream);
1181        if (substream->timer)
1182                snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MRESUME,
1183                                 &runtime->trigger_tstamp);
1184        runtime->status->state = runtime->status->suspended_state;
1185}
1186
1187static struct action_ops snd_pcm_action_resume = {
1188        .pre_action = snd_pcm_pre_resume,
1189        .do_action = snd_pcm_do_resume,
1190        .undo_action = snd_pcm_undo_resume,
1191        .post_action = snd_pcm_post_resume
1192};
1193
1194static int snd_pcm_resume(struct snd_pcm_substream *substream)
1195{
1196        struct snd_card *card = substream->pcm->card;
1197        int res;
1198
1199        snd_power_lock(card);
1200        if ((res = snd_power_wait(card, SNDRV_CTL_POWER_D0)) >= 0)
1201                res = snd_pcm_action_lock_irq(&snd_pcm_action_resume, substream, 0);
1202        snd_power_unlock(card);
1203        return res;
1204}
1205
1206#else
1207
1208static int snd_pcm_resume(struct snd_pcm_substream *substream)
1209{
1210        return -ENOSYS;
1211}
1212
1213#endif /* CONFIG_PM */
1214
1215/*
1216 * xrun ioctl
1217 *
1218 * Change the RUNNING stream(s) to XRUN state.
1219 */
1220static int snd_pcm_xrun(struct snd_pcm_substream *substream)
1221{
1222        struct snd_card *card = substream->pcm->card;
1223        struct snd_pcm_runtime *runtime = substream->runtime;
1224        int result;
1225
1226        snd_power_lock(card);
1227        if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
1228                result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
1229                if (result < 0)
1230                        goto _unlock;
1231        }
1232
1233        snd_pcm_stream_lock_irq(substream);
1234        switch (runtime->status->state) {
1235        case SNDRV_PCM_STATE_XRUN:
1236                result = 0;     /* already there */
1237                break;
1238        case SNDRV_PCM_STATE_RUNNING:
1239                result = snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
1240                break;
1241        default:
1242                result = -EBADFD;
1243        }
1244        snd_pcm_stream_unlock_irq(substream);
1245 _unlock:
1246        snd_power_unlock(card);
1247        return result;
1248}
1249
1250/*
1251 * reset ioctl
1252 */
1253static int snd_pcm_pre_reset(struct snd_pcm_substream *substream, int state)
1254{
1255        struct snd_pcm_runtime *runtime = substream->runtime;
1256        switch (runtime->status->state) {
1257        case SNDRV_PCM_STATE_RUNNING:
1258        case SNDRV_PCM_STATE_PREPARED:
1259        case SNDRV_PCM_STATE_PAUSED:
1260        case SNDRV_PCM_STATE_SUSPENDED:
1261                return 0;
1262        default:
1263                return -EBADFD;
1264        }
1265}
1266
1267static int snd_pcm_do_reset(struct snd_pcm_substream *substream, int state)
1268{
1269        struct snd_pcm_runtime *runtime = substream->runtime;
1270        int err = substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL);
1271        if (err < 0)
1272                return err;
1273        runtime->hw_ptr_base = 0;
1274        runtime->hw_ptr_interrupt = runtime->status->hw_ptr -
1275                runtime->status->hw_ptr % runtime->period_size;
1276        runtime->silence_start = runtime->status->hw_ptr;
1277        runtime->silence_filled = 0;
1278        return 0;
1279}
1280
1281static void snd_pcm_post_reset(struct snd_pcm_substream *substream, int state)
1282{
1283        struct snd_pcm_runtime *runtime = substream->runtime;
1284        runtime->control->appl_ptr = runtime->status->hw_ptr;
1285        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
1286            runtime->silence_size > 0)
1287                snd_pcm_playback_silence(substream, ULONG_MAX);
1288}
1289
1290static struct action_ops snd_pcm_action_reset = {
1291        .pre_action = snd_pcm_pre_reset,
1292        .do_action = snd_pcm_do_reset,
1293        .post_action = snd_pcm_post_reset
1294};
1295
1296static int snd_pcm_reset(struct snd_pcm_substream *substream)
1297{
1298        return snd_pcm_action_nonatomic(&snd_pcm_action_reset, substream, 0);
1299}
1300
1301/*
1302 * prepare ioctl
1303 */
1304/* we use the second argument for updating f_flags */
1305static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream,
1306                               int f_flags)
1307{
1308        struct snd_pcm_runtime *runtime = substream->runtime;
1309        if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1310            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
1311                return -EBADFD;
1312        if (snd_pcm_running(substream))
1313                return -EBUSY;
1314        substream->f_flags = f_flags;
1315        return 0;
1316}
1317
1318static int snd_pcm_do_prepare(struct snd_pcm_substream *substream, int state)
1319{
1320        int err;
1321        err = substream->ops->prepare(substream);
1322        if (err < 0)
1323                return err;
1324        return snd_pcm_do_reset(substream, 0);
1325}
1326
1327static void snd_pcm_post_prepare(struct snd_pcm_substream *substream, int state)
1328{
1329        struct snd_pcm_runtime *runtime = substream->runtime;
1330        runtime->control->appl_ptr = runtime->status->hw_ptr;
1331        snd_pcm_set_state(substream, SNDRV_PCM_STATE_PREPARED);
1332}
1333
1334static struct action_ops snd_pcm_action_prepare = {
1335        .pre_action = snd_pcm_pre_prepare,
1336        .do_action = snd_pcm_do_prepare,
1337        .post_action = snd_pcm_post_prepare
1338};
1339
1340/**
1341 * snd_pcm_prepare - prepare the PCM substream to be triggerable
1342 * @substream: the PCM substream instance
1343 * @file: file to refer f_flags
1344 */
1345static int snd_pcm_prepare(struct snd_pcm_substream *substream,
1346                           struct file *file)
1347{
1348        int res;
1349        struct snd_card *card = substream->pcm->card;
1350        int f_flags;
1351
1352        if (file)
1353                f_flags = file->f_flags;
1354        else
1355                f_flags = substream->f_flags;
1356
1357        snd_power_lock(card);
1358        if ((res = snd_power_wait(card, SNDRV_CTL_POWER_D0)) >= 0)
1359                res = snd_pcm_action_nonatomic(&snd_pcm_action_prepare,
1360                                               substream, f_flags);
1361        snd_power_unlock(card);
1362        return res;
1363}
1364
1365/*
1366 * drain ioctl
1367 */
1368
1369static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, int state)
1370{
1371        struct snd_pcm_runtime *runtime = substream->runtime;
1372        switch (runtime->status->state) {
1373        case SNDRV_PCM_STATE_OPEN:
1374        case SNDRV_PCM_STATE_DISCONNECTED:
1375        case SNDRV_PCM_STATE_SUSPENDED:
1376                return -EBADFD;
1377        }
1378        runtime->trigger_master = substream;
1379        return 0;
1380}
1381
1382static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, int state)
1383{
1384        struct snd_pcm_runtime *runtime = substream->runtime;
1385        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1386                switch (runtime->status->state) {
1387                case SNDRV_PCM_STATE_PREPARED:
1388                        /* start playback stream if possible */
1389                        if (! snd_pcm_playback_empty(substream)) {
1390                                snd_pcm_do_start(substream, SNDRV_PCM_STATE_DRAINING);
1391                                snd_pcm_post_start(substream, SNDRV_PCM_STATE_DRAINING);
1392                        }
1393                        break;
1394                case SNDRV_PCM_STATE_RUNNING:
1395                        runtime->status->state = SNDRV_PCM_STATE_DRAINING;
1396                        break;
1397                case SNDRV_PCM_STATE_XRUN:
1398                        runtime->status->state = SNDRV_PCM_STATE_SETUP;
1399                        break;
1400                default:
1401                        break;
1402                }
1403        } else {
1404                /* stop running stream */
1405                if (runtime->status->state == SNDRV_PCM_STATE_RUNNING) {
1406                        int new_state = snd_pcm_capture_avail(runtime) > 0 ?
1407                                SNDRV_PCM_STATE_DRAINING : SNDRV_PCM_STATE_SETUP;
1408                        snd_pcm_do_stop(substream, new_state);
1409                        snd_pcm_post_stop(substream, new_state);
1410                }
1411        }
1412        return 0;
1413}
1414
1415static void snd_pcm_post_drain_init(struct snd_pcm_substream *substream, int state)
1416{
1417}
1418
1419static struct action_ops snd_pcm_action_drain_init = {
1420        .pre_action = snd_pcm_pre_drain_init,
1421        .do_action = snd_pcm_do_drain_init,
1422        .post_action = snd_pcm_post_drain_init
1423};
1424
1425static int snd_pcm_drop(struct snd_pcm_substream *substream);
1426
1427/*
1428 * Drain the stream(s).
1429 * When the substream is linked, sync until the draining of all playback streams
1430 * is finished.
1431 * After this call, all streams are supposed to be either SETUP or DRAINING
1432 * (capture only) state.
1433 */
1434static int snd_pcm_drain(struct snd_pcm_substream *substream,
1435                         struct file *file)
1436{
1437        struct snd_card *card;
1438        struct snd_pcm_runtime *runtime;
1439        struct snd_pcm_substream *s;
1440        wait_queue_t wait;
1441        int result = 0;
1442        int nonblock = 0;
1443
1444        card = substream->pcm->card;
1445        runtime = substream->runtime;
1446
1447        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
1448                return -EBADFD;
1449
1450        snd_power_lock(card);
1451        if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
1452                result = snd_power_wait(card, SNDRV_CTL_POWER_D0);
1453                if (result < 0) {
1454                        snd_power_unlock(card);
1455                        return result;
1456                }
1457        }
1458
1459        if (file) {
1460                if (file->f_flags & O_NONBLOCK)
1461                        nonblock = 1;
1462        } else if (substream->f_flags & O_NONBLOCK)
1463                nonblock = 1;
1464
1465        down_read(&snd_pcm_link_rwsem);
1466        snd_pcm_stream_lock_irq(substream);
1467        /* resume pause */
1468        if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
1469                snd_pcm_pause(substream, 0);
1470
1471        /* pre-start/stop - all running streams are changed to DRAINING state */
1472        result = snd_pcm_action(&snd_pcm_action_drain_init, substream, 0);
1473        if (result < 0)
1474                goto unlock;
1475        /* in non-blocking, we don't wait in ioctl but let caller poll */
1476        if (nonblock) {
1477                result = -EAGAIN;
1478                goto unlock;
1479        }
1480
1481        for (;;) {
1482                long tout;
1483                struct snd_pcm_runtime *to_check;
1484                if (signal_pending(current)) {
1485                        result = -ERESTARTSYS;
1486                        break;
1487                }
1488                /* find a substream to drain */
1489                to_check = NULL;
1490                snd_pcm_group_for_each_entry(s, substream) {
1491                        if (s->stream != SNDRV_PCM_STREAM_PLAYBACK)
1492                                continue;
1493                        runtime = s->runtime;
1494                        if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
1495                                to_check = runtime;
1496                                break;
1497                        }
1498                }
1499                if (!to_check)
1500                        break; /* all drained */
1501                init_waitqueue_entry(&wait, current);
1502                add_wait_queue(&to_check->sleep, &wait);
1503                snd_pcm_stream_unlock_irq(substream);
1504                up_read(&snd_pcm_link_rwsem);
1505                snd_power_unlock(card);
1506                if (runtime->no_period_wakeup)
1507                        tout = MAX_SCHEDULE_TIMEOUT;
1508                else {
1509                        tout = 10;
1510                        if (runtime->rate) {
1511                                long t = runtime->period_size * 2 / runtime->rate;
1512                                tout = max(t, tout);
1513                        }
1514                        tout = msecs_to_jiffies(tout * 1000);
1515                }
1516                tout = schedule_timeout_interruptible(tout);
1517                snd_power_lock(card);
1518                down_read(&snd_pcm_link_rwsem);
1519                snd_pcm_stream_lock_irq(substream);
1520                remove_wait_queue(&to_check->sleep, &wait);
1521                if (card->shutdown) {
1522                        result = -ENODEV;
1523                        break;
1524                }
1525                if (tout == 0) {
1526                        if (substream->runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
1527                                result = -ESTRPIPE;
1528                        else {
1529                                snd_printd("playback drain error (DMA or IRQ trouble?)\n");
1530                                snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1531                                result = -EIO;
1532                        }
1533                        break;
1534                }
1535        }
1536
1537 unlock:
1538        snd_pcm_stream_unlock_irq(substream);
1539        up_read(&snd_pcm_link_rwsem);
1540        snd_power_unlock(card);
1541
1542        return result;
1543}
1544
1545/*
1546 * drop ioctl
1547 *
1548 * Immediately put all linked substreams into SETUP state.
1549 */
1550static int snd_pcm_drop(struct snd_pcm_substream *substream)
1551{
1552        struct snd_pcm_runtime *runtime;
1553        int result = 0;
1554        
1555        if (PCM_RUNTIME_CHECK(substream))
1556                return -ENXIO;
1557        runtime = substream->runtime;
1558
1559        if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1560            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED ||
1561            runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
1562                return -EBADFD;
1563
1564        snd_pcm_stream_lock_irq(substream);
1565        /* resume pause */
1566        if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
1567                snd_pcm_pause(substream, 0);
1568
1569        snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1570        /* runtime->control->appl_ptr = runtime->status->hw_ptr; */
1571        snd_pcm_stream_unlock_irq(substream);
1572
1573        return result;
1574}
1575
1576
1577/* WARNING: Don't forget to fput back the file */
1578static struct file *snd_pcm_file_fd(int fd, int *fput_needed)
1579{
1580        struct file *file;
1581        struct inode *inode;
1582        unsigned int minor;
1583
1584        file = fget_light(fd, fput_needed);
1585        if (!file)
1586                return NULL;
1587        inode = file->f_path.dentry->d_inode;
1588        if (!S_ISCHR(inode->i_mode) ||
1589            imajor(inode) != snd_major) {
1590                fput_light(file, *fput_needed);
1591                return NULL;
1592        }
1593        minor = iminor(inode);
1594        if (!snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_PLAYBACK) &&
1595            !snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_CAPTURE)) {
1596                fput_light(file, *fput_needed);
1597                return NULL;
1598        }
1599        return file;
1600}
1601
1602/*
1603 * PCM link handling
1604 */
1605static int snd_pcm_link(struct snd_pcm_substream *substream, int fd)
1606{
1607        int res = 0;
1608        struct file *file;
1609        struct snd_pcm_file *pcm_file;
1610        struct snd_pcm_substream *substream1;
1611        struct snd_pcm_group *group;
1612        int fput_needed;
1613
1614        file = snd_pcm_file_fd(fd, &fput_needed);
1615        if (!file)
1616                return -EBADFD;
1617        pcm_file = file->private_data;
1618        substream1 = pcm_file->substream;
1619        group = kmalloc(sizeof(*group), GFP_KERNEL);
1620        if (!group) {
1621                res = -ENOMEM;
1622                goto _nolock;
1623        }
1624        down_write(&snd_pcm_link_rwsem);
1625        write_lock_irq(&snd_pcm_link_rwlock);
1626        if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1627            substream->runtime->status->state != substream1->runtime->status->state) {
1628                res = -EBADFD;
1629                goto _end;
1630        }
1631        if (snd_pcm_stream_linked(substream1)) {
1632                res = -EALREADY;
1633                goto _end;
1634        }
1635        if (!snd_pcm_stream_linked(substream)) {
1636                substream->group = group;
1637                spin_lock_init(&substream->group->lock);
1638                INIT_LIST_HEAD(&substream->group->substreams);
1639                list_add_tail(&substream->link_list, &substream->group->substreams);
1640                substream->group->count = 1;
1641        }
1642        list_add_tail(&substream1->link_list, &substream->group->substreams);
1643        substream->group->count++;
1644        substream1->group = substream->group;
1645 _end:
1646        write_unlock_irq(&snd_pcm_link_rwlock);
1647        up_write(&snd_pcm_link_rwsem);
1648 _nolock:
1649        snd_card_unref(substream1->pcm->card);
1650        fput_light(file, fput_needed);
1651        if (res < 0)
1652                kfree(group);
1653        return res;
1654}
1655
1656static void relink_to_local(struct snd_pcm_substream *substream)
1657{
1658        substream->group = &substream->self_group;
1659        INIT_LIST_HEAD(&substream->self_group.substreams);
1660        list_add_tail(&substream->link_list, &substream->self_group.substreams);
1661}
1662
1663static int snd_pcm_unlink(struct snd_pcm_substream *substream)
1664{
1665        struct snd_pcm_substream *s;
1666        int res = 0;
1667
1668        down_write(&snd_pcm_link_rwsem);
1669        write_lock_irq(&snd_pcm_link_rwlock);
1670        if (!snd_pcm_stream_linked(substream)) {
1671                res = -EALREADY;
1672                goto _end;
1673        }
1674        list_del(&substream->link_list);
1675        substream->group->count--;
1676        if (substream->group->count == 1) {     /* detach the last stream, too */
1677                snd_pcm_group_for_each_entry(s, substream) {
1678                        relink_to_local(s);
1679                        break;
1680                }
1681                kfree(substream->group);
1682        }
1683        relink_to_local(substream);
1684       _end:
1685        write_unlock_irq(&snd_pcm_link_rwlock);
1686        up_write(&snd_pcm_link_rwsem);
1687        return res;
1688}
1689
1690/*
1691 * hw configurator
1692 */
1693static int snd_pcm_hw_rule_mul(struct snd_pcm_hw_params *params,
1694                               struct snd_pcm_hw_rule *rule)
1695{
1696        struct snd_interval t;
1697        snd_interval_mul(hw_param_interval_c(params, rule->deps[0]),
1698                     hw_param_interval_c(params, rule->deps[1]), &t);
1699        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1700}
1701
1702static int snd_pcm_hw_rule_div(struct snd_pcm_hw_params *params,
1703                               struct snd_pcm_hw_rule *rule)
1704{
1705        struct snd_interval t;
1706        snd_interval_div(hw_param_interval_c(params, rule->deps[0]),
1707                     hw_param_interval_c(params, rule->deps[1]), &t);
1708        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1709}
1710
1711static int snd_pcm_hw_rule_muldivk(struct snd_pcm_hw_params *params,
1712                                   struct snd_pcm_hw_rule *rule)
1713{
1714        struct snd_interval t;
1715        snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]),
1716                         hw_param_interval_c(params, rule->deps[1]),
1717                         (unsigned long) rule->private, &t);
1718        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1719}
1720
1721static int snd_pcm_hw_rule_mulkdiv(struct snd_pcm_hw_params *params,
1722                                   struct snd_pcm_hw_rule *rule)
1723{
1724        struct snd_interval t;
1725        snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]),
1726                         (unsigned long) rule->private,
1727                         hw_param_interval_c(params, rule->deps[1]), &t);
1728        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1729}
1730
1731static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params,
1732                                  struct snd_pcm_hw_rule *rule)
1733{
1734        unsigned int k;
1735        struct snd_interval *i = hw_param_interval(params, rule->deps[0]);
1736        struct snd_mask m;
1737        struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1738        snd_mask_any(&m);
1739        for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
1740                int bits;
1741                if (! snd_mask_test(mask, k))
1742                        continue;
1743                bits = snd_pcm_format_physical_width(k);
1744                if (bits <= 0)
1745                        continue; /* ignore invalid formats */
1746                if ((unsigned)bits < i->min || (unsigned)bits > i->max)
1747                        snd_mask_reset(&m, k);
1748        }
1749        return snd_mask_refine(mask, &m);
1750}
1751
1752static int snd_pcm_hw_rule_sample_bits(struct snd_pcm_hw_params *params,
1753                                       struct snd_pcm_hw_rule *rule)
1754{
1755        struct snd_interval t;
1756        unsigned int k;
1757        t.min = UINT_MAX;
1758        t.max = 0;
1759        t.openmin = 0;
1760        t.openmax = 0;
1761        for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
1762                int bits;
1763                if (! snd_mask_test(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), k))
1764                        continue;
1765                bits = snd_pcm_format_physical_width(k);
1766                if (bits <= 0)
1767                        continue; /* ignore invalid formats */
1768                if (t.min > (unsigned)bits)
1769                        t.min = bits;
1770                if (t.max < (unsigned)bits)
1771                        t.max = bits;
1772        }
1773        t.integer = 1;
1774        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1775}
1776
1777#if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12
1778#error "Change this table"
1779#endif
1780
1781static unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100,
1782                                 48000, 64000, 88200, 96000, 176400, 192000 };
1783
1784const struct snd_pcm_hw_constraint_list snd_pcm_known_rates = {
1785        .count = ARRAY_SIZE(rates),
1786        .list = rates,
1787};
1788
1789static int snd_pcm_hw_rule_rate(struct snd_pcm_hw_params *params,
1790                                struct snd_pcm_hw_rule *rule)
1791{
1792        struct snd_pcm_hardware *hw = rule->private;
1793        return snd_interval_list(hw_param_interval(params, rule->var),
1794                                 snd_pcm_known_rates.count,
1795                                 snd_pcm_known_rates.list, hw->rates);
1796}               
1797
1798static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *params,
1799                                            struct snd_pcm_hw_rule *rule)
1800{
1801        struct snd_interval t;
1802        struct snd_pcm_substream *substream = rule->private;
1803        t.min = 0;
1804        t.max = substream->buffer_bytes_max;
1805        t.openmin = 0;
1806        t.openmax = 0;
1807        t.integer = 1;
1808        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1809}               
1810
1811int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream)
1812{
1813        struct snd_pcm_runtime *runtime = substream->runtime;
1814        struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1815        int k, err;
1816
1817        for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) {
1818                snd_mask_any(constrs_mask(constrs, k));
1819        }
1820
1821        for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) {
1822                snd_interval_any(constrs_interval(constrs, k));
1823        }
1824
1825        snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_CHANNELS));
1826        snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_SIZE));
1827        snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_BYTES));
1828        snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_SAMPLE_BITS));
1829        snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_FRAME_BITS));
1830
1831        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
1832                                   snd_pcm_hw_rule_format, NULL,
1833                                   SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1834        if (err < 0)
1835                return err;
1836        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 
1837                                  snd_pcm_hw_rule_sample_bits, NULL,
1838                                  SNDRV_PCM_HW_PARAM_FORMAT, 
1839                                  SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1840        if (err < 0)
1841                return err;
1842        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 
1843                                  snd_pcm_hw_rule_div, NULL,
1844                                  SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
1845        if (err < 0)
1846                return err;
1847        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
1848                                  snd_pcm_hw_rule_mul, NULL,
1849                                  SNDRV_PCM_HW_PARAM_SAMPLE_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
1850        if (err < 0)
1851                return err;
1852        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
1853                                  snd_pcm_hw_rule_mulkdiv, (void*) 8,
1854                                  SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
1855        if (err < 0)
1856                return err;
1857        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
1858                                  snd_pcm_hw_rule_mulkdiv, (void*) 8,
1859                                  SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, -1);
1860        if (err < 0)
1861                return err;
1862        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 
1863                                  snd_pcm_hw_rule_div, NULL,
1864                                  SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1865        if (err < 0)
1866                return err;
1867        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
1868                                  snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
1869                                  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_TIME, -1);
1870        if (err < 0)
1871                return err;
1872        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
1873                                  snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
1874                                  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_BUFFER_TIME, -1);
1875        if (err < 0)
1876                return err;
1877        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS, 
1878                                  snd_pcm_hw_rule_div, NULL,
1879                                  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
1880        if (err < 0)
1881                return err;
1882        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
1883                                  snd_pcm_hw_rule_div, NULL,
1884                                  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
1885        if (err < 0)
1886                return err;
1887        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
1888                                  snd_pcm_hw_rule_mulkdiv, (void*) 8,
1889                                  SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
1890        if (err < 0)
1891                return err;
1892        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
1893                                  snd_pcm_hw_rule_muldivk, (void*) 1000000,
1894                                  SNDRV_PCM_HW_PARAM_PERIOD_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
1895        if (err < 0)
1896                return err;
1897        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
1898                                  snd_pcm_hw_rule_mul, NULL,
1899                                  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
1900        if (err < 0)
1901                return err;
1902        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
1903                                  snd_pcm_hw_rule_mulkdiv, (void*) 8,
1904                                  SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
1905        if (err < 0)
1906                return err;
1907        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
1908                                  snd_pcm_hw_rule_muldivk, (void*) 1000000,
1909                                  SNDRV_PCM_HW_PARAM_BUFFER_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
1910        if (err < 0)
1911                return err;
1912        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 
1913                                  snd_pcm_hw_rule_muldivk, (void*) 8,
1914                                  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
1915        if (err < 0)
1916                return err;
1917        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 
1918                                  snd_pcm_hw_rule_muldivk, (void*) 8,
1919                                  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
1920        if (err < 0)
1921                return err;
1922        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 
1923                                  snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
1924                                  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
1925        if (err < 0)
1926                return err;
1927        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_TIME, 
1928                                  snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
1929                                  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
1930        if (err < 0)
1931                return err;
1932        return 0;
1933}
1934
1935int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
1936{
1937        struct snd_pcm_runtime *runtime = substream->runtime;
1938        struct snd_pcm_hardware *hw = &runtime->hw;
1939        int err;
1940        unsigned int mask = 0;
1941
1942        if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
1943                mask |= 1 << SNDRV_PCM_ACCESS_RW_INTERLEAVED;
1944        if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
1945                mask |= 1 << SNDRV_PCM_ACCESS_RW_NONINTERLEAVED;
1946        if (hw->info & SNDRV_PCM_INFO_MMAP) {
1947                if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
1948                        mask |= 1 << SNDRV_PCM_ACCESS_MMAP_INTERLEAVED;
1949                if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
1950                        mask |= 1 << SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED;
1951                if (hw->info & SNDRV_PCM_INFO_COMPLEX)
1952                        mask |= 1 << SNDRV_PCM_ACCESS_MMAP_COMPLEX;
1953        }
1954        err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_ACCESS, mask);
1955        if (err < 0)
1956                return err;
1957
1958        err = snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT, hw->formats);
1959        if (err < 0)
1960                return err;
1961
1962        err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_SUBFORMAT, 1 << SNDRV_PCM_SUBFORMAT_STD);
1963        if (err < 0)
1964                return err;
1965
1966        err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS,
1967                                           hw->channels_min, hw->channels_max);
1968        if (err < 0)
1969                return err;
1970
1971        err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE,
1972                                           hw->rate_min, hw->rate_max);
1973        if (err < 0)
1974                return err;
1975
1976        err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
1977                                           hw->period_bytes_min, hw->period_bytes_max);
1978        if (err < 0)
1979                return err;
1980
1981        err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS,
1982                                           hw->periods_min, hw->periods_max);
1983        if (err < 0)
1984                return err;
1985
1986        err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
1987                                           hw->period_bytes_min, hw->buffer_bytes_max);
1988        if (err < 0)
1989                return err;
1990
1991        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 
1992                                  snd_pcm_hw_rule_buffer_bytes_max, substream,
1993                                  SNDRV_PCM_HW_PARAM_BUFFER_BYTES, -1);
1994        if (err < 0)
1995                return err;
1996
1997        /* FIXME: remove */
1998        if (runtime->dma_bytes) {
1999                err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, runtime->dma_bytes);
2000                if (err < 0)
2001                        return -EINVAL;
2002        }
2003
2004        if (!(hw->rates & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))) {
2005                err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
2006                                          snd_pcm_hw_rule_rate, hw,
2007                                          SNDRV_PCM_HW_PARAM_RATE, -1);
2008                if (err < 0)
2009                        return err;
2010        }
2011
2012        /* FIXME: this belong to lowlevel */
2013        snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
2014
2015        return 0;
2016}
2017
2018static void pcm_release_private(struct snd_pcm_substream *substream)
2019{
2020        snd_pcm_unlink(substream);
2021}
2022
2023void snd_pcm_release_substream(struct snd_pcm_substream *substream)
2024{
2025        substream->ref_count--;
2026        if (substream->ref_count > 0)
2027                return;
2028
2029        snd_pcm_drop(substream);
2030        if (substream->hw_opened) {
2031                if (substream->ops->hw_free != NULL)
2032                        substream->ops->hw_free(substream);
2033                substream->ops->close(substream);
2034                substream->hw_opened = 0;
2035        }
2036        if (pm_qos_request_active(&substream->latency_pm_qos_req))
2037                pm_qos_remove_request(&substream->latency_pm_qos_req);
2038        if (substream->pcm_release) {
2039                substream->pcm_release(substream);
2040                substream->pcm_release = NULL;
2041        }
2042        snd_pcm_detach_substream(substream);
2043}
2044
2045EXPORT_SYMBOL(snd_pcm_release_substream);
2046
2047int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
2048                           struct file *file,
2049                           struct snd_pcm_substream **rsubstream)
2050{
2051        struct snd_pcm_substream *substream;
2052        int err;
2053
2054        err = snd_pcm_attach_substream(pcm, stream, file, &substream);
2055        if (err < 0)
2056                return err;
2057        if (substream->ref_count > 1) {
2058                *rsubstream = substream;
2059                return 0;
2060        }
2061
2062        err = snd_pcm_hw_constraints_init(substream);
2063        if (err < 0) {
2064                snd_printd("snd_pcm_hw_constraints_init failed\n");
2065                goto error;
2066        }
2067
2068        if ((err = substream->ops->open(substream)) < 0)
2069                goto error;
2070
2071        substream->hw_opened = 1;
2072
2073        err = snd_pcm_hw_constraints_complete(substream);
2074        if (err < 0) {
2075                snd_printd("snd_pcm_hw_constraints_complete failed\n");
2076                goto error;
2077        }
2078
2079        *rsubstream = substream;
2080        return 0;
2081
2082 error:
2083        snd_pcm_release_substream(substream);
2084        return err;
2085}
2086
2087EXPORT_SYMBOL(snd_pcm_open_substream);
2088
2089static int snd_pcm_open_file(struct file *file,
2090                             struct snd_pcm *pcm,
2091                             int stream)
2092{
2093        struct snd_pcm_file *pcm_file;
2094        struct snd_pcm_substream *substream;
2095        int err;
2096
2097        err = snd_pcm_open_substream(pcm, stream, file, &substream);
2098        if (err < 0)
2099                return err;
2100
2101        pcm_file = kzalloc(sizeof(*pcm_file), GFP_KERNEL);
2102        if (pcm_file == NULL) {
2103                snd_pcm_release_substream(substream);
2104                return -ENOMEM;
2105        }
2106        pcm_file->substream = substream;
2107        if (substream->ref_count == 1) {
2108                substream->file = pcm_file;
2109                substream->pcm_release = pcm_release_private;
2110        }
2111        file->private_data = pcm_file;
2112
2113        return 0;
2114}
2115
2116static int snd_pcm_playback_open(struct inode *inode, struct file *file)
2117{
2118        struct snd_pcm *pcm;
2119        int err = nonseekable_open(inode, file);
2120        if (err < 0)
2121                return err;
2122        pcm = snd_lookup_minor_data(iminor(inode),
2123                                    SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
2124        err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_PLAYBACK);
2125        if (pcm)
2126                snd_card_unref(pcm->card);
2127        return err;
2128}
2129
2130static int snd_pcm_capture_open(struct inode *inode, struct file *file)
2131{
2132        struct snd_pcm *pcm;
2133        int err = nonseekable_open(inode, file);
2134        if (err < 0)
2135                return err;
2136        pcm = snd_lookup_minor_data(iminor(inode),
2137                                    SNDRV_DEVICE_TYPE_PCM_CAPTURE);
2138        err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_CAPTURE);
2139        if (pcm)
2140                snd_card_unref(pcm->card);
2141        return err;
2142}
2143
2144static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream)
2145{
2146        int err;
2147        wait_queue_t wait;
2148
2149        if (pcm == NULL) {
2150                err = -ENODEV;
2151                goto __error1;
2152        }
2153        err = snd_card_file_add(pcm->card, file);
2154        if (err < 0)
2155                goto __error1;
2156        if (!try_module_get(pcm->card->module)) {
2157                err = -EFAULT;
2158                goto __error2;
2159        }
2160        init_waitqueue_entry(&wait, current);
2161        add_wait_queue(&pcm->open_wait, &wait);
2162        mutex_lock(&pcm->open_mutex);
2163        while (1) {
2164                err = snd_pcm_open_file(file, pcm, stream);
2165                if (err >= 0)
2166                        break;
2167                if (err == -EAGAIN) {
2168                        if (file->f_flags & O_NONBLOCK) {
2169                                err = -EBUSY;
2170                                break;
2171                        }
2172                } else
2173                        break;
2174                set_current_state(TASK_INTERRUPTIBLE);
2175                mutex_unlock(&pcm->open_mutex);
2176                schedule();
2177                mutex_lock(&pcm->open_mutex);
2178                if (pcm->card->shutdown) {
2179                        err = -ENODEV;
2180                        break;
2181                }
2182                if (signal_pending(current)) {
2183                        err = -ERESTARTSYS;
2184                        break;
2185                }
2186        }
2187        remove_wait_queue(&pcm->open_wait, &wait);
2188        mutex_unlock(&pcm->open_mutex);
2189        if (err < 0)
2190                goto __error;
2191        return err;
2192
2193      __error:
2194        module_put(pcm->card->module);
2195      __error2:
2196        snd_card_file_remove(pcm->card, file);
2197      __error1:
2198        return err;
2199}
2200
2201static int snd_pcm_release(struct inode *inode, struct file *file)
2202{
2203        struct snd_pcm *pcm;
2204        struct snd_pcm_substream *substream;
2205        struct snd_pcm_file *pcm_file;
2206
2207        pcm_file = file->private_data;
2208        substream = pcm_file->substream;
2209        if (snd_BUG_ON(!substream))
2210                return -ENXIO;
2211        pcm = substream->pcm;
2212        mutex_lock(&pcm->open_mutex);
2213        snd_pcm_release_substream(substream);
2214        kfree(pcm_file);
2215        mutex_unlock(&pcm->open_mutex);
2216        wake_up(&pcm->open_wait);
2217        module_put(pcm->card->module);
2218        snd_card_file_remove(pcm->card, file);
2219        return 0;
2220}
2221
2222static snd_pcm_sframes_t snd_pcm_playback_rewind(struct snd_pcm_substream *substream,
2223                                                 snd_pcm_uframes_t frames)
2224{
2225        struct snd_pcm_runtime *runtime = substream->runtime;
2226        snd_pcm_sframes_t appl_ptr;
2227        snd_pcm_sframes_t ret;
2228        snd_pcm_sframes_t hw_avail;
2229
2230        if (frames == 0)
2231                return 0;
2232
2233        snd_pcm_stream_lock_irq(substream);
2234        switch (runtime->status->state) {
2235        case SNDRV_PCM_STATE_PREPARED:
2236                break;
2237        case SNDRV_PCM_STATE_DRAINING:
2238        case SNDRV_PCM_STATE_RUNNING:
2239                if (snd_pcm_update_hw_ptr(substream) >= 0)
2240                        break;
2241                /* Fall through */
2242        case SNDRV_PCM_STATE_XRUN:
2243                ret = -EPIPE;
2244                goto __end;
2245        case SNDRV_PCM_STATE_SUSPENDED:
2246                ret = -ESTRPIPE;
2247                goto __end;
2248        default:
2249                ret = -EBADFD;
2250                goto __end;
2251        }
2252
2253        hw_avail = snd_pcm_playback_hw_avail(runtime);
2254        if (hw_avail <= 0) {
2255                ret = 0;
2256                goto __end;
2257        }
2258        if (frames > (snd_pcm_uframes_t)hw_avail)
2259                frames = hw_avail;
2260        appl_ptr = runtime->control->appl_ptr - frames;
2261        if (appl_ptr < 0)
2262                appl_ptr += runtime->boundary;
2263        runtime->control->appl_ptr = appl_ptr;
2264        ret = frames;
2265 __end:
2266        snd_pcm_stream_unlock_irq(substream);
2267        return ret;
2268}
2269
2270static snd_pcm_sframes_t snd_pcm_capture_rewind(struct snd_pcm_substream *substream,
2271                                                snd_pcm_uframes_t frames)
2272{
2273        struct snd_pcm_runtime *runtime = substream->runtime;
2274        snd_pcm_sframes_t appl_ptr;
2275        snd_pcm_sframes_t ret;
2276        snd_pcm_sframes_t hw_avail;
2277
2278        if (frames == 0)
2279                return 0;
2280
2281        snd_pcm_stream_lock_irq(substream);
2282        switch (runtime->status->state) {
2283        case SNDRV_PCM_STATE_PREPARED:
2284        case SNDRV_PCM_STATE_DRAINING:
2285                break;
2286        case SNDRV_PCM_STATE_RUNNING:
2287                if (snd_pcm_update_hw_ptr(substream) >= 0)
2288                        break;
2289                /* Fall through */
2290        case SNDRV_PCM_STATE_XRUN:
2291                ret = -EPIPE;
2292                goto __end;
2293        case SNDRV_PCM_STATE_SUSPENDED:
2294                ret = -ESTRPIPE;
2295                goto __end;
2296        default:
2297                ret = -EBADFD;
2298                goto __end;
2299        }
2300
2301        hw_avail = snd_pcm_capture_hw_avail(runtime);
2302        if (hw_avail <= 0) {
2303                ret = 0;
2304                goto __end;
2305        }
2306        if (frames > (snd_pcm_uframes_t)hw_avail)
2307                frames = hw_avail;
2308        appl_ptr = runtime->control->appl_ptr - frames;
2309        if (appl_ptr < 0)
2310                appl_ptr += runtime->boundary;
2311        runtime->control->appl_ptr = appl_ptr;
2312        ret = frames;
2313 __end:
2314        snd_pcm_stream_unlock_irq(substream);
2315        return ret;
2316}
2317
2318static snd_pcm_sframes_t snd_pcm_playback_forward(struct snd_pcm_substream *substream,
2319                                                  snd_pcm_uframes_t frames)
2320{
2321        struct snd_pcm_runtime *runtime = substream->runtime;
2322        snd_pcm_sframes_t appl_ptr;
2323        snd_pcm_sframes_t ret;
2324        snd_pcm_sframes_t avail;
2325
2326        if (frames == 0)
2327                return 0;
2328
2329        snd_pcm_stream_lock_irq(substream);
2330        switch (runtime->status->state) {
2331        case SNDRV_PCM_STATE_PREPARED:
2332        case SNDRV_PCM_STATE_PAUSED:
2333                break;
2334        case SNDRV_PCM_STATE_DRAINING:
2335        case SNDRV_PCM_STATE_RUNNING:
2336                if (snd_pcm_update_hw_ptr(substream) >= 0)
2337                        break;
2338                /* Fall through */
2339        case SNDRV_PCM_STATE_XRUN:
2340                ret = -EPIPE;
2341                goto __end;
2342        case SNDRV_PCM_STATE_SUSPENDED:
2343                ret = -ESTRPIPE;
2344                goto __end;
2345        default:
2346                ret = -EBADFD;
2347                goto __end;
2348        }
2349
2350        avail = snd_pcm_playback_avail(runtime);
2351        if (avail <= 0) {
2352                ret = 0;
2353                goto __end;
2354        }
2355        if (frames > (snd_pcm_uframes_t)avail)
2356                frames = avail;
2357        appl_ptr = runtime->control->appl_ptr + frames;
2358        if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
2359                appl_ptr -= runtime->boundary;
2360        runtime->control->appl_ptr = appl_ptr;
2361        ret = frames;
2362 __end:
2363        snd_pcm_stream_unlock_irq(substream);
2364        return ret;
2365}
2366
2367static snd_pcm_sframes_t snd_pcm_capture_forward(struct snd_pcm_substream *substream,
2368                                                 snd_pcm_uframes_t frames)
2369{
2370        struct snd_pcm_runtime *runtime = substream->runtime;
2371        snd_pcm_sframes_t appl_ptr;
2372        snd_pcm_sframes_t ret;
2373        snd_pcm_sframes_t avail;
2374
2375        if (frames == 0)
2376                return 0;
2377
2378        snd_pcm_stream_lock_irq(substream);
2379        switch (runtime->status->state) {
2380        case SNDRV_PCM_STATE_PREPARED:
2381        case SNDRV_PCM_STATE_DRAINING:
2382        case SNDRV_PCM_STATE_PAUSED:
2383                break;
2384        case SNDRV_PCM_STATE_RUNNING:
2385                if (snd_pcm_update_hw_ptr(substream) >= 0)
2386                        break;
2387                /* Fall through */
2388        case SNDRV_PCM_STATE_XRUN:
2389                ret = -EPIPE;
2390                goto __end;
2391        case SNDRV_PCM_STATE_SUSPENDED:
2392                ret = -ESTRPIPE;
2393                goto __end;
2394        default:
2395                ret = -EBADFD;
2396                goto __end;
2397        }
2398
2399        avail = snd_pcm_capture_avail(runtime);
2400        if (avail <= 0) {
2401                ret = 0;
2402                goto __end;
2403        }
2404        if (frames > (snd_pcm_uframes_t)avail)
2405                frames = avail;
2406        appl_ptr = runtime->control->appl_ptr + frames;
2407        if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
2408                appl_ptr -= runtime->boundary;
2409        runtime->control->appl_ptr = appl_ptr;
2410        ret = frames;
2411 __end:
2412        snd_pcm_stream_unlock_irq(substream);
2413        return ret;
2414}
2415
2416static int snd_pcm_hwsync(struct snd_pcm_substream *substream)
2417{
2418        struct snd_pcm_runtime *runtime = substream->runtime;
2419        int err;
2420
2421        snd_pcm_stream_lock_irq(substream);
2422        switch (runtime->status->state) {
2423        case SNDRV_PCM_STATE_DRAINING:
2424                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2425                        goto __badfd;
2426        case SNDRV_PCM_STATE_RUNNING:
2427                if ((err = snd_pcm_update_hw_ptr(substream)) < 0)
2428                        break;
2429                /* Fall through */
2430        case SNDRV_PCM_STATE_PREPARED:
2431        case SNDRV_PCM_STATE_SUSPENDED:
2432                err = 0;
2433                break;
2434        case SNDRV_PCM_STATE_XRUN:
2435                err = -EPIPE;
2436                break;
2437        default:
2438              __badfd:
2439                err = -EBADFD;
2440                break;
2441        }
2442        snd_pcm_stream_unlock_irq(substream);
2443        return err;
2444}
2445                
2446static int snd_pcm_delay(struct snd_pcm_substream *substream,
2447                         snd_pcm_sframes_t __user *res)
2448{
2449        struct snd_pcm_runtime *runtime = substream->runtime;
2450        int err;
2451        snd_pcm_sframes_t n = 0;
2452
2453        snd_pcm_stream_lock_irq(substream);
2454        switch (runtime->status->state) {
2455        case SNDRV_PCM_STATE_DRAINING:
2456                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2457                        goto __badfd;
2458        case SNDRV_PCM_STATE_RUNNING:
2459                if ((err = snd_pcm_update_hw_ptr(substream)) < 0)
2460                        break;
2461                /* Fall through */
2462        case SNDRV_PCM_STATE_PREPARED:
2463        case SNDRV_PCM_STATE_SUSPENDED:
2464                err = 0;
2465                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2466                        n = snd_pcm_playback_hw_avail(runtime);
2467                else
2468                        n = snd_pcm_capture_avail(runtime);
2469                n += runtime->delay;
2470                break;
2471        case SNDRV_PCM_STATE_XRUN:
2472                err = -EPIPE;
2473                break;
2474        default:
2475              __badfd:
2476                err = -EBADFD;
2477                break;
2478        }
2479        snd_pcm_stream_unlock_irq(substream);
2480        if (!err)
2481                if (put_user(n, res))
2482                        err = -EFAULT;
2483        return err;
2484}
2485                
2486static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream,
2487                            struct snd_pcm_sync_ptr __user *_sync_ptr)
2488{
2489        struct snd_pcm_runtime *runtime = substream->runtime;
2490        struct snd_pcm_sync_ptr sync_ptr;
2491        volatile struct snd_pcm_mmap_status *status;
2492        volatile struct snd_pcm_mmap_control *control;
2493        int err;
2494
2495        memset(&sync_ptr, 0, sizeof(sync_ptr));
2496        if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags)))
2497                return -EFAULT;
2498        if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct snd_pcm_mmap_control)))
2499                return -EFAULT; 
2500        status = runtime->status;
2501        control = runtime->control;
2502        if (sync_ptr.flags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
2503                err = snd_pcm_hwsync(substream);
2504                if (err < 0)
2505                        return err;
2506        }
2507        snd_pcm_stream_lock_irq(substream);
2508        if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL))
2509                control->appl_ptr = sync_ptr.c.control.appl_ptr;
2510        else
2511                sync_ptr.c.control.appl_ptr = control->appl_ptr;
2512        if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
2513                control->avail_min = sync_ptr.c.control.avail_min;
2514        else
2515                sync_ptr.c.control.avail_min = control->avail_min;
2516        sync_ptr.s.status.state = status->state;
2517        sync_ptr.s.status.hw_ptr = status->hw_ptr;
2518        sync_ptr.s.status.tstamp = status->tstamp;
2519        sync_ptr.s.status.suspended_state = status->suspended_state;
2520        snd_pcm_stream_unlock_irq(substream);
2521        if (copy_to_user(_sync_ptr, &sync_ptr, sizeof(sync_ptr)))
2522                return -EFAULT;
2523        return 0;
2524}
2525
2526static int snd_pcm_tstamp(struct snd_pcm_substream *substream, int __user *_arg)
2527{
2528        struct snd_pcm_runtime *runtime = substream->runtime;
2529        int arg;
2530        
2531        if (get_user(arg, _arg))
2532                return -EFAULT;
2533        if (arg < 0 || arg > SNDRV_PCM_TSTAMP_TYPE_LAST)
2534                return -EINVAL;
2535        runtime->tstamp_type = SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY;
2536        if (arg == SNDRV_PCM_TSTAMP_TYPE_MONOTONIC)
2537                runtime->tstamp_type = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC;
2538        return 0;
2539}
2540                
2541static int snd_pcm_common_ioctl1(struct file *file,
2542                                 struct snd_pcm_substream *substream,
2543                                 unsigned int cmd, void __user *arg)
2544{
2545        switch (cmd) {
2546        case SNDRV_PCM_IOCTL_PVERSION:
2547                return put_user(SNDRV_PCM_VERSION, (int __user *)arg) ? -EFAULT : 0;
2548        case SNDRV_PCM_IOCTL_INFO:
2549                return snd_pcm_info_user(substream, arg);
2550        case SNDRV_PCM_IOCTL_TSTAMP:    /* just for compatibility */
2551                return 0;
2552        case SNDRV_PCM_IOCTL_TTSTAMP:
2553                return snd_pcm_tstamp(substream, arg);
2554        case SNDRV_PCM_IOCTL_HW_REFINE:
2555                return snd_pcm_hw_refine_user(substream, arg);
2556        case SNDRV_PCM_IOCTL_HW_PARAMS:
2557                return snd_pcm_hw_params_user(substream, arg);
2558        case SNDRV_PCM_IOCTL_HW_FREE:
2559                return snd_pcm_hw_free(substream);
2560        case SNDRV_PCM_IOCTL_SW_PARAMS:
2561                return snd_pcm_sw_params_user(substream, arg);
2562        case SNDRV_PCM_IOCTL_STATUS:
2563                return snd_pcm_status_user(substream, arg);
2564        case SNDRV_PCM_IOCTL_CHANNEL_INFO:
2565                return snd_pcm_channel_info_user(substream, arg);
2566        case SNDRV_PCM_IOCTL_PREPARE:
2567                return snd_pcm_prepare(substream, file);
2568        case SNDRV_PCM_IOCTL_RESET:
2569                return snd_pcm_reset(substream);
2570        case SNDRV_PCM_IOCTL_START:
2571                return snd_pcm_action_lock_irq(&snd_pcm_action_start, substream, SNDRV_PCM_STATE_RUNNING);
2572        case SNDRV_PCM_IOCTL_LINK:
2573                return snd_pcm_link(substream, (int)(unsigned long) arg);
2574        case SNDRV_PCM_IOCTL_UNLINK:
2575                return snd_pcm_unlink(substream);
2576        case SNDRV_PCM_IOCTL_RESUME:
2577                return snd_pcm_resume(substream);
2578        case SNDRV_PCM_IOCTL_XRUN:
2579                return snd_pcm_xrun(substream);
2580        case SNDRV_PCM_IOCTL_HWSYNC:
2581                return snd_pcm_hwsync(substream);
2582        case SNDRV_PCM_IOCTL_DELAY:
2583                return snd_pcm_delay(substream, arg);
2584        case SNDRV_PCM_IOCTL_SYNC_PTR:
2585                return snd_pcm_sync_ptr(substream, arg);
2586#ifdef CONFIG_SND_SUPPORT_OLD_API
2587        case SNDRV_PCM_IOCTL_HW_REFINE_OLD:
2588                return snd_pcm_hw_refine_old_user(substream, arg);
2589        case SNDRV_PCM_IOCTL_HW_PARAMS_OLD:
2590                return snd_pcm_hw_params_old_user(substream, arg);
2591#endif
2592        case SNDRV_PCM_IOCTL_DRAIN:
2593                return snd_pcm_drain(substream, file);
2594        case SNDRV_PCM_IOCTL_DROP:
2595                return snd_pcm_drop(substream);
2596        case SNDRV_PCM_IOCTL_PAUSE:
2597        {
2598                int res;
2599                snd_pcm_stream_lock_irq(substream);
2600                res = snd_pcm_pause(substream, (int)(unsigned long)arg);
2601                snd_pcm_stream_unlock_irq(substream);
2602                return res;
2603        }
2604        }
2605        snd_printd("unknown ioctl = 0x%x\n", cmd);
2606        return -ENOTTY;
2607}
2608
2609static int snd_pcm_playback_ioctl1(struct file *file,
2610                                   struct snd_pcm_substream *substream,
2611                                   unsigned int cmd, void __user *arg)
2612{
2613        if (snd_BUG_ON(!substream))
2614                return -ENXIO;
2615        if (snd_BUG_ON(substream->stream != SNDRV_PCM_STREAM_PLAYBACK))
2616                return -EINVAL;
2617        switch (cmd) {
2618        case SNDRV_PCM_IOCTL_WRITEI_FRAMES:
2619        {
2620                struct snd_xferi xferi;
2621                struct snd_xferi __user *_xferi = arg;
2622                struct snd_pcm_runtime *runtime = substream->runtime;
2623                snd_pcm_sframes_t result;
2624                if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2625                        return -EBADFD;
2626                if (put_user(0, &_xferi->result))
2627                        return -EFAULT;
2628                if (copy_from_user(&xferi, _xferi, sizeof(xferi)))
2629                        return -EFAULT;
2630                result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames);
2631                __put_user(result, &_xferi->result);
2632                return result < 0 ? result : 0;
2633        }
2634        case SNDRV_PCM_IOCTL_WRITEN_FRAMES:
2635        {
2636                struct snd_xfern xfern;
2637                struct snd_xfern __user *_xfern = arg;
2638                struct snd_pcm_runtime *runtime = substream->runtime;
2639                void __user **bufs;
2640                snd_pcm_sframes_t result;
2641                if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2642                        return -EBADFD;
2643                if (runtime->channels > 128)
2644                        return -EINVAL;
2645                if (put_user(0, &_xfern->result))
2646                        return -EFAULT;
2647                if (copy_from_user(&xfern, _xfern, sizeof(xfern)))
2648                        return -EFAULT;
2649
2650                bufs = memdup_user(xfern.bufs,
2651                                   sizeof(void *) * runtime->channels);
2652                if (IS_ERR(bufs))
2653                        return PTR_ERR(bufs);
2654                result = snd_pcm_lib_writev(substream, bufs, xfern.frames);
2655                kfree(bufs);
2656                __put_user(result, &_xfern->result);
2657                return result < 0 ? result : 0;
2658        }
2659        case SNDRV_PCM_IOCTL_REWIND:
2660        {
2661                snd_pcm_uframes_t frames;
2662                snd_pcm_uframes_t __user *_frames = arg;
2663                snd_pcm_sframes_t result;
2664                if (get_user(frames, _frames))
2665                        return -EFAULT;
2666                if (put_user(0, _frames))
2667                        return -EFAULT;
2668                result = snd_pcm_playback_rewind(substream, frames);
2669                __put_user(result, _frames);
2670                return result < 0 ? result : 0;
2671        }
2672        case SNDRV_PCM_IOCTL_FORWARD:
2673        {
2674                snd_pcm_uframes_t frames;
2675                snd_pcm_uframes_t __user *_frames = arg;
2676                snd_pcm_sframes_t result;
2677                if (get_user(frames, _frames))
2678                        return -EFAULT;
2679                if (put_user(0, _frames))
2680                        return -EFAULT;
2681                result = snd_pcm_playback_forward(substream, frames);
2682                __put_user(result, _frames);
2683                return result < 0 ? result : 0;
2684        }
2685        }
2686        return snd_pcm_common_ioctl1(file, substream, cmd, arg);
2687}
2688
2689static int snd_pcm_capture_ioctl1(struct file *file,
2690                                  struct snd_pcm_substream *substream,
2691                                  unsigned int cmd, void __user *arg)
2692{
2693        if (snd_BUG_ON(!substream))
2694                return -ENXIO;
2695        if (snd_BUG_ON(substream->stream != SNDRV_PCM_STREAM_CAPTURE))
2696                return -EINVAL;
2697        switch (cmd) {
2698        case SNDRV_PCM_IOCTL_READI_FRAMES:
2699        {
2700                struct snd_xferi xferi;
2701                struct snd_xferi __user *_xferi = arg;
2702                struct snd_pcm_runtime *runtime = substream->runtime;
2703                snd_pcm_sframes_t result;
2704                if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2705                        return -EBADFD;
2706                if (put_user(0, &_xferi->result))
2707                        return -EFAULT;
2708                if (copy_from_user(&xferi, _xferi, sizeof(xferi)))
2709                        return -EFAULT;
2710                result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames);
2711                __put_user(result, &_xferi->result);
2712                return result < 0 ? result : 0;
2713        }
2714        case SNDRV_PCM_IOCTL_READN_FRAMES:
2715        {
2716                struct snd_xfern xfern;
2717                struct snd_xfern __user *_xfern = arg;
2718                struct snd_pcm_runtime *runtime = substream->runtime;
2719                void *bufs;
2720                snd_pcm_sframes_t result;
2721                if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2722                        return -EBADFD;
2723                if (runtime->channels > 128)
2724                        return -EINVAL;
2725                if (put_user(0, &_xfern->result))
2726                        return -EFAULT;
2727                if (copy_from_user(&xfern, _xfern, sizeof(xfern)))
2728                        return -EFAULT;
2729
2730                bufs = memdup_user(xfern.bufs,
2731                                   sizeof(void *) * runtime->channels);
2732                if (IS_ERR(bufs))
2733                        return PTR_ERR(bufs);
2734                result = snd_pcm_lib_readv(substream, bufs, xfern.frames);
2735                kfree(bufs);
2736                __put_user(result, &_xfern->result);
2737                return result < 0 ? result : 0;
2738        }
2739        case SNDRV_PCM_IOCTL_REWIND:
2740        {
2741                snd_pcm_uframes_t frames;
2742                snd_pcm_uframes_t __user *_frames = arg;
2743                snd_pcm_sframes_t result;
2744                if (get_user(frames, _frames))
2745                        return -EFAULT;
2746                if (put_user(0, _frames))
2747                        return -EFAULT;
2748                result = snd_pcm_capture_rewind(substream, frames);
2749                __put_user(result, _frames);
2750                return result < 0 ? result : 0;
2751        }
2752        case SNDRV_PCM_IOCTL_FORWARD:
2753        {
2754                snd_pcm_uframes_t frames;
2755                snd_pcm_uframes_t __user *_frames = arg;
2756                snd_pcm_sframes_t result;
2757                if (get_user(frames, _frames))
2758                        return -EFAULT;
2759                if (put_user(0, _frames))
2760                        return -EFAULT;
2761                result = snd_pcm_capture_forward(substream, frames);
2762                __put_user(result, _frames);
2763                return result < 0 ? result : 0;
2764        }
2765        }
2766        return snd_pcm_common_ioctl1(file, substream, cmd, arg);
2767}
2768
2769static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd,
2770                                   unsigned long arg)
2771{
2772        struct snd_pcm_file *pcm_file;
2773
2774        pcm_file = file->private_data;
2775
2776        if (((cmd >> 8) & 0xff) != 'A')
2777                return -ENOTTY;
2778
2779        return snd_pcm_playback_ioctl1(file, pcm_file->substream, cmd,
2780                                       (void __user *)arg);
2781}
2782
2783static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd,
2784                                  unsigned long arg)
2785{
2786        struct snd_pcm_file *pcm_file;
2787
2788        pcm_file = file->private_data;
2789
2790        if (((cmd >> 8) & 0xff) != 'A')
2791                return -ENOTTY;
2792
2793        return snd_pcm_capture_ioctl1(file, pcm_file->substream, cmd,
2794                                      (void __user *)arg);
2795}
2796
2797int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
2798                         unsigned int cmd, void *arg)
2799{
2800        mm_segment_t fs;
2801        int result;
2802        
2803        fs = snd_enter_user();
2804        switch (substream->stream) {
2805        case SNDRV_PCM_STREAM_PLAYBACK:
2806                result = snd_pcm_playback_ioctl1(NULL, substream, cmd,
2807                                                 (void __user *)arg);
2808                break;
2809        case SNDRV_PCM_STREAM_CAPTURE:
2810                result = snd_pcm_capture_ioctl1(NULL, substream, cmd,
2811                                                (void __user *)arg);
2812                break;
2813        default:
2814                result = -EINVAL;
2815                break;
2816        }
2817        snd_leave_user(fs);
2818        return result;
2819}
2820
2821EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
2822
2823static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count,
2824                            loff_t * offset)
2825{
2826        struct snd_pcm_file *pcm_file;
2827        struct snd_pcm_substream *substream;
2828        struct snd_pcm_runtime *runtime;
2829        snd_pcm_sframes_t result;
2830
2831        pcm_file = file->private_data;
2832        substream = pcm_file->substream;
2833        if (PCM_RUNTIME_CHECK(substream))
2834                return -ENXIO;
2835        runtime = substream->runtime;
2836        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2837                return -EBADFD;
2838        if (!frame_aligned(runtime, count))
2839                return -EINVAL;
2840        count = bytes_to_frames(runtime, count);
2841        result = snd_pcm_lib_read(substream, buf, count);
2842        if (result > 0)
2843                result = frames_to_bytes(runtime, result);
2844        return result;
2845}
2846
2847static ssize_t snd_pcm_write(struct file *file, const char __user *buf,
2848                             size_t count, loff_t * offset)
2849{
2850        struct snd_pcm_file *pcm_file;
2851        struct snd_pcm_substream *substream;
2852        struct snd_pcm_runtime *runtime;
2853        snd_pcm_sframes_t result;
2854
2855        pcm_file = file->private_data;
2856        substream = pcm_file->substream;
2857        if (PCM_RUNTIME_CHECK(substream))
2858                return -ENXIO;
2859        runtime = substream->runtime;
2860        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2861                return -EBADFD;
2862        if (!frame_aligned(runtime, count))
2863                return -EINVAL;
2864        count = bytes_to_frames(runtime, count);
2865        result = snd_pcm_lib_write(substream, buf, count);
2866        if (result > 0)
2867                result = frames_to_bytes(runtime, result);
2868        return result;
2869}
2870
2871static ssize_t snd_pcm_aio_read(struct kiocb *iocb, const struct iovec *iov,
2872                             unsigned long nr_segs, loff_t pos)
2873
2874{
2875        struct snd_pcm_file *pcm_file;
2876        struct snd_pcm_substream *substream;
2877        struct snd_pcm_runtime *runtime;
2878        snd_pcm_sframes_t result;
2879        unsigned long i;
2880        void __user **bufs;
2881        snd_pcm_uframes_t frames;
2882
2883        pcm_file = iocb->ki_filp->private_data;
2884        substream = pcm_file->substream;
2885        if (PCM_RUNTIME_CHECK(substream))
2886                return -ENXIO;
2887        runtime = substream->runtime;
2888        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2889                return -EBADFD;
2890        if (nr_segs > 1024 || nr_segs != runtime->channels)
2891                return -EINVAL;
2892        if (!frame_aligned(runtime, iov->iov_len))
2893                return -EINVAL;
2894        frames = bytes_to_samples(runtime, iov->iov_len);
2895        bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL);
2896        if (bufs == NULL)
2897                return -ENOMEM;
2898        for (i = 0; i < nr_segs; ++i)
2899                bufs[i] = iov[i].iov_base;
2900        result = snd_pcm_lib_readv(substream, bufs, frames);
2901        if (result > 0)
2902                result = frames_to_bytes(runtime, result);
2903        kfree(bufs);
2904        return result;
2905}
2906
2907static ssize_t snd_pcm_aio_write(struct kiocb *iocb, const struct iovec *iov,
2908                              unsigned long nr_segs, loff_t pos)
2909{
2910        struct snd_pcm_file *pcm_file;
2911        struct snd_pcm_substream *substream;
2912        struct snd_pcm_runtime *runtime;
2913        snd_pcm_sframes_t result;
2914        unsigned long i;
2915        void __user **bufs;
2916        snd_pcm_uframes_t frames;
2917
2918        pcm_file = iocb->ki_filp->private_data;
2919        substream = pcm_file->substream;
2920        if (PCM_RUNTIME_CHECK(substream))
2921                return -ENXIO;
2922        runtime = substream->runtime;
2923        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2924                return -EBADFD;
2925        if (nr_segs > 128 || nr_segs != runtime->channels ||
2926            !frame_aligned(runtime, iov->iov_len))
2927                return -EINVAL;
2928        frames = bytes_to_samples(runtime, iov->iov_len);
2929        bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL);
2930        if (bufs == NULL)
2931                return -ENOMEM;
2932        for (i = 0; i < nr_segs; ++i)
2933                bufs[i] = iov[i].iov_base;
2934        result = snd_pcm_lib_writev(substream, bufs, frames);
2935        if (result > 0)
2936                result = frames_to_bytes(runtime, result);
2937        kfree(bufs);
2938        return result;
2939}
2940
2941static unsigned int snd_pcm_playback_poll(struct file *file, poll_table * wait)
2942{
2943        struct snd_pcm_file *pcm_file;
2944        struct snd_pcm_substream *substream;
2945        struct snd_pcm_runtime *runtime;
2946        unsigned int mask;
2947        snd_pcm_uframes_t avail;
2948
2949        pcm_file = file->private_data;
2950
2951        substream = pcm_file->substream;
2952        if (PCM_RUNTIME_CHECK(substream))
2953                return -ENXIO;
2954        runtime = substream->runtime;
2955
2956        poll_wait(file, &runtime->sleep, wait);
2957
2958        snd_pcm_stream_lock_irq(substream);
2959        avail = snd_pcm_playback_avail(runtime);
2960        switch (runtime->status->state) {
2961        case SNDRV_PCM_STATE_RUNNING:
2962        case SNDRV_PCM_STATE_PREPARED:
2963        case SNDRV_PCM_STATE_PAUSED:
2964                if (avail >= runtime->control->avail_min) {
2965                        mask = POLLOUT | POLLWRNORM;
2966                        break;
2967                }
2968                /* Fall through */
2969        case SNDRV_PCM_STATE_DRAINING:
2970                mask = 0;
2971                break;
2972        default:
2973                mask = POLLOUT | POLLWRNORM | POLLERR;
2974                break;
2975        }
2976        snd_pcm_stream_unlock_irq(substream);
2977        return mask;
2978}
2979
2980static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait)
2981{
2982        struct snd_pcm_file *pcm_file;
2983        struct snd_pcm_substream *substream;
2984        struct snd_pcm_runtime *runtime;
2985        unsigned int mask;
2986        snd_pcm_uframes_t avail;
2987
2988        pcm_file = file->private_data;
2989
2990        substream = pcm_file->substream;
2991        if (PCM_RUNTIME_CHECK(substream))
2992                return -ENXIO;
2993        runtime = substream->runtime;
2994
2995        poll_wait(file, &runtime->sleep, wait);
2996
2997        snd_pcm_stream_lock_irq(substream);
2998        avail = snd_pcm_capture_avail(runtime);
2999        switch (runtime->status->state) {
3000        case SNDRV_PCM_STATE_RUNNING:
3001        case SNDRV_PCM_STATE_PREPARED:
3002        case SNDRV_PCM_STATE_PAUSED:
3003                if (avail >= runtime->control->avail_min) {
3004                        mask = POLLIN | POLLRDNORM;
3005                        break;
3006                }
3007                mask = 0;
3008                break;
3009        case SNDRV_PCM_STATE_DRAINING:
3010                if (avail > 0) {
3011                        mask = POLLIN | POLLRDNORM;
3012                        break;
3013                }
3014                /* Fall through */
3015        default:
3016                mask = POLLIN | POLLRDNORM | POLLERR;
3017                break;
3018        }
3019        snd_pcm_stream_unlock_irq(substream);
3020        return mask;
3021}
3022
3023/*
3024 * mmap support
3025 */
3026
3027/*
3028 * Only on coherent architectures, we can mmap the status and the control records
3029 * for effcient data transfer.  On others, we have to use HWSYNC ioctl...
3030 */
3031#if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
3032/*
3033 * mmap status record
3034 */
3035static int snd_pcm_mmap_status_fault(struct vm_area_struct *area,
3036                                                struct vm_fault *vmf)
3037{
3038        struct snd_pcm_substream *substream = area->vm_private_data;
3039        struct snd_pcm_runtime *runtime;
3040        
3041        if (substream == NULL)
3042                return VM_FAULT_SIGBUS;
3043        runtime = substream->runtime;
3044        vmf->page = virt_to_page(runtime->status);
3045        get_page(vmf->page);
3046        return 0;
3047}
3048
3049static const struct vm_operations_struct snd_pcm_vm_ops_status =
3050{
3051        .fault =        snd_pcm_mmap_status_fault,
3052};
3053
3054static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file,
3055                               struct vm_area_struct *area)
3056{
3057        long size;
3058        if (!(area->vm_flags & VM_READ))
3059                return -EINVAL;
3060        size = area->vm_end - area->vm_start;
3061        if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)))
3062                return -EINVAL;
3063        area->vm_ops = &snd_pcm_vm_ops_status;
3064        area->vm_private_data = substream;
3065        area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
3066        return 0;
3067}
3068
3069/*
3070 * mmap control record
3071 */
3072static int snd_pcm_mmap_control_fault(struct vm_area_struct *area,
3073                                                struct vm_fault *vmf)
3074{
3075        struct snd_pcm_substream *substream = area->vm_private_data;
3076        struct snd_pcm_runtime *runtime;
3077        
3078        if (substream == NULL)
3079                return VM_FAULT_SIGBUS;
3080        runtime = substream->runtime;
3081        vmf->page = virt_to_page(runtime->control);
3082        get_page(vmf->page);
3083        return 0;
3084}
3085
3086static const struct vm_operations_struct snd_pcm_vm_ops_control =
3087{
3088        .fault =        snd_pcm_mmap_control_fault,
3089};
3090
3091static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file,
3092                                struct vm_area_struct *area)
3093{
3094        long size;
3095        if (!(area->vm_flags & VM_READ))
3096                return -EINVAL;
3097        size = area->vm_end - area->vm_start;
3098        if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)))
3099                return -EINVAL;
3100        area->vm_ops = &snd_pcm_vm_ops_control;
3101        area->vm_private_data = substream;
3102        area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
3103        return 0;
3104}
3105#else /* ! coherent mmap */
3106/*
3107 * don't support mmap for status and control records.
3108 */
3109static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file,
3110                               struct vm_area_struct *area)
3111{
3112        return -ENXIO;
3113}
3114static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file,
3115                                struct vm_area_struct *area)
3116{
3117        return -ENXIO;
3118}
3119#endif /* coherent mmap */
3120
3121static inline struct page *
3122snd_pcm_default_page_ops(struct snd_pcm_substream *substream, unsigned long ofs)
3123{
3124        void *vaddr = substream->runtime->dma_area + ofs;
3125#if defined(CONFIG_MIPS) && defined(CONFIG_DMA_NONCOHERENT)
3126        if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV)
3127                return virt_to_page(CAC_ADDR(vaddr));
3128#endif
3129#if defined(CONFIG_PPC32) && defined(CONFIG_NOT_COHERENT_CACHE)
3130        if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV) {
3131                dma_addr_t addr = substream->runtime->dma_addr + ofs;
3132                addr -= get_dma_offset(substream->dma_buffer.dev.dev);
3133                /* assume dma_handle set via pfn_to_phys() in
3134                 * mm/dma-noncoherent.c
3135                 */
3136                return pfn_to_page(addr >> PAGE_SHIFT);
3137        }
3138#endif
3139        return virt_to_page(vaddr);
3140}
3141
3142/*
3143 * fault callback for mmapping a RAM page
3144 */
3145static int snd_pcm_mmap_data_fault(struct vm_area_struct *area,
3146                                                struct vm_fault *vmf)
3147{
3148        struct snd_pcm_substream *substream = area->vm_private_data;
3149        struct snd_pcm_runtime *runtime;
3150        unsigned long offset;
3151        struct page * page;
3152        size_t dma_bytes;
3153        
3154        if (substream == NULL)
3155                return VM_FAULT_SIGBUS;
3156        runtime = substream->runtime;
3157        offset = vmf->pgoff << PAGE_SHIFT;
3158        dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
3159        if (offset > dma_bytes - PAGE_SIZE)
3160                return VM_FAULT_SIGBUS;
3161        if (substream->ops->page)
3162                page = substream->ops->page(substream, offset);
3163        else
3164                page = snd_pcm_default_page_ops(substream, offset);
3165        if (!page)
3166                return VM_FAULT_SIGBUS;
3167        get_page(page);
3168        vmf->page = page;
3169        return 0;
3170}
3171
3172static const struct vm_operations_struct snd_pcm_vm_ops_data = {
3173        .open =         snd_pcm_mmap_data_open,
3174        .close =        snd_pcm_mmap_data_close,
3175};
3176
3177static const struct vm_operations_struct snd_pcm_vm_ops_data_fault = {
3178        .open =         snd_pcm_mmap_data_open,
3179        .close =        snd_pcm_mmap_data_close,
3180        .fault =        snd_pcm_mmap_data_fault,
3181};
3182
3183#ifndef ARCH_HAS_DMA_MMAP_COHERENT
3184/* This should be defined / handled globally! */
3185#ifdef CONFIG_ARM
3186#define ARCH_HAS_DMA_MMAP_COHERENT
3187#endif
3188#endif
3189
3190/*
3191 * mmap the DMA buffer on RAM
3192 */
3193int snd_pcm_lib_default_mmap(struct snd_pcm_substream *substream,
3194                             struct vm_area_struct *area)
3195{
3196        area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
3197#ifdef ARCH_HAS_DMA_MMAP_COHERENT
3198        if (!substream->ops->page &&
3199            substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV)
3200                return dma_mmap_coherent(substream->dma_buffer.dev.dev,
3201                                         area,
3202                                         substream->runtime->dma_area,
3203                                         substream->runtime->dma_addr,
3204                                         area->vm_end - area->vm_start);
3205#elif defined(CONFIG_MIPS) && defined(CONFIG_DMA_NONCOHERENT)
3206        if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV &&
3207            !plat_device_is_coherent(substream->dma_buffer.dev.dev))
3208                area->vm_page_prot = pgprot_noncached(area->vm_page_prot);
3209#endif /* ARCH_HAS_DMA_MMAP_COHERENT */
3210        /* mmap with fault handler */
3211        area->vm_ops = &snd_pcm_vm_ops_data_fault;
3212        return 0;
3213}
3214EXPORT_SYMBOL_GPL(snd_pcm_lib_default_mmap);
3215
3216/*
3217 * mmap the DMA buffer on I/O memory area
3218 */
3219#if SNDRV_PCM_INFO_MMAP_IOMEM
3220int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream,
3221                           struct vm_area_struct *area)
3222{
3223        long size;
3224        unsigned long offset;
3225
3226        area->vm_page_prot = pgprot_noncached(area->vm_page_prot);
3227        area->vm_flags |= VM_IO;
3228        size = area->vm_end - area->vm_start;
3229        offset = area->vm_pgoff << PAGE_SHIFT;
3230        if (io_remap_pfn_range(area, area->vm_start,
3231                                (substream->runtime->dma_addr + offset) >> PAGE_SHIFT,
3232                                size, area->vm_page_prot))
3233                return -EAGAIN;
3234        return 0;
3235}
3236
3237EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
3238#endif /* SNDRV_PCM_INFO_MMAP */
3239
3240/*
3241 * mmap DMA buffer
3242 */
3243int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file,
3244                      struct vm_area_struct *area)
3245{
3246        struct snd_pcm_runtime *runtime;
3247        long size;
3248        unsigned long offset;
3249        size_t dma_bytes;
3250        int err;
3251
3252        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
3253                if (!(area->vm_flags & (VM_WRITE|VM_READ)))
3254                        return -EINVAL;
3255        } else {
3256                if (!(area->vm_flags & VM_READ))
3257                        return -EINVAL;
3258        }
3259        runtime = substream->runtime;
3260        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3261                return -EBADFD;
3262        if (!(runtime->info & SNDRV_PCM_INFO_MMAP))
3263                return -ENXIO;
3264        if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||
3265            runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
3266                return -EINVAL;
3267        size = area->vm_end - area->vm_start;
3268        offset = area->vm_pgoff << PAGE_SHIFT;
3269        dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
3270        if ((size_t)size > dma_bytes)
3271                return -EINVAL;
3272        if (offset > dma_bytes - size)
3273                return -EINVAL;
3274
3275        area->vm_ops = &snd_pcm_vm_ops_data;
3276        area->vm_private_data = substream;
3277        if (substream->ops->mmap)
3278                err = substream->ops->mmap(substream, area);
3279        else
3280                err = snd_pcm_lib_default_mmap(substream, area);
3281        if (!err)
3282                atomic_inc(&substream->mmap_count);
3283        return err;
3284}
3285
3286EXPORT_SYMBOL(snd_pcm_mmap_data);
3287
3288static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area)
3289{
3290        struct snd_pcm_file * pcm_file;
3291        struct snd_pcm_substream *substream;    
3292        unsigned long offset;
3293        
3294        pcm_file = file->private_data;
3295        substream = pcm_file->substream;
3296        if (PCM_RUNTIME_CHECK(substream))
3297                return -ENXIO;
3298
3299        offset = area->vm_pgoff << PAGE_SHIFT;
3300        switch (offset) {
3301        case SNDRV_PCM_MMAP_OFFSET_STATUS:
3302                if (pcm_file->no_compat_mmap)
3303                        return -ENXIO;
3304                return snd_pcm_mmap_status(substream, file, area);
3305        case SNDRV_PCM_MMAP_OFFSET_CONTROL:
3306                if (pcm_file->no_compat_mmap)
3307                        return -ENXIO;
3308                return snd_pcm_mmap_control(substream, file, area);
3309        default:
3310                return snd_pcm_mmap_data(substream, file, area);
3311        }
3312        return 0;
3313}
3314
3315static int snd_pcm_fasync(int fd, struct file * file, int on)
3316{
3317        struct snd_pcm_file * pcm_file;
3318        struct snd_pcm_substream *substream;
3319        struct snd_pcm_runtime *runtime;
3320
3321        pcm_file = file->private_data;
3322        substream = pcm_file->substream;
3323        if (PCM_RUNTIME_CHECK(substream))
3324                return -ENXIO;
3325        runtime = substream->runtime;
3326        return fasync_helper(fd, file, on, &runtime->fasync);
3327}
3328
3329/*
3330 * ioctl32 compat
3331 */
3332#ifdef CONFIG_COMPAT
3333#include "pcm_compat.c"
3334#else
3335#define snd_pcm_ioctl_compat    NULL
3336#endif
3337
3338/*
3339 *  To be removed helpers to keep binary compatibility
3340 */
3341
3342#ifdef CONFIG_SND_SUPPORT_OLD_API
3343#define __OLD_TO_NEW_MASK(x) ((x&7)|((x&0x07fffff8)<<5))
3344#define __NEW_TO_OLD_MASK(x) ((x&7)|((x&0xffffff00)>>5))
3345
3346static void snd_pcm_hw_convert_from_old_params(struct snd_pcm_hw_params *params,
3347                                               struct snd_pcm_hw_params_old *oparams)
3348{
3349        unsigned int i;
3350
3351        memset(params, 0, sizeof(*params));
3352        params->flags = oparams->flags;
3353        for (i = 0; i < ARRAY_SIZE(oparams->masks); i++)
3354                params->masks[i].bits[0] = oparams->masks[i];
3355        memcpy(params->intervals, oparams->intervals, sizeof(oparams->intervals));
3356        params->rmask = __OLD_TO_NEW_MASK(oparams->rmask);
3357        params->cmask = __OLD_TO_NEW_MASK(oparams->cmask);
3358        params->info = oparams->info;
3359        params->msbits = oparams->msbits;
3360        params->rate_num = oparams->rate_num;
3361        params->rate_den = oparams->rate_den;
3362        params->fifo_size = oparams->fifo_size;
3363}
3364
3365static void snd_pcm_hw_convert_to_old_params(struct snd_pcm_hw_params_old *oparams,
3366                                             struct snd_pcm_hw_params *params)
3367{
3368        unsigned int i;
3369
3370        memset(oparams, 0, sizeof(*oparams));
3371        oparams->flags = params->flags;
3372        for (i = 0; i < ARRAY_SIZE(oparams->masks); i++)
3373                oparams->masks[i] = params->masks[i].bits[0];
3374        memcpy(oparams->intervals, params->intervals, sizeof(oparams->intervals));
3375        oparams->rmask = __NEW_TO_OLD_MASK(params->rmask);
3376        oparams->cmask = __NEW_TO_OLD_MASK(params->cmask);
3377        oparams->info = params->info;
3378        oparams->msbits = params->msbits;
3379        oparams->rate_num = params->rate_num;
3380        oparams->rate_den = params->rate_den;
3381        oparams->fifo_size = params->fifo_size;
3382}
3383
3384static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream,
3385                                      struct snd_pcm_hw_params_old __user * _oparams)
3386{
3387        struct snd_pcm_hw_params *params;
3388        struct snd_pcm_hw_params_old *oparams = NULL;
3389        int err;
3390
3391        params = kmalloc(sizeof(*params), GFP_KERNEL);
3392        if (!params)
3393                return -ENOMEM;
3394
3395        oparams = memdup_user(_oparams, sizeof(*oparams));
3396        if (IS_ERR(oparams)) {
3397                err = PTR_ERR(oparams);
3398                goto out;
3399        }
3400        snd_pcm_hw_convert_from_old_params(params, oparams);
3401        err = snd_pcm_hw_refine(substream, params);
3402        snd_pcm_hw_convert_to_old_params(oparams, params);
3403        if (copy_to_user(_oparams, oparams, sizeof(*oparams))) {
3404                if (!err)
3405                        err = -EFAULT;
3406        }
3407
3408        kfree(oparams);
3409out:
3410        kfree(params);
3411        return err;
3412}
3413
3414static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream,
3415                                      struct snd_pcm_hw_params_old __user * _oparams)
3416{
3417        struct snd_pcm_hw_params *params;
3418        struct snd_pcm_hw_params_old *oparams = NULL;
3419        int err;
3420
3421        params = kmalloc(sizeof(*params), GFP_KERNEL);
3422        if (!params)
3423                return -ENOMEM;
3424
3425        oparams = memdup_user(_oparams, sizeof(*oparams));
3426        if (IS_ERR(oparams)) {
3427                err = PTR_ERR(oparams);
3428                goto out;
3429        }
3430        snd_pcm_hw_convert_from_old_params(params, oparams);
3431        err = snd_pcm_hw_params(substream, params);
3432        snd_pcm_hw_convert_to_old_params(oparams, params);
3433        if (copy_to_user(_oparams, oparams, sizeof(*oparams))) {
3434                if (!err)
3435                        err = -EFAULT;
3436        }
3437
3438        kfree(oparams);
3439out:
3440        kfree(params);
3441        return err;
3442}
3443#endif /* CONFIG_SND_SUPPORT_OLD_API */
3444
3445#ifndef CONFIG_MMU
3446static unsigned long snd_pcm_get_unmapped_area(struct file *file,
3447                                               unsigned long addr,
3448                                               unsigned long len,
3449                                               unsigned long pgoff,
3450                                               unsigned long flags)
3451{
3452        struct snd_pcm_file *pcm_file = file->private_data;
3453        struct snd_pcm_substream *substream = pcm_file->substream;
3454        struct snd_pcm_runtime *runtime = substream->runtime;
3455        unsigned long offset = pgoff << PAGE_SHIFT;
3456
3457        switch (offset) {
3458        case SNDRV_PCM_MMAP_OFFSET_STATUS:
3459                return (unsigned long)runtime->status;
3460        case SNDRV_PCM_MMAP_OFFSET_CONTROL:
3461                return (unsigned long)runtime->control;
3462        default:
3463                return (unsigned long)runtime->dma_area + offset;
3464        }
3465}
3466#else
3467# define snd_pcm_get_unmapped_area NULL
3468#endif
3469
3470/*
3471 *  Register section
3472 */
3473
3474const struct file_operations snd_pcm_f_ops[2] = {
3475        {
3476                .owner =                THIS_MODULE,
3477                .write =                snd_pcm_write,
3478                .aio_write =            snd_pcm_aio_write,
3479                .open =                 snd_pcm_playback_open,
3480                .release =              snd_pcm_release,
3481                .llseek =               no_llseek,
3482                .poll =                 snd_pcm_playback_poll,
3483                .unlocked_ioctl =       snd_pcm_playback_ioctl,
3484                .compat_ioctl =         snd_pcm_ioctl_compat,
3485                .mmap =                 snd_pcm_mmap,
3486                .fasync =               snd_pcm_fasync,
3487                .get_unmapped_area =    snd_pcm_get_unmapped_area,
3488        },
3489        {
3490                .owner =                THIS_MODULE,
3491                .read =                 snd_pcm_read,
3492                .aio_read =             snd_pcm_aio_read,
3493                .open =                 snd_pcm_capture_open,
3494                .release =              snd_pcm_release,
3495                .llseek =               no_llseek,
3496                .poll =                 snd_pcm_capture_poll,
3497                .unlocked_ioctl =       snd_pcm_capture_ioctl,
3498                .compat_ioctl =         snd_pcm_ioctl_compat,
3499                .mmap =                 snd_pcm_mmap,
3500                .fasync =               snd_pcm_fasync,
3501                .get_unmapped_area =    snd_pcm_get_unmapped_area,
3502        }
3503};
3504
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.