sound/core/pcm_native.c

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