sound/core/pcm_native.c

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