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)
1579{
1580        struct file *file;
1581        struct inode *inode;
1582        unsigned int minor;
1583
1584        file = fget(fd);
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(file);
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(file);
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
1613        file = snd_pcm_file_fd(fd);
1614        if (!file)
1615                return -EBADFD;
1616        pcm_file = file->private_data;
1617        substream1 = pcm_file->substream;
1618        group = kmalloc(sizeof(*group), GFP_KERNEL);
1619        if (!group) {
1620                res = -ENOMEM;
1621                goto _nolock;
1622        }
1623        down_write(&snd_pcm_link_rwsem);
1624        write_lock_irq(&snd_pcm_link_rwlock);
1625        if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1626            substream->runtime->status->state != substream1->runtime->status->state) {
1627                res = -EBADFD;
1628                goto _end;
1629        }
1630        if (snd_pcm_stream_linked(substream1)) {
1631                res = -EALREADY;
1632                goto _end;
1633        }
1634        if (!snd_pcm_stream_linked(substream)) {
1635                substream->group = group;
1636                spin_lock_init(&substream->group->lock);
1637                INIT_LIST_HEAD(&substream->group->substreams);
1638                list_add_tail(&substream->link_list, &substream->group->substreams);
1639                substream->group->count = 1;
1640        }
1641        list_add_tail(&substream1->link_list, &substream->group->substreams);
1642        substream->group->count++;
1643        substream1->group = substream->group;
1644 _end:
1645        write_unlock_irq(&snd_pcm_link_rwlock);
1646        up_write(&snd_pcm_link_rwsem);
1647 _nolock:
1648        snd_card_unref(substream1->pcm->card);
1649        fput(file);
1650        if (res < 0)
1651                kfree(group);
1652        return res;
1653}
1654
1655static void relink_to_local(struct snd_pcm_substream *substream)
1656{
1657        substream->group = &substream->self_group;
1658        INIT_LIST_HEAD(&substream->self_group.substreams);
1659        list_add_tail(&substream->link_list, &substream->self_group.substreams);
1660}
1661
1662static int snd_pcm_unlink(struct snd_pcm_substream *substream)
1663{
1664        struct snd_pcm_substream *s;
1665        int res = 0;
1666
1667        down_write(&snd_pcm_link_rwsem);
1668        write_lock_irq(&snd_pcm_link_rwlock);
1669        if (!snd_pcm_stream_linked(substream)) {
1670                res = -EALREADY;
1671                goto _end;
1672        }
1673        list_del(&substream->link_list);
1674        substream->group->count--;
1675        if (substream->group->count == 1) {     /* detach the last stream, too */
1676                snd_pcm_group_for_each_entry(s, substream) {
1677                        relink_to_local(s);
1678                        break;
1679                }
1680                kfree(substream->group);
1681        }
1682        relink_to_local(substream);
1683       _end:
1684        write_unlock_irq(&snd_pcm_link_rwlock);
1685        up_write(&snd_pcm_link_rwsem);
1686        return res;
1687}
1688
1689/*
1690 * hw configurator
1691 */
1692static int snd_pcm_hw_rule_mul(struct snd_pcm_hw_params *params,
1693                               struct snd_pcm_hw_rule *rule)
1694{
1695        struct snd_interval t;
1696        snd_interval_mul(hw_param_interval_c(params, rule->deps[0]),
1697                     hw_param_interval_c(params, rule->deps[1]), &t);
1698        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1699}
1700
1701static int snd_pcm_hw_rule_div(struct snd_pcm_hw_params *params,
1702                               struct snd_pcm_hw_rule *rule)
1703{
1704        struct snd_interval t;
1705        snd_interval_div(hw_param_interval_c(params, rule->deps[0]),
1706                     hw_param_interval_c(params, rule->deps[1]), &t);
1707        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1708}
1709
1710static int snd_pcm_hw_rule_muldivk(struct snd_pcm_hw_params *params,
1711                                   struct snd_pcm_hw_rule *rule)
1712{
1713        struct snd_interval t;
1714        snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]),
1715                         hw_param_interval_c(params, rule->deps[1]),
1716                         (unsigned long) rule->private, &t);
1717        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1718}
1719
1720static int snd_pcm_hw_rule_mulkdiv(struct snd_pcm_hw_params *params,
1721                                   struct snd_pcm_hw_rule *rule)
1722{
1723        struct snd_interval t;
1724        snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]),
1725                         (unsigned long) rule->private,
1726                         hw_param_interval_c(params, rule->deps[1]), &t);
1727        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1728}
1729
1730static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params,
1731                                  struct snd_pcm_hw_rule *rule)
1732{
1733        unsigned int k;
1734        struct snd_interval *i = hw_param_interval(params, rule->deps[0]);
1735        struct snd_mask m;
1736        struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1737        snd_mask_any(&m);
1738        for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
1739                int bits;
1740                if (! snd_mask_test(mask, k))
1741                        continue;
1742                bits = snd_pcm_format_physical_width(k);
1743                if (bits <= 0)
1744                        continue; /* ignore invalid formats */
1745                if ((unsigned)bits < i->min || (unsigned)bits > i->max)
1746                        snd_mask_reset(&m, k);
1747        }
1748        return snd_mask_refine(mask, &m);
1749}
1750
1751static int snd_pcm_hw_rule_sample_bits(struct snd_pcm_hw_params *params,
1752                                       struct snd_pcm_hw_rule *rule)
1753{
1754        struct snd_interval t;
1755        unsigned int k;
1756        t.min = UINT_MAX;
1757        t.max = 0;
1758        t.openmin = 0;
1759        t.openmax = 0;
1760        for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
1761                int bits;
1762                if (! snd_mask_test(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), k))
1763                        continue;
1764                bits = snd_pcm_format_physical_width(k);
1765                if (bits <= 0)
1766                        continue; /* ignore invalid formats */
1767                if (t.min > (unsigned)bits)
1768                        t.min = bits;
1769                if (t.max < (unsigned)bits)
1770                        t.max = bits;
1771        }
1772        t.integer = 1;
1773        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1774}
1775
1776#if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12
1777#error "Change this table"
1778#endif
1779
1780static unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100,
1781                                 48000, 64000, 88200, 96000, 176400, 192000 };
1782
1783const struct snd_pcm_hw_constraint_list snd_pcm_known_rates = {
1784        .count = ARRAY_SIZE(rates),
1785        .list = rates,
1786};
1787
1788static int snd_pcm_hw_rule_rate(struct snd_pcm_hw_params *params,
1789                                struct snd_pcm_hw_rule *rule)
1790{
1791        struct snd_pcm_hardware *hw = rule->private;
1792        return snd_interval_list(hw_param_interval(params, rule->var),
1793                                 snd_pcm_known_rates.count,
1794                                 snd_pcm_known_rates.list, hw->rates);
1795}               
1796
1797static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *params,
1798                                            struct snd_pcm_hw_rule *rule)
1799{
1800        struct snd_interval t;
1801        struct snd_pcm_substream *substream = rule->private;
1802        t.min = 0;
1803        t.max = substream->buffer_bytes_max;
1804        t.openmin = 0;
1805        t.openmax = 0;
1806        t.integer = 1;
1807        return snd_interval_refine(hw_param_interval(params, rule->var), &t);
1808}               
1809
1810int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream)
1811{
1812        struct snd_pcm_runtime *runtime = substream->runtime;
1813        struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1814        int k, err;
1815
1816        for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) {
1817                snd_mask_any(constrs_mask(constrs, k));
1818        }
1819
1820        for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) {
1821                snd_interval_any(constrs_interval(constrs, k));
1822        }
1823
1824        snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_CHANNELS));
1825        snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_SIZE));
1826        snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_BYTES));
1827        snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_SAMPLE_BITS));
1828        snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_FRAME_BITS));
1829
1830        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
1831                                   snd_pcm_hw_rule_format, NULL,
1832                                   SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1833        if (err < 0)
1834                return err;
1835        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 
1836                                  snd_pcm_hw_rule_sample_bits, NULL,
1837                                  SNDRV_PCM_HW_PARAM_FORMAT, 
1838                                  SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1839        if (err < 0)
1840                return err;
1841        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, 
1842                                  snd_pcm_hw_rule_div, NULL,
1843                                  SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
1844        if (err < 0)
1845                return err;
1846        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
1847                                  snd_pcm_hw_rule_mul, NULL,
1848                                  SNDRV_PCM_HW_PARAM_SAMPLE_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
1849        if (err < 0)
1850                return err;
1851        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
1852                                  snd_pcm_hw_rule_mulkdiv, (void*) 8,
1853                                  SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
1854        if (err < 0)
1855                return err;
1856        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS, 
1857                                  snd_pcm_hw_rule_mulkdiv, (void*) 8,
1858                                  SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, -1);
1859        if (err < 0)
1860                return err;
1861        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 
1862                                  snd_pcm_hw_rule_div, NULL,
1863                                  SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
1864        if (err < 0)
1865                return err;
1866        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
1867                                  snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
1868                                  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_TIME, -1);
1869        if (err < 0)
1870                return err;
1871        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
1872                                  snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
1873                                  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_BUFFER_TIME, -1);
1874        if (err < 0)
1875                return err;
1876        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS, 
1877                                  snd_pcm_hw_rule_div, NULL,
1878                                  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
1879        if (err < 0)
1880                return err;
1881        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
1882                                  snd_pcm_hw_rule_div, NULL,
1883                                  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
1884        if (err < 0)
1885                return err;
1886        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
1887                                  snd_pcm_hw_rule_mulkdiv, (void*) 8,
1888                                  SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
1889        if (err < 0)
1890                return err;
1891        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 
1892                                  snd_pcm_hw_rule_muldivk, (void*) 1000000,
1893                                  SNDRV_PCM_HW_PARAM_PERIOD_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
1894        if (err < 0)
1895                return err;
1896        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
1897                                  snd_pcm_hw_rule_mul, NULL,
1898                                  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
1899        if (err < 0)
1900                return err;
1901        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
1902                                  snd_pcm_hw_rule_mulkdiv, (void*) 8,
1903                                  SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
1904        if (err < 0)
1905                return err;
1906        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 
1907                                  snd_pcm_hw_rule_muldivk, (void*) 1000000,
1908                                  SNDRV_PCM_HW_PARAM_BUFFER_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
1909        if (err < 0)
1910                return err;
1911        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 
1912                                  snd_pcm_hw_rule_muldivk, (void*) 8,
1913                                  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
1914        if (err < 0)
1915                return err;
1916        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 
1917                                  snd_pcm_hw_rule_muldivk, (void*) 8,
1918                                  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
1919        if (err < 0)
1920                return err;
1921        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 
1922                                  snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
1923                                  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
1924        if (err < 0)
1925                return err;
1926        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_TIME, 
1927                                  snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
1928                                  SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
1929        if (err < 0)
1930                return err;
1931        return 0;
1932}
1933
1934int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
1935{
1936        struct snd_pcm_runtime *runtime = substream->runtime;
1937        struct snd_pcm_hardware *hw = &runtime->hw;
1938        int err;
1939        unsigned int mask = 0;
1940
1941        if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
1942                mask |= 1 << SNDRV_PCM_ACCESS_RW_INTERLEAVED;
1943        if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
1944                mask |= 1 << SNDRV_PCM_ACCESS_RW_NONINTERLEAVED;
1945        if (hw->info & SNDRV_PCM_INFO_MMAP) {
1946                if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
1947                        mask |= 1 << SNDRV_PCM_ACCESS_MMAP_INTERLEAVED;
1948                if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
1949                        mask |= 1 << SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED;
1950                if (hw->info & SNDRV_PCM_INFO_COMPLEX)
1951                        mask |= 1 << SNDRV_PCM_ACCESS_MMAP_COMPLEX;
1952        }
1953        err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_ACCESS, mask);
1954        if (err < 0)
1955                return err;
1956
1957        err = snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT, hw->formats);
1958        if (err < 0)
1959                return err;
1960
1961        err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_SUBFORMAT, 1 << SNDRV_PCM_SUBFORMAT_STD);
1962        if (err < 0)
1963                return err;
1964
1965        err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS,
1966                                           hw->channels_min, hw->channels_max);
1967        if (err < 0)
1968                return err;
1969
1970        err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE,
1971                                           hw->rate_min, hw->rate_max);
1972        if (err < 0)
1973                return err;
1974
1975        err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
1976                                           hw->period_bytes_min, hw->period_bytes_max);
1977        if (err < 0)
1978                return err;
1979
1980        err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS,
1981                                           hw->periods_min, hw->periods_max);
1982        if (err < 0)
1983                return err;
1984
1985        err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
1986                                           hw->period_bytes_min, hw->buffer_bytes_max);
1987        if (err < 0)
1988                return err;
1989
1990        err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 
1991                                  snd_pcm_hw_rule_buffer_bytes_max, substream,
1992                                  SNDRV_PCM_HW_PARAM_BUFFER_BYTES, -1);
1993        if (err < 0)
1994                return err;
1995
1996        /* FIXME: remove */
1997        if (runtime->dma_bytes) {
1998                err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, runtime->dma_bytes);
1999                if (err < 0)
2000                        return -EINVAL;
2001        }
2002
2003        if (!(hw->rates & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))) {
2004                err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 
2005                                          snd_pcm_hw_rule_rate, hw,
2006                                          SNDRV_PCM_HW_PARAM_RATE, -1);
2007                if (err < 0)
2008                        return err;
2009        }
2010
2011        /* FIXME: this belong to lowlevel */
2012        snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
2013
2014        return 0;
2015}
2016
2017static void pcm_release_private(struct snd_pcm_substream *substream)
2018{
2019        snd_pcm_unlink(substream);
2020}
2021
2022void snd_pcm_release_substream(struct snd_pcm_substream *substream)
2023{
2024        substream->ref_count--;
2025        if (substream->ref_count > 0)
2026                return;
2027
2028        snd_pcm_drop(substream);
2029        if (substream->hw_opened) {
2030                if (substream->ops->hw_free != NULL)
2031                        substream->ops->hw_free(substream);
2032                substream->ops->close(substream);
2033                substream->hw_opened = 0;
2034        }
2035        if (pm_qos_request_active(&substream->latency_pm_qos_req))
2036                pm_qos_remove_request(&substream->latency_pm_qos_req);
2037        if (substream->pcm_release) {
2038                substream->pcm_release(substream);
2039                substream->pcm_release = NULL;
2040        }
2041        snd_pcm_detach_substream(substream);
2042}
2043
2044EXPORT_SYMBOL(snd_pcm_release_substream);
2045
2046int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
2047                           struct file *file,
2048                           struct snd_pcm_substream **rsubstream)
2049{
2050        struct snd_pcm_substream *substream;
2051        int err;
2052
2053        err = snd_pcm_attach_substream(pcm, stream, file, &substream);
2054        if (err < 0)
2055                return err;
2056        if (substream->ref_count > 1) {
2057                *rsubstream = substream;
2058                return 0;
2059        }
2060
2061        err = snd_pcm_hw_constraints_init(substream);
2062        if (err < 0) {
2063                snd_printd("snd_pcm_hw_constraints_init failed\n");
2064                goto error;
2065        }
2066
2067        if ((err = substream->ops->open(substream)) < 0)
2068                goto error;
2069
2070        substream->hw_opened = 1;
2071
2072        err = snd_pcm_hw_constraints_complete(substream);
2073        if (err < 0) {
2074                snd_printd("snd_pcm_hw_constraints_complete failed\n");
2075                goto error;
2076        }
2077
2078        *rsubstream = substream;
2079        return 0;
2080
2081 error:
2082        snd_pcm_release_substream(substream);
2083        return err;
2084}
2085
2086EXPORT_SYMBOL(snd_pcm_open_substream);
2087
2088static int snd_pcm_open_file(struct file *file,
2089                             struct snd_pcm *pcm,
2090                             int stream)
2091{
2092        struct snd_pcm_file *pcm_file;
2093        struct snd_pcm_substream *substream;
2094        int err;
2095
2096        err = snd_pcm_open_substream(pcm, stream, file, &substream);
2097        if (err < 0)
2098                return err;
2099
2100        pcm_file = kzalloc(sizeof(*pcm_file), GFP_KERNEL);
2101        if (pcm_file == NULL) {
2102                snd_pcm_release_substream(substream);
2103                return -ENOMEM;
2104        }
2105        pcm_file->substream = substream;
2106        if (substream->ref_count == 1) {
2107                substream->file = pcm_file;
2108                substream->pcm_release = pcm_release_private;
2109        }
2110        file->private_data = pcm_file;
2111
2112        return 0;
2113}
2114
2115static int snd_pcm_playback_open(struct inode *inode, struct file *file)
2116{
2117        struct snd_pcm *pcm;
2118        int err = nonseekable_open(inode, file);
2119        if (err < 0)
2120                return err;
2121        pcm = snd_lookup_minor_data(iminor(inode),
2122                                    SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
2123        err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_PLAYBACK);
2124        if (pcm)
2125                snd_card_unref(pcm->card);
2126        return err;
2127}
2128
2129static int snd_pcm_capture_open(struct inode *inode, struct file *file)
2130{
2131        struct snd_pcm *pcm;
2132        int err = nonseekable_open(inode, file);
2133        if (err < 0)
2134                return err;
2135        pcm = snd_lookup_minor_data(iminor(inode),
2136                                    SNDRV_DEVICE_TYPE_PCM_CAPTURE);
2137        err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_CAPTURE);
2138        if (pcm)
2139                snd_card_unref(pcm->card);
2140        return err;
2141}
2142
2143static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream)
2144{
2145        int err;
2146        wait_queue_t wait;
2147
2148        if (pcm == NULL) {
2149                err = -ENODEV;
2150                goto __error1;
2151        }
2152        err = snd_card_file_add(pcm->card, file);
2153        if (err < 0)
2154                goto __error1;
2155        if (!try_module_get(pcm->card->module)) {
2156                err = -EFAULT;
2157                goto __error2;
2158        }
2159        init_waitqueue_entry(&wait, current);
2160        add_wait_queue(&pcm->open_wait, &wait);
2161        mutex_lock(&pcm->open_mutex);
2162        while (1) {
2163                err = snd_pcm_open_file(file, pcm, stream);
2164                if (err >= 0)
2165                        break;
2166                if (err == -EAGAIN) {
2167                        if (file->f_flags & O_NONBLOCK) {
2168                                err = -EBUSY;
2169                                break;
2170                        }
2171                } else
2172                        break;
2173                set_current_state(TASK_INTERRUPTIBLE);
2174                mutex_unlock(&pcm->open_mutex);
2175                schedule();
2176                mutex_lock(&pcm->open_mutex);
2177                if (pcm->card->shutdown) {
2178                        err = -ENODEV;
2179                        break;
2180                }
2181                if (signal_pending(current)) {
2182                        err = -ERESTARTSYS;
2183                        break;
2184                }
2185        }
2186        remove_wait_queue(&pcm->open_wait, &wait);
2187        mutex_unlock(&pcm->open_mutex);
2188        if (err < 0)
2189                goto __error;
2190        return err;
2191
2192      __error:
2193        module_put(pcm->card->module);
2194      __error2:
2195        snd_card_file_remove(pcm->card, file);
2196      __error1:
2197        return err;
2198}
2199
2200static int snd_pcm_release(struct inode *inode, struct file *file)
2201{
2202        struct snd_pcm *pcm;
2203        struct snd_pcm_substream *substream;
2204        struct snd_pcm_file *pcm_file;
2205
2206        pcm_file = file->private_data;
2207        substream = pcm_file->substream;
2208        if (snd_BUG_ON(!substream))
2209                return -ENXIO;
2210        pcm = substream->pcm;
2211        mutex_lock(&pcm->open_mutex);
2212        snd_pcm_release_substream(substream);
2213        kfree(pcm_file);
2214        mutex_unlock(&pcm->open_mutex);
2215        wake_up(&pcm->open_wait);
2216        module_put(pcm->card->module);
2217        snd_card_file_remove(pcm->card, file);
2218        return 0;
2219}
2220
2221static snd_pcm_sframes_t snd_pcm_playback_rewind(struct snd_pcm_substream *substream,
2222                                                 snd_pcm_uframes_t frames)
2223{
2224        struct snd_pcm_runtime *runtime = substream->runtime;
2225        snd_pcm_sframes_t appl_ptr;
2226        snd_pcm_sframes_t ret;
2227        snd_pcm_sframes_t hw_avail;
2228
2229        if (frames == 0)
2230                return 0;
2231
2232        snd_pcm_stream_lock_irq(substream);
2233        switch (runtime->status->state) {
2234        case SNDRV_PCM_STATE_PREPARED:
2235                break;
2236        case SNDRV_PCM_STATE_DRAINING:
2237        case SNDRV_PCM_STATE_RUNNING:
2238                if (snd_pcm_update_hw_ptr(substream) >= 0)
2239                        break;
2240                /* Fall through */
2241        case SNDRV_PCM_STATE_XRUN:
2242                ret = -EPIPE;
2243                goto __end;
2244        case SNDRV_PCM_STATE_SUSPENDED:
2245                ret = -ESTRPIPE;
2246                goto __end;
2247        default:
2248                ret = -EBADFD;
2249                goto __end;
2250        }
2251
2252        hw_avail = snd_pcm_playback_hw_avail(runtime);
2253        if (hw_avail <= 0) {
2254                ret = 0;
2255                goto __end;
2256        }
2257        if (frames > (snd_pcm_uframes_t)hw_avail)
2258                frames = hw_avail;
2259        appl_ptr = runtime->control->appl_ptr - frames;
2260        if (appl_ptr < 0)
2261                appl_ptr += runtime->boundary;
2262        runtime->control->appl_ptr = appl_ptr;
2263        ret = frames;
2264 __end:
2265        snd_pcm_stream_unlock_irq(substream);
2266        return ret;
2267}
2268
2269static snd_pcm_sframes_t snd_pcm_capture_rewind(struct snd_pcm_substream *substream,
2270                                                snd_pcm_uframes_t frames)
2271{
2272        struct snd_pcm_runtime *runtime = substream->runtime;
2273        snd_pcm_sframes_t appl_ptr;
2274        snd_pcm_sframes_t ret;
2275        snd_pcm_sframes_t hw_avail;
2276
2277        if (frames == 0)
2278                return 0;
2279
2280        snd_pcm_stream_lock_irq(substream);
2281        switch (runtime->status->state) {
2282        case SNDRV_PCM_STATE_PREPARED:
2283        case SNDRV_PCM_STATE_DRAINING:
2284                break;
2285        case SNDRV_PCM_STATE_RUNNING:
2286                if (snd_pcm_update_hw_ptr(substream) >= 0)
2287                        break;
2288                /* Fall through */
2289        case SNDRV_PCM_STATE_XRUN:
2290                ret = -EPIPE;
2291                goto __end;
2292        case SNDRV_PCM_STATE_SUSPENDED:
2293                ret = -ESTRPIPE;
2294                goto __end;
2295        default:
2296                ret = -EBADFD;
2297                goto __end;
2298        }
2299
2300        hw_avail = snd_pcm_capture_hw_avail(runtime);
2301        if (hw_avail <= 0) {
2302                ret = 0;
2303                goto __end;
2304        }
2305        if (frames > (snd_pcm_uframes_t)hw_avail)
2306                frames = hw_avail;
2307        appl_ptr = runtime->control->appl_ptr - frames;
2308        if (appl_ptr < 0)
2309                appl_ptr += runtime->boundary;
2310        runtime->control->appl_ptr = appl_ptr;
2311        ret = frames;
2312 __end:
2313        snd_pcm_stream_unlock_irq(substream);
2314        return ret;
2315}
2316
2317static snd_pcm_sframes_t snd_pcm_playback_forward(struct snd_pcm_substream *substream,
2318                                                  snd_pcm_uframes_t frames)
2319{
2320        struct snd_pcm_runtime *runtime = substream->runtime;
2321        snd_pcm_sframes_t appl_ptr;
2322        snd_pcm_sframes_t ret;
2323        snd_pcm_sframes_t avail;
2324
2325        if (frames == 0)
2326                return 0;
2327
2328        snd_pcm_stream_lock_irq(substream);
2329        switch (runtime->status->state) {
2330        case SNDRV_PCM_STATE_PREPARED:
2331        case SNDRV_PCM_STATE_PAUSED:
2332                break;
2333        case SNDRV_PCM_STATE_DRAINING:
2334        case SNDRV_PCM_STATE_RUNNING:
2335                if (snd_pcm_update_hw_ptr(substream) >= 0)
2336                        break;
2337                /* Fall through */
2338        case SNDRV_PCM_STATE_XRUN:
2339                ret = -EPIPE;
2340                goto __end;
2341        case SNDRV_PCM_STATE_SUSPENDED:
2342                ret = -ESTRPIPE;
2343                goto __end;
2344        default:
2345                ret = -EBADFD;
2346                goto __end;
2347        }
2348
2349        avail = snd_pcm_playback_avail(runtime);
2350        if (avail <= 0) {
2351                ret = 0;
2352                goto __end;
2353        }
2354        if (frames > (snd_pcm_uframes_t)avail)
2355                frames = avail;
2356        appl_ptr = runtime->control->appl_ptr + frames;
2357        if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
2358                appl_ptr -= runtime->boundary;
2359        runtime->control->appl_ptr = appl_ptr;
2360        ret = frames;
2361 __end:
2362        snd_pcm_stream_unlock_irq(substream);
2363        return ret;
2364}
2365
2366static snd_pcm_sframes_t snd_pcm_capture_forward(struct snd_pcm_substream *substream,
2367                                                 snd_pcm_uframes_t frames)
2368{
2369        struct snd_pcm_runtime *runtime = substream->runtime;
2370        snd_pcm_sframes_t appl_ptr;
2371        snd_pcm_sframes_t ret;
2372        snd_pcm_sframes_t avail;
2373
2374        if (frames == 0)
2375                return 0;
2376
2377        snd_pcm_stream_lock_irq(substream);
2378        switch (runtime->status->state) {
2379        case SNDRV_PCM_STATE_PREPARED:
2380        case SNDRV_PCM_STATE_DRAINING:
2381        case SNDRV_PCM_STATE_PAUSED:
2382                break;
2383        case SNDRV_PCM_STATE_RUNNING:
2384                if (snd_pcm_update_hw_ptr(substream) >= 0)
2385                        break;
2386                /* Fall through */
2387        case SNDRV_PCM_STATE_XRUN:
2388                ret = -EPIPE;
2389                goto __end;
2390        case SNDRV_PCM_STATE_SUSPENDED:
2391                ret = -ESTRPIPE;
2392                goto __end;
2393        default:
2394                ret = -EBADFD;
2395                goto __end;
2396        }
2397
2398        avail = snd_pcm_capture_avail(runtime);
2399        if (avail <= 0) {
2400                ret = 0;
2401                goto __end;
2402        }
2403        if (frames > (snd_pcm_uframes_t)avail)
2404                frames = avail;
2405        appl_ptr = runtime->control->appl_ptr + frames;
2406        if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
2407                appl_ptr -= runtime->boundary;
2408        runtime->control->appl_ptr = appl_ptr;
2409        ret = frames;
2410 __end:
2411        snd_pcm_stream_unlock_irq(substream);
2412        return ret;
2413}
2414
2415static int snd_pcm_hwsync(struct snd_pcm_substream *substream)
2416{
2417        struct snd_pcm_runtime *runtime = substream->runtime;
2418        int err;
2419
2420        snd_pcm_stream_lock_irq(substream);
2421        switch (runtime->status->state) {
2422        case SNDRV_PCM_STATE_DRAINING:
2423                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2424                        goto __badfd;
2425        case SNDRV_PCM_STATE_RUNNING:
2426                if ((err = snd_pcm_update_hw_ptr(substream)) < 0)
2427                        break;
2428                /* Fall through */
2429        case SNDRV_PCM_STATE_PREPARED:
2430        case SNDRV_PCM_STATE_SUSPENDED:
2431                err = 0;
2432                break;
2433        case SNDRV_PCM_STATE_XRUN:
2434                err = -EPIPE;
2435                break;
2436        default:
2437              __badfd:
2438                err = -EBADFD;
2439                break;
2440        }
2441        snd_pcm_stream_unlock_irq(substream);
2442        return err;
2443}
2444                
2445static int snd_pcm_delay(struct snd_pcm_substream *substream,
2446                         snd_pcm_sframes_t __user *res)
2447{
2448        struct snd_pcm_runtime *runtime = substream->runtime;
2449        int err;
2450        snd_pcm_sframes_t n = 0;
2451
2452        snd_pcm_stream_lock_irq(substream);
2453        switch (runtime->status->state) {
2454        case SNDRV_PCM_STATE_DRAINING:
2455                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2456                        goto __badfd;
2457        case SNDRV_PCM_STATE_RUNNING:
2458                if ((err = snd_pcm_update_hw_ptr(substream)) < 0)
2459                        break;
2460                /* Fall through */
2461        case SNDRV_PCM_STATE_PREPARED:
2462        case SNDRV_PCM_STATE_SUSPENDED:
2463                err = 0;
2464                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2465                        n = snd_pcm_playback_hw_avail(runtime);
2466                else
2467                        n = snd_pcm_capture_avail(runtime);
2468                n += runtime->delay;
2469                break;
2470        case SNDRV_PCM_STATE_XRUN:
2471                err = -EPIPE;
2472                break;
2473        default:
2474              __badfd:
2475                err = -EBADFD;
2476                break;
2477        }
2478        snd_pcm_stream_unlock_irq(substream);
2479        if (!err)
2480                if (put_user(n, res))
2481                        err = -EFAULT;
2482        return err;
2483}
2484                
2485static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream,
2486                            struct snd_pcm_sync_ptr __user *_sync_ptr)
2487{
2488        struct snd_pcm_runtime *runtime = substream->runtime;
2489        struct snd_pcm_sync_ptr sync_ptr;
2490        volatile struct snd_pcm_mmap_status *status;
2491        volatile struct snd_pcm_mmap_control *control;
2492        int err;
2493
2494        memset(&sync_ptr, 0, sizeof(sync_ptr));
2495        if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags)))
2496                return -EFAULT;
2497        if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct snd_pcm_mmap_control)))
2498                return -EFAULT; 
2499        status = runtime->status;
2500        control = runtime->control;
2501        if (sync_ptr.flags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
2502                err = snd_pcm_hwsync(substream);
2503                if (err < 0)
2504                        return err;
2505        }
2506        snd_pcm_stream_lock_irq(substream);
2507        if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL))
2508                control->appl_ptr = sync_ptr.c.control.appl_ptr;
2509        else
2510                sync_ptr.c.control.appl_ptr = control->appl_ptr;
2511        if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
2512                control->avail_min = sync_ptr.c.control.avail_min;
2513        else
2514                sync_ptr.c.control.avail_min = control->avail_min;
2515        sync_ptr.s.status.state = status->state;
2516        sync_ptr.s.status.hw_ptr = status->hw_ptr;
2517        sync_ptr.s.status.tstamp = status->tstamp;
2518        sync_ptr.s.status.suspended_state = status->suspended_state;
2519        snd_pcm_stream_unlock_irq(substream);
2520        if (copy_to_user(_sync_ptr, &sync_ptr, sizeof(sync_ptr)))
2521                return -EFAULT;
2522        return 0;
2523}
2524
2525static int snd_pcm_tstamp(struct snd_pcm_substream *substream, int __user *_arg)
2526{
2527        struct snd_pcm_runtime *runtime = substream->runtime;
2528        int arg;
2529        
2530        if (get_user(arg, _arg))
2531                return -EFAULT;
2532        if (arg < 0 || arg > SNDRV_PCM_TSTAMP_TYPE_LAST)
2533                return -EINVAL;
2534        runtime->tstamp_type = SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY;
2535        if (arg == SNDRV_PCM_TSTAMP_TYPE_MONOTONIC)
2536                runtime->tstamp_type = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC;
2537        return 0;
2538}
2539                
2540static int snd_pcm_common_ioctl1(struct file *file,
2541                                 struct snd_pcm_substream *substream,
2542                                 unsigned int cmd, void __user *arg)
2543{
2544        switch (cmd) {
2545        case SNDRV_PCM_IOCTL_PVERSION:
2546                return put_user(SNDRV_PCM_VERSION, (int __user *)arg) ? -EFAULT : 0;
2547        case SNDRV_PCM_IOCTL_INFO:
2548                return snd_pcm_info_user(substream, arg);
2549        case SNDRV_PCM_IOCTL_TSTAMP:    /* just for compatibility */
2550                return 0;
2551        case SNDRV_PCM_IOCTL_TTSTAMP:
2552                return snd_pcm_tstamp(substream, arg);
2553        case SNDRV_PCM_IOCTL_HW_REFINE:
2554                return snd_pcm_hw_refine_user(substream, arg);
2555        case SNDRV_PCM_IOCTL_HW_PARAMS:
2556                return snd_pcm_hw_params_user(substream, arg);
2557        case SNDRV_PCM_IOCTL_HW_FREE:
2558                return snd_pcm_hw_free(substream);
2559        case SNDRV_PCM_IOCTL_SW_PARAMS:
2560                return snd_pcm_sw_params_user(substream, arg);
2561        case SNDRV_PCM_IOCTL_STATUS:
2562                return snd_pcm_status_user(substream, arg);
2563        case SNDRV_PCM_IOCTL_CHANNEL_INFO:
2564                return snd_pcm_channel_info_user(substream, arg);
2565        case SNDRV_PCM_IOCTL_PREPARE:
2566                return snd_pcm_prepare(substream, file);
2567        case SNDRV_PCM_IOCTL_RESET:
2568                return snd_pcm_reset(substream);
2569        case SNDRV_PCM_IOCTL_START:
2570                return snd_pcm_action_lock_irq(&snd_pcm_action_start, substream, SNDRV_PCM_STATE_RUNNING);
2571        case SNDRV_PCM_IOCTL_LINK:
2572                return snd_pcm_link(substream, (int)(unsigned long) arg);
2573        case SNDRV_PCM_IOCTL_UNLINK:
2574                return snd_pcm_unlink(substream);
2575        case SNDRV_PCM_IOCTL_RESUME:
2576                return snd_pcm_resume(substream);
2577        case SNDRV_PCM_IOCTL_XRUN:
2578                return snd_pcm_xrun(substream);
2579        case SNDRV_PCM_IOCTL_HWSYNC:
2580                return snd_pcm_hwsync(substream);
2581        case SNDRV_PCM_IOCTL_DELAY:
2582                return snd_pcm_delay(substream, arg);
2583        case SNDRV_PCM_IOCTL_SYNC_PTR:
2584                return snd_pcm_sync_ptr(substream, arg);
2585#ifdef CONFIG_SND_SUPPORT_OLD_API
2586        case SNDRV_PCM_IOCTL_HW_REFINE_OLD:
2587                return snd_pcm_hw_refine_old_user(substream, arg);
2588        case SNDRV_PCM_IOCTL_HW_PARAMS_OLD:
2589                return snd_pcm_hw_params_old_user(substream, arg);
2590#endif
2591        case SNDRV_PCM_IOCTL_DRAIN:
2592                return snd_pcm_drain(substream, file);
2593        case SNDRV_PCM_IOCTL_DROP:
2594                return snd_pcm_drop(substream);
2595        case SNDRV_PCM_IOCTL_PAUSE:
2596        {
2597                int res;
2598                snd_pcm_stream_lock_irq(substream);
2599                res = snd_pcm_pause(substream, (int)(unsigned long)arg);
2600                snd_pcm_stream_unlock_irq(substream);
2601                return res;
2602        }
2603        }
2604        snd_printd("unknown ioctl = 0x%x\n", cmd);
2605        return -ENOTTY;
2606}
2607
2608static int snd_pcm_playback_ioctl1(struct file *file,
2609                                   struct snd_pcm_substream *substream,
2610                                   unsigned int cmd, void __user *arg)
2611{
2612        if (snd_BUG_ON(!substream))
2613                return -ENXIO;
2614        if (snd_BUG_ON(substream->stream != SNDRV_PCM_STREAM_PLAYBACK))
2615                return -EINVAL;
2616        switch (cmd) {
2617        case SNDRV_PCM_IOCTL_WRITEI_FRAMES:
2618        {
2619                struct snd_xferi xferi;
2620                struct snd_xferi __user *_xferi = arg;
2621                struct snd_pcm_runtime *runtime = substream->runtime;
2622                snd_pcm_sframes_t result;
2623                if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2624                        return -EBADFD;
2625                if (put_user(0, &_xferi->result))
2626                        return -EFAULT;
2627                if (copy_from_user(&xferi, _xferi, sizeof(xferi)))
2628                        return -EFAULT;
2629                result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames);
2630                __put_user(result, &_xferi->result);
2631                return result < 0 ? result : 0;
2632        }
2633        case SNDRV_PCM_IOCTL_WRITEN_FRAMES:
2634        {
2635                struct snd_xfern xfern;
2636                struct snd_xfern __user *_xfern = arg;
2637                struct snd_pcm_runtime *runtime = substream->runtime;
2638                void __user **bufs;
2639                snd_pcm_sframes_t result;
2640                if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2641                        return -EBADFD;
2642                if (runtime->channels > 128)
2643                        return -EINVAL;
2644                if (put_user(0, &_xfern->result))
2645                        return -EFAULT;
2646                if (copy_from_user(&xfern, _xfern, sizeof(xfern)))
2647                        return -EFAULT;
2648
2649                bufs = memdup_user(xfern.bufs,
2650                                   sizeof(void *) * runtime->channels);
2651                if (IS_ERR(bufs))
2652                        return PTR_ERR(bufs);
2653                result = snd_pcm_lib_writev(substream, bufs, xfern.frames);
2654                kfree(bufs);
2655                __put_user(result, &_xfern->result);
2656                return result < 0 ? result : 0;
2657        }
2658        case SNDRV_PCM_IOCTL_REWIND:
2659        {
2660                snd_pcm_uframes_t frames;
2661                snd_pcm_uframes_t __user *_frames = arg;
2662                snd_pcm_sframes_t result;
2663                if (get_user(frames, _frames))
2664                        return -EFAULT;
2665                if (put_user(0, _frames))
2666                        return -EFAULT;
2667                result = snd_pcm_playback_rewind(substream, frames);
2668                __put_user(result, _frames);
2669                return result < 0 ? result : 0;
2670        }
2671        case SNDRV_PCM_IOCTL_FORWARD:
2672        {
2673                snd_pcm_uframes_t frames;
2674                snd_pcm_uframes_t __user *_frames = arg;
2675                snd_pcm_sframes_t result;
2676                if (get_user(frames, _frames))
2677                        return -EFAULT;
2678                if (put_user(0, _frames))
2679                        return -EFAULT;
2680                result = snd_pcm_playback_forward(substream, frames);
2681                __put_user(result, _frames);
2682                return result < 0 ? result : 0;
2683        }
2684        }
2685        return snd_pcm_common_ioctl1(file, substream, cmd, arg);
2686}
2687
2688static int snd_pcm_capture_ioctl1(struct file *file,
2689                                  struct snd_pcm_substream *substream,
2690                                  unsigned int cmd, void __user *arg)
2691{
2692        if (snd_BUG_ON(!substream))
2693                return -ENXIO;
2694        if (snd_BUG_ON(substream->stream != SNDRV_PCM_STREAM_CAPTURE))
2695                return -EINVAL;
2696        switch (cmd) {
2697        case SNDRV_PCM_IOCTL_READI_FRAMES:
2698        {
2699                struct snd_xferi xferi;
2700                struct snd_xferi __user *_xferi = arg;
2701                struct snd_pcm_runtime *runtime = substream->runtime;
2702                snd_pcm_sframes_t result;
2703                if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2704                        return -EBADFD;
2705                if (put_user(0, &_xferi->result))
2706                        return -EFAULT;
2707                if (copy_from_user(&xferi, _xferi, sizeof(xferi)))
2708                        return -EFAULT;
2709                result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames);
2710                __put_user(result, &_xferi->result);
2711                return result < 0 ? result : 0;
2712        }
2713        case SNDRV_PCM_IOCTL_READN_FRAMES:
2714        {
2715                struct snd_xfern xfern;
2716                struct snd_xfern __user *_xfern = arg;
2717                struct snd_pcm_runtime *runtime = substream->runtime;
2718                void *bufs;
2719                snd_pcm_sframes_t result;
2720                if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2721                        return -EBADFD;
2722                if (runtime->channels > 128)
2723                        return -EINVAL;
2724                if (put_user(0, &_xfern->result))
2725                        return -EFAULT;
2726                if (copy_from_user(&xfern, _xfern, sizeof(xfern)))
2727                        return -EFAULT;
2728
2729                bufs = memdup_user(xfern.bufs,
2730                                   sizeof(void *) * runtime->channels);
2731                if (IS_ERR(bufs))
2732                        return PTR_ERR(bufs);
2733                result = snd_pcm_lib_readv(substream, bufs, xfern.frames);
2734                kfree(bufs);
2735                __put_user(result, &_xfern->result);
2736                return result < 0 ? result : 0;
2737        }
2738        case SNDRV_PCM_IOCTL_REWIND:
2739        {
2740                snd_pcm_uframes_t frames;
2741                snd_pcm_uframes_t __user *_frames = arg;
2742                snd_pcm_sframes_t result;
2743                if (get_user(frames, _frames))
2744                        return -EFAULT;
2745                if (put_user(0, _frames))
2746                        return -EFAULT;
2747                result = snd_pcm_capture_rewind(substream, frames);
2748                __put_user(result, _frames);
2749                return result < 0 ? result : 0;
2750        }
2751        case SNDRV_PCM_IOCTL_FORWARD:
2752        {
2753                snd_pcm_uframes_t frames;
2754                snd_pcm_uframes_t __user *_frames = arg;
2755                snd_pcm_sframes_t result;
2756                if (get_user(frames, _frames))
2757                        return -EFAULT;
2758                if (put_user(0, _frames))
2759                        return -EFAULT;
2760                result = snd_pcm_capture_forward(substream, frames);
2761                __put_user(result, _frames);
2762                return result < 0 ? result : 0;
2763        }
2764        }
2765        return snd_pcm_common_ioctl1(file, substream, cmd, arg);
2766}
2767
2768static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd,
2769                                   unsigned long arg)
2770{
2771        struct snd_pcm_file *pcm_file;
2772
2773        pcm_file = file->private_data;
2774
2775        if (((cmd >> 8) & 0xff) != 'A')
2776                return -ENOTTY;
2777
2778        return snd_pcm_playback_ioctl1(file, pcm_file->substream, cmd,
2779                                       (void __user *)arg);
2780}
2781
2782static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd,
2783                                  unsigned long arg)
2784{
2785        struct snd_pcm_file *pcm_file;
2786
2787        pcm_file = file->private_data;
2788
2789        if (((cmd >> 8) & 0xff) != 'A')
2790                return -ENOTTY;
2791
2792        return snd_pcm_capture_ioctl1(file, pcm_file->substream, cmd,
2793                                      (void __user *)arg);
2794}
2795
2796int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
2797                         unsigned int cmd, void *arg)
2798{
2799        mm_segment_t fs;
2800        int result;
2801        
2802        fs = snd_enter_user();
2803        switch (substream->stream) {
2804        case SNDRV_PCM_STREAM_PLAYBACK:
2805                result = snd_pcm_playback_ioctl1(NULL, substream, cmd,
2806                                                 (void __user *)arg);
2807                break;
2808        case SNDRV_PCM_STREAM_CAPTURE:
2809                result = snd_pcm_capture_ioctl1(NULL, substream, cmd,
2810                                                (void __user *)arg);
2811                break;
2812        default:
2813                result = -EINVAL;
2814                break;
2815        }
2816        snd_leave_user(fs);
2817        return result;
2818}
2819
2820EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
2821
2822static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count,
2823                            loff_t * offset)
2824{
2825        struct snd_pcm_file *pcm_file;
2826        struct snd_pcm_substream *substream;
2827        struct snd_pcm_runtime *runtime;
2828        snd_pcm_sframes_t result;
2829
2830        pcm_file = file->private_data;
2831        substream = pcm_file->substream;
2832        if (PCM_RUNTIME_CHECK(substream))
2833                return -ENXIO;
2834        runtime = substream->runtime;
2835        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2836                return -EBADFD;
2837        if (!frame_aligned(runtime, count))
2838                return -EINVAL;
2839        count = bytes_to_frames(runtime, count);
2840        result = snd_pcm_lib_read(substream, buf, count);
2841        if (result > 0)
2842                result = frames_to_bytes(runtime, result);
2843        return result;
2844}
2845
2846static ssize_t snd_pcm_write(struct file *file, const char __user *buf,
2847                             size_t count, loff_t * offset)
2848{
2849        struct snd_pcm_file *pcm_file;
2850        struct snd_pcm_substream *substream;
2851        struct snd_pcm_runtime *runtime;
2852        snd_pcm_sframes_t result;
2853
2854        pcm_file = file->private_data;
2855        substream = pcm_file->substream;
2856        if (PCM_RUNTIME_CHECK(substream))
2857                return -ENXIO;
2858        runtime = substream->runtime;
2859        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2860                return -EBADFD;
2861        if (!frame_aligned(runtime, count))
2862                return -EINVAL;
2863        count = bytes_to_frames(runtime, count);
2864        result = snd_pcm_lib_write(substream, buf, count);
2865        if (result > 0)
2866                result = frames_to_bytes(runtime, result);
2867        return result;
2868}
2869
2870static ssize_t snd_pcm_aio_read(struct kiocb *iocb, const struct iovec *iov,
2871                             unsigned long nr_segs, loff_t pos)
2872
2873{
2874        struct snd_pcm_file *pcm_file;
2875        struct snd_pcm_substream *substream;
2876        struct snd_pcm_runtime *runtime;
2877        snd_pcm_sframes_t result;
2878        unsigned long i;
2879        void __user **bufs;
2880        snd_pcm_uframes_t frames;
2881
2882        pcm_file = iocb->ki_filp->private_data;
2883        substream = pcm_file->substream;
2884        if (PCM_RUNTIME_CHECK(substream))
2885                return -ENXIO;
2886        runtime = substream->runtime;
2887        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2888                return -EBADFD;
2889        if (nr_segs > 1024 || nr_segs != runtime->channels)
2890                return -EINVAL;
2891        if (!frame_aligned(runtime, iov->iov_len))
2892                return -EINVAL;
2893        frames = bytes_to_samples(runtime, iov->iov_len);
2894        bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL);
2895        if (bufs == NULL)
2896                return -ENOMEM;
2897        for (i = 0; i < nr_segs; ++i)
2898                bufs[i] = iov[i].iov_base;
2899        result = snd_pcm_lib_readv(substream, bufs, frames);
2900        if (result > 0)
2901                result = frames_to_bytes(runtime, result);
2902        kfree(bufs);
2903        return result;
2904}
2905
2906static ssize_t snd_pcm_aio_write(struct kiocb *iocb, const struct iovec *iov,
2907                              unsigned long nr_segs, loff_t pos)
2908{
2909        struct snd_pcm_file *pcm_file;
2910        struct snd_pcm_substream *substream;
2911        struct snd_pcm_runtime *runtime;
2912        snd_pcm_sframes_t result;
2913        unsigned long i;
2914        void __user **bufs;
2915        snd_pcm_uframes_t frames;
2916
2917        pcm_file = iocb->ki_filp->private_data;
2918        substream = pcm_file->substream;
2919        if (PCM_RUNTIME_CHECK(substream))
2920                return -ENXIO;
2921        runtime = substream->runtime;
2922        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2923                return -EBADFD;
2924        if (nr_segs > 128 || nr_segs != runtime->channels ||
2925            !frame_aligned(runtime, iov->iov_len))
2926                return -EINVAL;
2927        frames = bytes_to_samples(runtime, iov->iov_len);
2928        bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL);
2929        if (bufs == NULL)
2930                return -ENOMEM;
2931        for (i = 0; i < nr_segs; ++i)
2932                bufs[i] = iov[i].iov_base;
2933        result = snd_pcm_lib_writev(substream, bufs, frames);
2934        if (result > 0)
2935                result = frames_to_bytes(runtime, result);
2936        kfree(bufs);
2937        return result;
2938}
2939
2940static unsigned int snd_pcm_playback_poll(struct file *file, poll_table * wait)
2941{
2942        struct snd_pcm_file *pcm_file;
2943        struct snd_pcm_substream *substream;
2944        struct snd_pcm_runtime *runtime;
2945        unsigned int mask;
2946        snd_pcm_uframes_t avail;
2947
2948        pcm_file = file->private_data;
2949
2950        substream = pcm_file->substream;
2951        if (PCM_RUNTIME_CHECK(substream))
2952                return -ENXIO;
2953        runtime = substream->runtime;
2954
2955        poll_wait(file, &runtime->sleep, wait);
2956
2957        snd_pcm_stream_lock_irq(substream);
2958        avail = snd_pcm_playback_avail(runtime);
2959        switch (runtime->status->state) {
2960        case SNDRV_PCM_STATE_RUNNING:
2961        case SNDRV_PCM_STATE_PREPARED:
2962        case SNDRV_PCM_STATE_PAUSED:
2963                if (avail >= runtime->control->avail_min) {
2964                        mask = POLLOUT | POLLWRNORM;
2965                        break;
2966                }
2967                /* Fall through */
2968        case SNDRV_PCM_STATE_DRAINING:
2969                mask = 0;
2970                break;
2971        default:
2972                mask = POLLOUT | POLLWRNORM | POLLERR;
2973                break;
2974        }
2975        snd_pcm_stream_unlock_irq(substream);
2976        return mask;
2977}
2978
2979static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait)
2980{
2981        struct snd_pcm_file *pcm_file;
2982        struct snd_pcm_substream *substream;
2983        struct snd_pcm_runtime *runtime;
2984        unsigned int mask;
2985        snd_pcm_uframes_t avail;
2986
2987        pcm_file = file->private_data;
2988
2989        substream = pcm_file->substream;
2990        if (PCM_RUNTIME_CHECK(substream))
2991                return -ENXIO;
2992        runtime = substream->runtime;
2993
2994        poll_wait(file, &runtime->sleep, wait);
2995
2996        snd_pcm_stream_lock_irq(substream);
2997        avail = snd_pcm_capture_avail(runtime);
2998        switch (runtime->status->state) {
2999        case SNDRV_PCM_STATE_RUNNING:
3000        case SNDRV_PCM_STATE_PREPARED:
3001        case SNDRV_PCM_STATE_PAUSED:
3002                if (avail >= runtime->control->avail_min) {
3003                        mask = POLLIN | POLLRDNORM;
3004                        break;
3005                }
3006                mask = 0;
3007                break;
3008        case SNDRV_PCM_STATE_DRAINING:
3009                if (avail > 0) {
3010                        mask = POLLIN | POLLRDNORM;
3011                        break;
3012                }
3013                /* Fall through */
3014        default:
3015                mask = POLLIN | POLLRDNORM | POLLERR;
3016                break;
3017        }
3018        snd_pcm_stream_unlock_irq(substream);
3019        return mask;
3020}
3021
3022/*
3023 * mmap support
3024 */
3025
3026/*
3027 * Only on coherent architectures, we can mmap the status and the control records
3028 * for effcient data transfer.  On others, we have to use HWSYNC ioctl...
3029 */
3030#if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
3031/*
3032 * mmap status record
3033 */
3034static int snd_pcm_mmap_status_fault(struct vm_area_struct *area,
3035                                                struct vm_fault *vmf)
3036{
3037        struct snd_pcm_substream *substream = area->vm_private_data;
3038        struct snd_pcm_runtime *runtime;
3039        
3040        if (substream == NULL)
3041                return VM_FAULT_SIGBUS;
3042        runtime = substream->runtime;
3043        vmf->page = virt_to_page(runtime->status);
3044        get_page(vmf->page);
3045        return 0;
3046}
3047
3048static const struct vm_operations_struct snd_pcm_vm_ops_status =
3049{
3050        .fault =        snd_pcm_mmap_status_fault,
3051};
3052
3053static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file,
3054                               struct vm_area_struct *area)
3055{
3056        long size;
3057        if (!(area->vm_flags & VM_READ))
3058                return -EINVAL;
3059        size = area->vm_end - area->vm_start;
3060        if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)))
3061                return -EINVAL;
3062        area->vm_ops = &snd_pcm_vm_ops_status;
3063        area->vm_private_data = substream;
3064        area->vm_flags |= VM_RESERVED;
3065        return 0;
3066}
3067
3068/*
3069 * mmap control record
3070 */
3071static int snd_pcm_mmap_control_fault(struct vm_area_struct *area,
3072                                                struct vm_fault *vmf)
3073{
3074        struct snd_pcm_substream *substream = area->vm_private_data;
3075        struct snd_pcm_runtime *runtime;
3076        
3077        if (substream == NULL)
3078                return VM_FAULT_SIGBUS;
3079        runtime = substream->runtime;
3080        vmf->page = virt_to_page(runtime->control);
3081        get_page(vmf->page);
3082        return 0;
3083}
3084
3085static const struct vm_operations_struct snd_pcm_vm_ops_control =
3086{
3087        .fault =        snd_pcm_mmap_control_fault,
3088};
3089
3090static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file,
3091                                struct vm_area_struct *area)
3092{
3093        long size;
3094        if (!(area->vm_flags & VM_READ))
3095                return -EINVAL;
3096        size = area->vm_end - area->vm_start;
3097        if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)))
3098                return -EINVAL;
3099        area->vm_ops = &snd_pcm_vm_ops_control;
3100        area->vm_private_data = substream;
3101        area->vm_flags |= VM_RESERVED;
3102        return 0;
3103}
3104#else /* ! coherent mmap */
3105/*
3106 * don't support mmap for status and control records.
3107 */
3108static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file,
3109                               struct vm_area_struct *area)
3110{
3111        return -ENXIO;
3112}
3113static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file,
3114                                struct vm_area_struct *area)
3115{
3116        return -ENXIO;
3117}
3118#endif /* coherent mmap */
3119
3120static inline struct page *
3121snd_pcm_default_page_ops(struct snd_pcm_substream *substream, unsigned long ofs)
3122{
3123        void *vaddr = substream->runtime->dma_area + ofs;
3124#if defined(CONFIG_MIPS) && defined(CONFIG_DMA_NONCOHERENT)
3125        if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV)
3126                return virt_to_page(CAC_ADDR(vaddr));
3127#endif
3128#if defined(CONFIG_PPC32) && defined(CONFIG_NOT_COHERENT_CACHE)
3129        if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV) {
3130                dma_addr_t addr = substream->runtime->dma_addr + ofs;
3131                addr -= get_dma_offset(substream->dma_buffer.dev.dev);
3132                /* assume dma_handle set via pfn_to_phys() in
3133                 * mm/dma-noncoherent.c
3134                 */
3135                return pfn_to_page(addr >> PAGE_SHIFT);
3136        }
3137#endif
3138        return virt_to_page(vaddr);
3139}
3140
3141/*
3142 * fault callback for mmapping a RAM page
3143 */
3144static int snd_pcm_mmap_data_fault(struct vm_area_struct *area,
3145                                                struct vm_fault *vmf)
3146{
3147        struct snd_pcm_substream *substream = area->vm_private_data;
3148        struct snd_pcm_runtime *runtime;
3149        unsigned long offset;
3150        struct page * page;
3151        size_t dma_bytes;
3152        
3153        if (substream == NULL)
3154                return VM_FAULT_SIGBUS;
3155        runtime = substream->runtime;
3156        offset = vmf->pgoff << PAGE_SHIFT;
3157        dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
3158        if (offset > dma_bytes - PAGE_SIZE)
3159                return VM_FAULT_SIGBUS;
3160        if (substream->ops->page)
3161                page = substream->ops->page(substream, offset);
3162        else
3163                page = snd_pcm_default_page_ops(substream, offset);
3164        if (!page)
3165                return VM_FAULT_SIGBUS;
3166        get_page(page);
3167        vmf->page = page;
3168        return 0;
3169}
3170
3171static const struct vm_operations_struct snd_pcm_vm_ops_data = {
3172        .open =         snd_pcm_mmap_data_open,
3173        .close =        snd_pcm_mmap_data_close,
3174};
3175
3176static const struct vm_operations_struct snd_pcm_vm_ops_data_fault = {
3177        .open =         snd_pcm_mmap_data_open,
3178        .close =        snd_pcm_mmap_data_close,
3179        .fault =        snd_pcm_mmap_data_fault,
3180};
3181
3182#ifndef ARCH_HAS_DMA_MMAP_COHERENT
3183/* This should be defined / handled globally! */
3184#ifdef CONFIG_ARM
3185#define ARCH_HAS_DMA_MMAP_COHERENT
3186#endif
3187#endif
3188
3189/*
3190 * mmap the DMA buffer on RAM
3191 */
3192int snd_pcm_lib_default_mmap(struct snd_pcm_substream *substream,
3193                             struct vm_area_struct *area)
3194{
3195        area->vm_flags |= VM_RESERVED;
3196#ifdef ARCH_HAS_DMA_MMAP_COHERENT
3197        if (!substream->ops->page &&
3198            substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV)
3199                return dma_mmap_coherent(substream->dma_buffer.dev.dev,
3200                                         area,
3201                                         substream->runtime->dma_area,
3202                                         substream->runtime->dma_addr,
3203                                         area->vm_end - area->vm_start);
3204#elif defined(CONFIG_MIPS) && defined(CONFIG_DMA_NONCOHERENT)
3205        if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV &&
3206            !plat_device_is_coherent(substream->dma_buffer.dev.dev))
3207                area->vm_page_prot = pgprot_noncached(area->vm_page_prot);
3208#endif /* ARCH_HAS_DMA_MMAP_COHERENT */
3209        /* mmap with fault handler */
3210        area->vm_ops = &snd_pcm_vm_ops_data_fault;
3211        return 0;
3212}
3213EXPORT_SYMBOL_GPL(snd_pcm_lib_default_mmap);
3214
3215/*
3216 * mmap the DMA buffer on I/O memory area
3217 */
3218#if SNDRV_PCM_INFO_MMAP_IOMEM
3219int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream,
3220                           struct vm_area_struct *area)
3221{
3222        long size;
3223        unsigned long offset;
3224
3225        area->vm_page_prot = pgprot_noncached(area->vm_page_prot);
3226        area->vm_flags |= VM_IO;
3227        size = area->vm_end - area->vm_start;
3228        offset = area->vm_pgoff << PAGE_SHIFT;
3229        if (io_remap_pfn_range(area, area->vm_start,
3230                                (substream->runtime->dma_addr + offset) >> PAGE_SHIFT,
3231                                size, area->vm_page_prot))
3232                return -EAGAIN;
3233        return 0;
3234}
3235
3236EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
3237#endif /* SNDRV_PCM_INFO_MMAP */
3238
3239/*
3240 * mmap DMA buffer
3241 */
3242int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file,
3243                      struct vm_area_struct *area)
3244{
3245        struct snd_pcm_runtime *runtime;
3246        long size;
3247        unsigned long offset;
3248        size_t dma_bytes;
3249        int err;
3250
3251        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
3252                if (!(area->vm_flags & (VM_WRITE|VM_READ)))
3253                        return -EINVAL;
3254        } else {
3255                if (!(area->vm_flags & VM_READ))
3256                        return -EINVAL;
3257        }
3258        runtime = substream->runtime;
3259        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3260                return -EBADFD;
3261        if (!(runtime->info & SNDRV_PCM_INFO_MMAP))
3262                return -ENXIO;
3263        if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||
3264            runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
3265                return -EINVAL;
3266        size = area->vm_end - area->vm_start;
3267        offset = area->vm_pgoff << PAGE_SHIFT;
3268        dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
3269        if ((size_t)size > dma_bytes)
3270                return -EINVAL;
3271        if (offset > dma_bytes - size)
3272                return -EINVAL;
3273
3274        area->vm_ops = &snd_pcm_vm_ops_data;
3275        area->vm_private_data = substream;
3276        if (substream->ops->mmap)
3277                err = substream->ops->mmap(substream, area);
3278        else
3279                err = snd_pcm_lib_default_mmap(substream, area);
3280        if (!err)
3281                atomic_inc(&substream->mmap_count);
3282        return err;
3283}
3284
3285EXPORT_SYMBOL(snd_pcm_mmap_data);
3286
3287static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area)
3288{
3289        struct snd_pcm_file * pcm_file;
3290        struct snd_pcm_substream *substream;    
3291        unsigned long offset;
3292        
3293        pcm_file = file->private_data;
3294        substream = pcm_file->substream;
3295        if (PCM_RUNTIME_CHECK(substream))
3296                return -ENXIO;
3297
3298        offset = area->vm_pgoff << PAGE_SHIFT;
3299        switch (offset) {
3300        case SNDRV_PCM_MMAP_OFFSET_STATUS:
3301                if (pcm_file->no_compat_mmap)
3302                        return -ENXIO;
3303                return snd_pcm_mmap_status(substream, file, area);
3304        case SNDRV_PCM_MMAP_OFFSET_CONTROL:
3305                if (pcm_file->no_compat_mmap)
3306                        return -ENXIO;
3307                return snd_pcm_mmap_control(substream, file, area);
3308        default:
3309                return snd_pcm_mmap_data(substream, file, area);
3310        }
3311        return 0;
3312}
3313
3314static int snd_pcm_fasync(int fd, struct file * file, int on)
3315{
3316        struct snd_pcm_file * pcm_file;
3317        struct snd_pcm_substream *substream;
3318        struct snd_pcm_runtime *runtime;
3319
3320        pcm_file = file->private_data;
3321        substream = pcm_file->substream;
3322        if (PCM_RUNTIME_CHECK(substream))
3323                return -ENXIO;
3324        runtime = substream->runtime;
3325        return fasync_helper(fd, file, on, &runtime->fasync);
3326}
3327
3328/*
3329 * ioctl32 compat
3330 */
3331#ifdef CONFIG_COMPAT
3332#include "pcm_compat.c"
3333#else
3334#define snd_pcm_ioctl_compat    NULL
3335#endif
3336
3337/*
3338 *  To be removed helpers to keep binary compatibility
3339 */
3340
3341#ifdef CONFIG_SND_SUPPORT_OLD_API
3342#define __OLD_TO_NEW_MASK(x) ((x&7)|((x&0x07fffff8)<<5))
3343#define __NEW_TO_OLD_MASK(x) ((x&7)|((x&0xffffff00)>>5))
3344
3345static void snd_pcm_hw_convert_from_old_params(struct snd_pcm_hw_params *params,
3346                                               struct snd_pcm_hw_params_old *oparams)
3347{
3348        unsigned int i;
3349
3350        memset(params, 0, sizeof(*params));
3351        params->flags = oparams->flags;
3352        for (i = 0; i < ARRAY_SIZE(oparams->masks); i++)
3353                params->masks[i].bits[0] = oparams->masks[i];
3354        memcpy(params->intervals, oparams->intervals, sizeof(oparams->intervals));
3355        params->rmask = __OLD_TO_NEW_MASK(oparams->rmask);
3356        params->cmask = __OLD_TO_NEW_MASK(oparams->cmask);
3357        params->info = oparams->info;
3358        params->msbits = oparams->msbits;
3359        params->rate_num = oparams->rate_num;
3360        params->rate_den = oparams->rate_den;
3361        params->fifo_size = oparams->fifo_size;
3362}
3363
3364static void snd_pcm_hw_convert_to_old_params(struct snd_pcm_hw_params_old *oparams,
3365                                             struct snd_pcm_hw_params *params)
3366{
3367        unsigned int i;
3368
3369        memset(oparams, 0, sizeof(*oparams));
3370        oparams->flags = params->flags;
3371        for (i = 0; i < ARRAY_SIZE(oparams->masks); i++)
3372                oparams->masks[i] = params->masks[i].bits[0];
3373        memcpy(oparams->intervals, params->intervals, sizeof(oparams->intervals));
3374        oparams->rmask = __NEW_TO_OLD_MASK(params->rmask);
3375        oparams->cmask = __NEW_TO_OLD_MASK(params->cmask);
3376        oparams->info = params->info;
3377        oparams->msbits = params->msbits;
3378        oparams->rate_num = params->rate_num;
3379        oparams->rate_den = params->rate_den;
3380        oparams->fifo_size = params->fifo_size;
3381}
3382
3383static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream,
3384                                      struct snd_pcm_hw_params_old __user * _oparams)
3385{
3386        struct snd_pcm_hw_params *params;
3387        struct snd_pcm_hw_params_old *oparams = NULL;
3388        int err;
3389
3390        params = kmalloc(sizeof(*params), GFP_KERNEL);
3391        if (!params)
3392                return -ENOMEM;
3393
3394        oparams = memdup_user(_oparams, sizeof(*oparams));
3395        if (IS_ERR(oparams)) {
3396                err = PTR_ERR(oparams);
3397                goto out;
3398        }
3399        snd_pcm_hw_convert_from_old_params(params, oparams);
3400        err = snd_pcm_hw_refine(substream, params);
3401        snd_pcm_hw_convert_to_old_params(oparams, params);
3402        if (copy_to_user(_oparams, oparams, sizeof(*oparams))) {
3403                if (!err)
3404                        err = -EFAULT;
3405        }
3406
3407        kfree(oparams);
3408out:
3409        kfree(params);
3410        return err;
3411}
3412
3413static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream,
3414                                      struct snd_pcm_hw_params_old __user * _oparams)
3415{
3416        struct snd_pcm_hw_params *params;
3417        struct snd_pcm_hw_params_old *oparams = NULL;
3418        int err;
3419
3420        params = kmalloc(sizeof(*params), GFP_KERNEL);
3421        if (!params)
3422                return -ENOMEM;
3423
3424        oparams = memdup_user(_oparams, sizeof(*oparams));
3425        if (IS_ERR(oparams)) {
3426                err = PTR_ERR(oparams);
3427                goto out;
3428        }
3429        snd_pcm_hw_convert_from_old_params(params, oparams);
3430        err = snd_pcm_hw_params(substream, params);
3431        snd_pcm_hw_convert_to_old_params(oparams, params);
3432        if (copy_to_user(_oparams, oparams, sizeof(*oparams))) {
3433                if (!err)
3434                        err = -EFAULT;
3435        }
3436
3437        kfree(oparams);
3438out:
3439        kfree(params);
3440        return err;
3441}
3442#endif /* CONFIG_SND_SUPPORT_OLD_API */
3443
3444#ifndef CONFIG_MMU
3445static unsigned long snd_pcm_get_unmapped_area(struct file *file,
3446                                               unsigned long addr,
3447                                               unsigned long len,
3448                                               unsigned long pgoff,
3449                                               unsigned long flags)
3450{
3451        struct snd_pcm_file *pcm_file = file->private_data;
3452        struct snd_pcm_substream *substream = pcm_file->substream;
3453        struct snd_pcm_runtime *runtime = substream->runtime;
3454        unsigned long offset = pgoff << PAGE_SHIFT;
3455
3456        switch (offset) {
3457        case SNDRV_PCM_MMAP_OFFSET_STATUS:
3458                return (unsigned long)runtime->status;
3459        case SNDRV_PCM_MMAP_OFFSET_CONTROL:
3460                return (unsigned long)runtime->control;
3461        default:
3462                return (unsigned long)runtime->dma_area + offset;
3463        }
3464}
3465#else
3466# define snd_pcm_get_unmapped_area NULL
3467#endif
3468
3469/*
3470 *  Register section
3471 */
3472
3473const struct file_operations snd_pcm_f_ops[2] = {
3474        {
3475                .owner =                THIS_MODULE,
3476                .write =                snd_pcm_write,
3477                .aio_write =            snd_pcm_aio_write,
3478                .open =                 snd_pcm_playback_open,
3479                .release =              snd_pcm_release,
3480                .llseek =               no_llseek,
3481                .poll =                 snd_pcm_playback_poll,
3482                .unlocked_ioctl =       snd_pcm_playback_ioctl,
3483                .compat_ioctl =         snd_pcm_ioctl_compat,
3484                .mmap =                 snd_pcm_mmap,
3485                .fasync =               snd_pcm_fasync,
3486                .get_unmapped_area =    snd_pcm_get_unmapped_area,
3487        },
3488        {
3489                .owner =                THIS_MODULE,
3490                .read =                 snd_pcm_read,
3491                .aio_read =             snd_pcm_aio_read,
3492                .open =                 snd_pcm_capture_open,
3493                .release =              snd_pcm_release,
3494                .llseek =               no_llseek,
3495                .poll =                 snd_pcm_capture_poll,
3496                .unlocked_ioctl =       snd_pcm_capture_ioctl,
3497                .compat_ioctl =         snd_pcm_ioctl_compat,
3498                .mmap =                 snd_pcm_mmap,
3499                .fasync =               snd_pcm_fasync,
3500                .get_unmapped_area =    snd_pcm_get_unmapped_area,
3501        }
3502};
3503
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.