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                 set_current_state(TASK_INTERRUPTIBLE);
1877                 add_wait_queue(&to_check->sleep, &wait);
1878                 snd_pcm_stream_unlock_irq(substream);
1879                 if (runtime->no_period_wakeup)
1880                         tout = MAX_SCHEDULE_TIMEOUT;
1881                 else {
1882                         tout = 10;
1883                         if (runtime->rate) {
1884                                 long t = runtime->period_size * 2 / runtime->rate;
1885                                 tout = max(t, tout);
1886                         }
1887                         tout = msecs_to_jiffies(tout * 1000);
1888                 }
1889                 tout = schedule_timeout(tout);
1890
1891                 snd_pcm_stream_lock_irq(substream);
1892                 group = snd_pcm_stream_group_ref(substream);
1893                 snd_pcm_group_for_each_entry(s, substream) {
1894                         if (s->runtime == to_check) {
1895                                 remove_wait_queue(&to_check->sleep, &wait);
1896                                 break;
1897                         }
1898                 }
1899                 snd_pcm_group_unref(group, substream);
1900
1901                 if (card->shutdown) {
1902                         result = -ENODEV;
1903                         break;
1904                 }
1905                 if (tout == 0) {
1906                         if (substream->runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
1907                                 result = -ESTRPIPE;
1908                         else {
1909                                 dev_dbg(substream->pcm->card->dev,
1910                                         "playback drain error (DMA or IRQ trouble?)\n");
1911                                 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1912                                 result = -EIO;
1913                         }
1914                         break;
1915                 }
1916         }
1917
1918  unlock:
1919         snd_pcm_stream_unlock_irq(substream);
1920
1921         return result;
1922 }
1923
1924 /*
1925  * drop ioctl
1926  *
1927  * Immediately put all linked substreams into SETUP state.
1928  */
1929 static int snd_pcm_drop(struct snd_pcm_substream *substream)
1930 {
1931         struct snd_pcm_runtime *runtime;
1932         int result = 0;
1933
1934         if (PCM_RUNTIME_CHECK(substream))
1935                 return -ENXIO;
1936         runtime = substream->runtime;
1937
1938         if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1939             runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
1940                 return -EBADFD;
1941
1942         snd_pcm_stream_lock_irq(substream);
1943         /* resume pause */
1944         if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
1945                 snd_pcm_pause(substream, 0);
1946
1947         snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
1948         /* runtime->control->appl_ptr = runtime->status->hw_ptr; */
1949         snd_pcm_stream_unlock_irq(substream);
1950
1951         return result;
1952 }
1953
1954
1955 static bool is_pcm_file(struct file *file)
1956 {
1957         struct inode *inode = file_inode(file);
1958         struct snd_pcm *pcm;
1959         unsigned int minor;
1960
1961         if (!S_ISCHR(inode->i_mode) || imajor(inode) != snd_major)
1962                 return false;
1963         minor = iminor(inode);
1964         pcm = snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
1965         if (!pcm)
1966                 pcm = snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_CAPTURE);
1967         if (!pcm)
1968                 return false;
1969         snd_card_unref(pcm->card);
1970         return true;
1971 }
1972
1973 /*
1974  * PCM link handling
1975  */
1976 static int snd_pcm_link(struct snd_pcm_substream *substream, int fd)
1977 {
1978         int res = 0;
1979         struct snd_pcm_file *pcm_file;
1980         struct snd_pcm_substream *substream1;
1981         struct snd_pcm_group *group, *target_group;
1982         bool nonatomic = substream->pcm->nonatomic;
1983         struct fd f = fdget(fd);
1984
1985         if (!f.file)
1986                 return -EBADFD;
1987         if (!is_pcm_file(f.file)) {
1988                 res = -EBADFD;
1989                 goto _badf;
1990         }
1991         pcm_file = f.file->private_data;
1992         substream1 = pcm_file->substream;
1993         group = kzalloc(sizeof(*group), GFP_KERNEL);
1994         if (!group) {
1995                 res = -ENOMEM;
1996                 goto _nolock;
1997         }
1998         snd_pcm_group_init(group);
1999
2000         down_write(&snd_pcm_link_rwsem);
2001         if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN ||
2002             substream->runtime->status->state != substream1->runtime->status->state ||
2003             substream->pcm->nonatomic != substream1->pcm->nonatomic) {
2004                 res = -EBADFD;
2005                 goto _end;
2006         }
2007         if (snd_pcm_stream_linked(substream1)) {
2008                 res = -EALREADY;
2009                 goto _end;
2010         }
2011
2012         snd_pcm_stream_lock_irq(substream);
2013         if (!snd_pcm_stream_linked(substream)) {
2014                 snd_pcm_group_assign(substream, group);
2015                 group = NULL; /* assigned, don't free this one below */
2016         }
2017         target_group = substream->group;
2018         snd_pcm_stream_unlock_irq(substream);
2019
2020         snd_pcm_group_lock_irq(target_group, nonatomic);
2021         snd_pcm_stream_lock(substream1);
2022         snd_pcm_group_assign(substream1, target_group);
2023         refcount_inc(&target_group->refs);
2024         snd_pcm_stream_unlock(substream1);
2025         snd_pcm_group_unlock_irq(target_group, nonatomic);
2026  _end:
2027         up_write(&snd_pcm_link_rwsem);
2028  _nolock:
2029         kfree(group);
2030  _badf:
2031         fdput(f);
2032         return res;
2033 }
2034
2035 static void relink_to_local(struct snd_pcm_substream *substream)
2036 {
2037         snd_pcm_stream_lock(substream);
2038         snd_pcm_group_assign(substream, &substream->self_group);
2039         snd_pcm_stream_unlock(substream);
2040 }
2041
2042 static int snd_pcm_unlink(struct snd_pcm_substream *substream)
2043 {
2044         struct snd_pcm_group *group;
2045         bool nonatomic = substream->pcm->nonatomic;
2046         bool do_free = false;
2047         int res = 0;
2048
2049         down_write(&snd_pcm_link_rwsem);
2050
2051         if (!snd_pcm_stream_linked(substream)) {
2052                 res = -EALREADY;
2053                 goto _end;
2054         }
2055
2056         group = substream->group;
2057         snd_pcm_group_lock_irq(group, nonatomic);
2058
2059         relink_to_local(substream);
2060         refcount_dec(&group->refs);
2061
2062         /* detach the last stream, too */
2063         if (list_is_singular(&group->substreams)) {
2064                 relink_to_local(list_first_entry(&group->substreams,
2065                                                  struct snd_pcm_substream,
2066                                                  link_list));
2067                 do_free = refcount_dec_and_test(&group->refs);
2068         }
2069
2070         snd_pcm_group_unlock_irq(group, nonatomic);
2071         if (do_free)
2072                 kfree(group);
2073
2074        _end:
2075         up_write(&snd_pcm_link_rwsem);
2076         return res;
2077 }
2078
2079 /*
2080  * hw configurator
2081  */
2082 static int snd_pcm_hw_rule_mul(struct snd_pcm_hw_params *params,
2083                                struct snd_pcm_hw_rule *rule)
2084 {
2085         struct snd_interval t;
2086         snd_interval_mul(hw_param_interval_c(params, rule->deps[0]),
2087                      hw_param_interval_c(params, rule->deps[1]), &t);
2088         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2089 }
2090
2091 static int snd_pcm_hw_rule_div(struct snd_pcm_hw_params *params,
2092                                struct snd_pcm_hw_rule *rule)
2093 {
2094         struct snd_interval t;
2095         snd_interval_div(hw_param_interval_c(params, rule->deps[0]),
2096                      hw_param_interval_c(params, rule->deps[1]), &t);
2097         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2098 }
2099
2100 static int snd_pcm_hw_rule_muldivk(struct snd_pcm_hw_params *params,
2101                                    struct snd_pcm_hw_rule *rule)
2102 {
2103         struct snd_interval t;
2104         snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]),
2105                          hw_param_interval_c(params, rule->deps[1]),
2106                          (unsigned long) rule->private, &t);
2107         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2108 }
2109
2110 static int snd_pcm_hw_rule_mulkdiv(struct snd_pcm_hw_params *params,
2111                                    struct snd_pcm_hw_rule *rule)
2112 {
2113         struct snd_interval t;
2114         snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]),
2115                          (unsigned long) rule->private,
2116                          hw_param_interval_c(params, rule->deps[1]), &t);
2117         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2118 }
2119
2120 static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params,
2121                                   struct snd_pcm_hw_rule *rule)
2122 {
2123         unsigned int k;
2124         const struct snd_interval *i =
2125                                 hw_param_interval_c(params, rule->deps[0]);
2126         struct snd_mask m;
2127         struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
2128         snd_mask_any(&m);
2129         for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
2130                 int bits;
2131                 if (! snd_mask_test(mask, k))
2132                         continue;
2133                 bits = snd_pcm_format_physical_width(k);
2134                 if (bits <= 0)
2135                         continue; /* ignore invalid formats */
2136                 if ((unsigned)bits < i->min || (unsigned)bits > i->max)
2137                         snd_mask_reset(&m, k);
2138         }
2139         return snd_mask_refine(mask, &m);
2140 }
2141
2142 static int snd_pcm_hw_rule_sample_bits(struct snd_pcm_hw_params *params,
2143                                        struct snd_pcm_hw_rule *rule)
2144 {
2145         struct snd_interval t;
2146         unsigned int k;
2147         t.min = UINT_MAX;
2148         t.max = 0;
2149         t.openmin = 0;
2150         t.openmax = 0;
2151         for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) {
2152                 int bits;
2153                 if (! snd_mask_test(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), k))
2154                         continue;
2155                 bits = snd_pcm_format_physical_width(k);
2156                 if (bits <= 0)
2157                         continue; /* ignore invalid formats */
2158                 if (t.min > (unsigned)bits)
2159                         t.min = bits;
2160                 if (t.max < (unsigned)bits)
2161                         t.max = bits;
2162         }
2163         t.integer = 1;
2164         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2165 }
2166
2167 #if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12
2168 #error "Change this table"
2169 #endif
2170
2171 static const unsigned int rates[] = {
2172         5512, 8000, 11025, 16000, 22050, 32000, 44100,
2173         48000, 64000, 88200, 96000, 176400, 192000
2174 };
2175
2176 const struct snd_pcm_hw_constraint_list snd_pcm_known_rates = {
2177         .count = ARRAY_SIZE(rates),
2178         .list = rates,
2179 };
2180
2181 static int snd_pcm_hw_rule_rate(struct snd_pcm_hw_params *params,
2182                                 struct snd_pcm_hw_rule *rule)
2183 {
2184         struct snd_pcm_hardware *hw = rule->private;
2185         return snd_interval_list(hw_param_interval(params, rule->var),
2186                                  snd_pcm_known_rates.count,
2187                                  snd_pcm_known_rates.list, hw->rates);
2188 }
2189
2190 static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *params,
2191                                             struct snd_pcm_hw_rule *rule)
2192 {
2193         struct snd_interval t;
2194         struct snd_pcm_substream *substream = rule->private;
2195         t.min = 0;
2196         t.max = substream->buffer_bytes_max;
2197         t.openmin = 0;
2198         t.openmax = 0;
2199         t.integer = 1;
2200         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
2201 }
2202
2203 int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream)
2204 {
2205         struct snd_pcm_runtime *runtime = substream->runtime;
2206         struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
2207         int k, err;
2208
2209         for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) {
2210                 snd_mask_any(constrs_mask(constrs, k));
2211         }
2212
2213         for (k = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; k <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; k++) {
2214                 snd_interval_any(constrs_interval(constrs, k));
2215         }
2216
2217         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_CHANNELS));
2218         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_SIZE));
2219         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_BUFFER_BYTES));
2220         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_SAMPLE_BITS));
2221         snd_interval_setinteger(constrs_interval(constrs, SNDRV_PCM_HW_PARAM_FRAME_BITS));
2222
2223         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
2224                                    snd_pcm_hw_rule_format, NULL,
2225                                    SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
2226         if (err < 0)
2227                 return err;
2228         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
2229                                   snd_pcm_hw_rule_sample_bits, NULL,
2230                                   SNDRV_PCM_HW_PARAM_FORMAT,
2231                                   SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
2232         if (err < 0)
2233                 return err;
2234         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
2235                                   snd_pcm_hw_rule_div, NULL,
2236                                   SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2237         if (err < 0)
2238                 return err;
2239         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,
2240                                   snd_pcm_hw_rule_mul, NULL,
2241                                   SNDRV_PCM_HW_PARAM_SAMPLE_BITS, SNDRV_PCM_HW_PARAM_CHANNELS, -1);
2242         if (err < 0)
2243                 return err;
2244         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,
2245                                   snd_pcm_hw_rule_mulkdiv, (void*) 8,
2246                                   SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
2247         if (err < 0)
2248                 return err;
2249         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,
2250                                   snd_pcm_hw_rule_mulkdiv, (void*) 8,
2251                                   SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, -1);
2252         if (err < 0)
2253                 return err;
2254         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
2255                                   snd_pcm_hw_rule_div, NULL,
2256                                   SNDRV_PCM_HW_PARAM_FRAME_BITS, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
2257         if (err < 0)
2258                 return err;
2259         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
2260                                   snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
2261                                   SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_TIME, -1);
2262         if (err < 0)
2263                 return err;
2264         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
2265                                   snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
2266                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_BUFFER_TIME, -1);
2267         if (err < 0)
2268                 return err;
2269         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS,
2270                                   snd_pcm_hw_rule_div, NULL,
2271                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
2272         if (err < 0)
2273                 return err;
2274         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
2275                                   snd_pcm_hw_rule_div, NULL,
2276                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
2277         if (err < 0)
2278                 return err;
2279         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
2280                                   snd_pcm_hw_rule_mulkdiv, (void*) 8,
2281                                   SNDRV_PCM_HW_PARAM_PERIOD_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
2282         if (err < 0)
2283                 return err;
2284         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
2285                                   snd_pcm_hw_rule_muldivk, (void*) 1000000,
2286                                   SNDRV_PCM_HW_PARAM_PERIOD_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
2287         if (err < 0)
2288                 return err;
2289         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
2290                                   snd_pcm_hw_rule_mul, NULL,
2291                                   SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_PERIODS, -1);
2292         if (err < 0)
2293                 return err;
2294         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
2295                                   snd_pcm_hw_rule_mulkdiv, (void*) 8,
2296                                   SNDRV_PCM_HW_PARAM_BUFFER_BYTES, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
2297         if (err < 0)
2298                 return err;
2299         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
2300                                   snd_pcm_hw_rule_muldivk, (void*) 1000000,
2301                                   SNDRV_PCM_HW_PARAM_BUFFER_TIME, SNDRV_PCM_HW_PARAM_RATE, -1);
2302         if (err < 0)
2303                 return err;
2304         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
2305                                   snd_pcm_hw_rule_muldivk, (void*) 8,
2306                                   SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
2307         if (err < 0)
2308                 return err;
2309         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
2310                                   snd_pcm_hw_rule_muldivk, (void*) 8,
2311                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_FRAME_BITS, -1);
2312         if (err < 0)
2313                 return err;
2314         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
2315                                   snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
2316                                   SNDRV_PCM_HW_PARAM_PERIOD_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
2317         if (err < 0)
2318                 return err;
2319         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_TIME,
2320                                   snd_pcm_hw_rule_mulkdiv, (void*) 1000000,
2321                                   SNDRV_PCM_HW_PARAM_BUFFER_SIZE, SNDRV_PCM_HW_PARAM_RATE, -1);
2322         if (err < 0)
2323                 return err;
2324         return 0;
2325 }
2326
2327 int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
2328 {
2329         struct snd_pcm_runtime *runtime = substream->runtime;
2330         struct snd_pcm_hardware *hw = &runtime->hw;
2331         int err;
2332         unsigned int mask = 0;
2333
2334         if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
2335                 mask |= 1 << SNDRV_PCM_ACCESS_RW_INTERLEAVED;
2336         if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
2337                 mask |= 1 << SNDRV_PCM_ACCESS_RW_NONINTERLEAVED;
2338         if (hw_support_mmap(substream)) {
2339                 if (hw->info & SNDRV_PCM_INFO_INTERLEAVED)
2340                         mask |= 1 << SNDRV_PCM_ACCESS_MMAP_INTERLEAVED;
2341                 if (hw->info & SNDRV_PCM_INFO_NONINTERLEAVED)
2342                         mask |= 1 << SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED;
2343                 if (hw->info & SNDRV_PCM_INFO_COMPLEX)
2344                         mask |= 1 << SNDRV_PCM_ACCESS_MMAP_COMPLEX;
2345         }
2346         err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_ACCESS, mask);
2347         if (err < 0)
2348                 return err;
2349
2350         err = snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT, hw->formats);
2351         if (err < 0)
2352                 return err;
2353
2354         err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_SUBFORMAT, 1 << SNDRV_PCM_SUBFORMAT_STD);
2355         if (err < 0)
2356                 return err;
2357
2358         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS,
2359                                            hw->channels_min, hw->channels_max);
2360         if (err < 0)
2361                 return err;
2362
2363         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE,
2364                                            hw->rate_min, hw->rate_max);
2365         if (err < 0)
2366                 return err;
2367
2368         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
2369                                            hw->period_bytes_min, hw->period_bytes_max);
2370         if (err < 0)
2371                 return err;
2372
2373         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS,
2374                                            hw->periods_min, hw->periods_max);
2375         if (err < 0)
2376                 return err;
2377
2378         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
2379                                            hw->period_bytes_min, hw->buffer_bytes_max);
2380         if (err < 0)
2381                 return err;
2382
2383         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
2384                                   snd_pcm_hw_rule_buffer_bytes_max, substream,
2385                                   SNDRV_PCM_HW_PARAM_BUFFER_BYTES, -1);
2386         if (err < 0)
2387                 return err;
2388
2389         /* FIXME: remove */
2390         if (runtime->dma_bytes) {
2391                 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, runtime->dma_bytes);
2392                 if (err < 0)
2393                         return err;
2394         }
2395
2396         if (!(hw->rates & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))) {
2397                 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
2398                                           snd_pcm_hw_rule_rate, hw,
2399                                           SNDRV_PCM_HW_PARAM_RATE, -1);
2400                 if (err < 0)
2401                         return err;
2402         }
2403
2404         /* FIXME: this belong to lowlevel */
2405         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
2406
2407         return 0;
2408 }
2409
2410 static void pcm_release_private(struct snd_pcm_substream *substream)
2411 {
2412         if (snd_pcm_stream_linked(substream))
2413                 snd_pcm_unlink(substream);
2414 }
2415
2416 void snd_pcm_release_substream(struct snd_pcm_substream *substream)
2417 {
2418         substream->ref_count--;
2419         if (substream->ref_count > 0)
2420                 return;
2421
2422         snd_pcm_drop(substream);
2423         if (substream->hw_opened) {
2424                 if (substream->ops->hw_free &&
2425                     substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
2426                         substream->ops->hw_free(substream);
2427                 substream->ops->close(substream);
2428                 substream->hw_opened = 0;
2429         }
2430         if (pm_qos_request_active(&substream->latency_pm_qos_req))
2431                 pm_qos_remove_request(&substream->latency_pm_qos_req);
2432         if (substream->pcm_release) {
2433                 substream->pcm_release(substream);
2434                 substream->pcm_release = NULL;
2435         }
2436         snd_pcm_detach_substream(substream);
2437 }
2438 EXPORT_SYMBOL(snd_pcm_release_substream);
2439
2440 int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
2441                            struct file *file,
2442                            struct snd_pcm_substream **rsubstream)
2443 {
2444         struct snd_pcm_substream *substream;
2445         int err;
2446
2447         err = snd_pcm_attach_substream(pcm, stream, file, &substream);
2448         if (err < 0)
2449                 return err;
2450         if (substream->ref_count > 1) {
2451                 *rsubstream = substream;
2452                 return 0;
2453         }
2454
2455         err = snd_pcm_hw_constraints_init(substream);
2456         if (err < 0) {
2457                 pcm_dbg(pcm, "snd_pcm_hw_constraints_init failed\n");
2458                 goto error;
2459         }
2460
2461         if ((err = substream->ops->open(substream)) < 0)
2462                 goto error;
2463
2464         substream->hw_opened = 1;
2465
2466         err = snd_pcm_hw_constraints_complete(substream);
2467         if (err < 0) {
2468                 pcm_dbg(pcm, "snd_pcm_hw_constraints_complete failed\n");
2469                 goto error;
2470         }
2471
2472         *rsubstream = substream;
2473         return 0;
2474
2475  error:
2476         snd_pcm_release_substream(substream);
2477         return err;
2478 }
2479 EXPORT_SYMBOL(snd_pcm_open_substream);
2480
2481 static int snd_pcm_open_file(struct file *file,
2482                              struct snd_pcm *pcm,
2483                              int stream)
2484 {
2485         struct snd_pcm_file *pcm_file;
2486         struct snd_pcm_substream *substream;
2487         int err;
2488
2489         err = snd_pcm_open_substream(pcm, stream, file, &substream);
2490         if (err < 0)
2491                 return err;
2492
2493         pcm_file = kzalloc(sizeof(*pcm_file), GFP_KERNEL);
2494         if (pcm_file == NULL) {
2495                 snd_pcm_release_substream(substream);
2496                 return -ENOMEM;
2497         }
2498         pcm_file->substream = substream;
2499         if (substream->ref_count == 1)
2500                 substream->pcm_release = pcm_release_private;
2501         file->private_data = pcm_file;
2502
2503         return 0;
2504 }
2505
2506 static int snd_pcm_playback_open(struct inode *inode, struct file *file)
2507 {
2508         struct snd_pcm *pcm;
2509         int err = nonseekable_open(inode, file);
2510         if (err < 0)
2511                 return err;
2512         pcm = snd_lookup_minor_data(iminor(inode),
2513                                     SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
2514         err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_PLAYBACK);
2515         if (pcm)
2516                 snd_card_unref(pcm->card);
2517         return err;
2518 }
2519
2520 static int snd_pcm_capture_open(struct inode *inode, struct file *file)
2521 {
2522         struct snd_pcm *pcm;
2523         int err = nonseekable_open(inode, file);
2524         if (err < 0)
2525                 return err;
2526         pcm = snd_lookup_minor_data(iminor(inode),
2527                                     SNDRV_DEVICE_TYPE_PCM_CAPTURE);
2528         err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_CAPTURE);
2529         if (pcm)
2530                 snd_card_unref(pcm->card);
2531         return err;
2532 }
2533
2534 static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream)
2535 {
2536         int err;
2537         wait_queue_entry_t wait;
2538
2539         if (pcm == NULL) {
2540                 err = -ENODEV;
2541                 goto __error1;
2542         }
2543         err = snd_card_file_add(pcm->card, file);
2544         if (err < 0)
2545                 goto __error1;
2546         if (!try_module_get(pcm->card->module)) {
2547                 err = -EFAULT;
2548                 goto __error2;
2549         }
2550         init_waitqueue_entry(&wait, current);
2551         add_wait_queue(&pcm->open_wait, &wait);
2552         mutex_lock(&pcm->open_mutex);
2553         while (1) {
2554                 err = snd_pcm_open_file(file, pcm, stream);
2555                 if (err >= 0)
2556                         break;
2557                 if (err == -EAGAIN) {
2558                         if (file->f_flags & O_NONBLOCK) {
2559                                 err = -EBUSY;
2560                                 break;
2561                         }
2562                 } else
2563                         break;
2564                 set_current_state(TASK_INTERRUPTIBLE);
2565                 mutex_unlock(&pcm->open_mutex);
2566                 schedule();
2567                 mutex_lock(&pcm->open_mutex);
2568                 if (pcm->card->shutdown) {
2569                         err = -ENODEV;
2570                         break;
2571                 }
2572                 if (signal_pending(current)) {
2573                         err = -ERESTARTSYS;
2574                         break;
2575                 }
2576         }
2577         remove_wait_queue(&pcm->open_wait, &wait);
2578         mutex_unlock(&pcm->open_mutex);
2579         if (err < 0)
2580                 goto __error;
2581         return err;
2582
2583       __error:
2584         module_put(pcm->card->module);
2585       __error2:
2586         snd_card_file_remove(pcm->card, file);
2587       __error1:
2588         return err;
2589 }
2590
2591 static int snd_pcm_release(struct inode *inode, struct file *file)
2592 {
2593         struct snd_pcm *pcm;
2594         struct snd_pcm_substream *substream;
2595         struct snd_pcm_file *pcm_file;
2596
2597         pcm_file = file->private_data;
2598         substream = pcm_file->substream;
2599         if (snd_BUG_ON(!substream))
2600                 return -ENXIO;
2601         pcm = substream->pcm;
2602         mutex_lock(&pcm->open_mutex);
2603         snd_pcm_release_substream(substream);
2604         kfree(pcm_file);
2605         mutex_unlock(&pcm->open_mutex);
2606         wake_up(&pcm->open_wait);
2607         module_put(pcm->card->module);
2608         snd_card_file_remove(pcm->card, file);
2609         return 0;
2610 }
2611
2612 /* check and update PCM state; return 0 or a negative error
2613  * call this inside PCM lock
2614  */
2615 static int do_pcm_hwsync(struct snd_pcm_substream *substream)
2616 {
2617         switch (substream->runtime->status->state) {
2618         case SNDRV_PCM_STATE_DRAINING:
2619                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
2620                         return -EBADFD;
2621                 /* Fall through */
2622         case SNDRV_PCM_STATE_RUNNING:
2623                 return snd_pcm_update_hw_ptr(substream);
2624         case SNDRV_PCM_STATE_PREPARED:
2625         case SNDRV_PCM_STATE_PAUSED:
2626                 return 0;
2627         case SNDRV_PCM_STATE_SUSPENDED:
2628                 return -ESTRPIPE;
2629         case SNDRV_PCM_STATE_XRUN:
2630                 return -EPIPE;
2631         default:
2632                 return -EBADFD;
2633         }
2634 }
2635
2636 /* increase the appl_ptr; returns the processed frames or a negative error */
2637 static snd_pcm_sframes_t forward_appl_ptr(struct snd_pcm_substream *substream,
2638                                           snd_pcm_uframes_t frames,
2639                                            snd_pcm_sframes_t avail)
2640 {
2641         struct snd_pcm_runtime *runtime = substream->runtime;
2642         snd_pcm_sframes_t appl_ptr;
2643         int ret;
2644
2645         if (avail <= 0)
2646                 return 0;
2647         if (frames > (snd_pcm_uframes_t)avail)
2648                 frames = avail;
2649         appl_ptr = runtime->control->appl_ptr + frames;
2650         if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
2651                 appl_ptr -= runtime->boundary;
2652         ret = pcm_lib_apply_appl_ptr(substream, appl_ptr);
2653         return ret < 0 ? ret : frames;
2654 }
2655
2656 /* decrease the appl_ptr; returns the processed frames or zero for error */
2657 static snd_pcm_sframes_t rewind_appl_ptr(struct snd_pcm_substream *substream,
2658                                          snd_pcm_uframes_t frames,
2659                                          snd_pcm_sframes_t avail)
2660 {
2661         struct snd_pcm_runtime *runtime = substream->runtime;
2662         snd_pcm_sframes_t appl_ptr;
2663         int ret;
2664
2665         if (avail <= 0)
2666                 return 0;
2667         if (frames > (snd_pcm_uframes_t)avail)
2668                 frames = avail;
2669         appl_ptr = runtime->control->appl_ptr - frames;
2670         if (appl_ptr < 0)
2671                 appl_ptr += runtime->boundary;
2672         ret = pcm_lib_apply_appl_ptr(substream, appl_ptr);
2673         /* NOTE: we return zero for errors because PulseAudio gets depressed
2674          * upon receiving an error from rewind ioctl and stops processing
2675          * any longer.  Returning zero means that no rewind is done, so
2676          * it's not absolutely wrong to answer like that.
2677          */
2678         return ret < 0 ? 0 : frames;
2679 }
2680
2681 static snd_pcm_sframes_t snd_pcm_rewind(struct snd_pcm_substream *substream,
2682                                         snd_pcm_uframes_t frames)
2683 {
2684         snd_pcm_sframes_t ret;
2685
2686         if (frames == 0)
2687                 return 0;
2688
2689         snd_pcm_stream_lock_irq(substream);
2690         ret = do_pcm_hwsync(substream);
2691         if (!ret)
2692                 ret = rewind_appl_ptr(substream, frames,
2693                                       snd_pcm_hw_avail(substream));
2694         snd_pcm_stream_unlock_irq(substream);
2695         return ret;
2696 }
2697
2698 static snd_pcm_sframes_t snd_pcm_forward(struct snd_pcm_substream *substream,
2699                                          snd_pcm_uframes_t frames)
2700 {
2701         snd_pcm_sframes_t ret;
2702
2703         if (frames == 0)
2704                 return 0;
2705
2706         snd_pcm_stream_lock_irq(substream);
2707         ret = do_pcm_hwsync(substream);
2708         if (!ret)
2709                 ret = forward_appl_ptr(substream, frames,
2710                                        snd_pcm_avail(substream));
2711         snd_pcm_stream_unlock_irq(substream);
2712         return ret;
2713 }
2714
2715 static int snd_pcm_hwsync(struct snd_pcm_substream *substream)
2716 {
2717         int err;
2718
2719         snd_pcm_stream_lock_irq(substream);
2720         err = do_pcm_hwsync(substream);
2721         snd_pcm_stream_unlock_irq(substream);
2722         return err;
2723 }
2724
2725 static int snd_pcm_delay(struct snd_pcm_substream *substream,
2726                          snd_pcm_sframes_t *delay)
2727 {
2728         int err;
2729         snd_pcm_sframes_t n = 0;
2730
2731         snd_pcm_stream_lock_irq(substream);
2732         err = do_pcm_hwsync(substream);
2733         if (!err)
2734                 n = snd_pcm_calc_delay(substream);
2735         snd_pcm_stream_unlock_irq(substream);
2736         if (!err)
2737                 *delay = n;
2738         return err;
2739 }
2740
2741 static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream,
2742                             struct snd_pcm_sync_ptr __user *_sync_ptr)
2743 {
2744         struct snd_pcm_runtime *runtime = substream->runtime;
2745         struct snd_pcm_sync_ptr sync_ptr;
2746         volatile struct snd_pcm_mmap_status *status;
2747         volatile struct snd_pcm_mmap_control *control;
2748         int err;
2749
2750         memset(&sync_ptr, 0, sizeof(sync_ptr));
2751         if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags)))
2752                 return -EFAULT;
2753         if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct snd_pcm_mmap_control)))
2754                 return -EFAULT;
2755         status = runtime->status;
2756         control = runtime->control;
2757         if (sync_ptr.flags & SNDRV_PCM_SYNC_PTR_HWSYNC) {
2758                 err = snd_pcm_hwsync(substream);
2759                 if (err < 0)
2760                         return err;
2761         }
2762         snd_pcm_stream_lock_irq(substream);
2763         if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL)) {
2764                 err = pcm_lib_apply_appl_ptr(substream,
2765                                              sync_ptr.c.control.appl_ptr);
2766                 if (err < 0) {
2767                         snd_pcm_stream_unlock_irq(substream);
2768                         return err;
2769                 }
2770         } else {
2771                 sync_ptr.c.control.appl_ptr = control->appl_ptr;
2772         }
2773         if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))
2774                 control->avail_min = sync_ptr.c.control.avail_min;
2775         else
2776                 sync_ptr.c.control.avail_min = control->avail_min;
2777         sync_ptr.s.status.state = status->state;
2778         sync_ptr.s.status.hw_ptr = status->hw_ptr;
2779         sync_ptr.s.status.tstamp = status->tstamp;
2780         sync_ptr.s.status.suspended_state = status->suspended_state;
2781         sync_ptr.s.status.audio_tstamp = status->audio_tstamp;
2782         snd_pcm_stream_unlock_irq(substream);
2783         if (copy_to_user(_sync_ptr, &sync_ptr, sizeof(sync_ptr)))
2784                 return -EFAULT;
2785         return 0;
2786 }
2787
2788 static int snd_pcm_tstamp(struct snd_pcm_substream *substream, int __user *_arg)
2789 {
2790         struct snd_pcm_runtime *runtime = substream->runtime;
2791         int arg;
2792
2793         if (get_user(arg, _arg))
2794                 return -EFAULT;
2795         if (arg < 0 || arg > SNDRV_PCM_TSTAMP_TYPE_LAST)
2796                 return -EINVAL;
2797         runtime->tstamp_type = arg;
2798         return 0;
2799 }
2800
2801 static int snd_pcm_xferi_frames_ioctl(struct snd_pcm_substream *substream,
2802                                       struct snd_xferi __user *_xferi)
2803 {
2804         struct snd_xferi xferi;
2805         struct snd_pcm_runtime *runtime = substream->runtime;
2806         snd_pcm_sframes_t result;
2807
2808         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2809                 return -EBADFD;
2810         if (put_user(0, &_xferi->result))
2811                 return -EFAULT;
2812         if (copy_from_user(&xferi, _xferi, sizeof(xferi)))
2813                 return -EFAULT;
2814         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2815                 result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames);
2816         else
2817                 result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames);
2818         __put_user(result, &_xferi->result);
2819         return result < 0 ? result : 0;
2820 }
2821
2822 static int snd_pcm_xfern_frames_ioctl(struct snd_pcm_substream *substream,
2823                                       struct snd_xfern __user *_xfern)
2824 {
2825         struct snd_xfern xfern;
2826         struct snd_pcm_runtime *runtime = substream->runtime;
2827         void *bufs;
2828         snd_pcm_sframes_t result;
2829
2830         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2831                 return -EBADFD;
2832         if (runtime->channels > 128)
2833                 return -EINVAL;
2834         if (put_user(0, &_xfern->result))
2835                 return -EFAULT;
2836         if (copy_from_user(&xfern, _xfern, sizeof(xfern)))
2837                 return -EFAULT;
2838
2839         bufs = memdup_user(xfern.bufs, sizeof(void *) * runtime->channels);
2840         if (IS_ERR(bufs))
2841                 return PTR_ERR(bufs);
2842         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
2843                 result = snd_pcm_lib_writev(substream, bufs, xfern.frames);
2844         else
2845                 result = snd_pcm_lib_readv(substream, bufs, xfern.frames);
2846         kfree(bufs);
2847         __put_user(result, &_xfern->result);
2848         return result < 0 ? result : 0;
2849 }
2850
2851 static int snd_pcm_rewind_ioctl(struct snd_pcm_substream *substream,
2852                                 snd_pcm_uframes_t __user *_frames)
2853 {
2854         snd_pcm_uframes_t frames;
2855         snd_pcm_sframes_t result;
2856
2857         if (get_user(frames, _frames))
2858                 return -EFAULT;
2859         if (put_user(0, _frames))
2860                 return -EFAULT;
2861         result = snd_pcm_rewind(substream, frames);
2862         __put_user(result, _frames);
2863         return result < 0 ? result : 0;
2864 }
2865
2866 static int snd_pcm_forward_ioctl(struct snd_pcm_substream *substream,
2867                                  snd_pcm_uframes_t __user *_frames)
2868 {
2869         snd_pcm_uframes_t frames;
2870         snd_pcm_sframes_t result;
2871
2872         if (get_user(frames, _frames))
2873                 return -EFAULT;
2874         if (put_user(0, _frames))
2875                 return -EFAULT;
2876         result = snd_pcm_forward(substream, frames);
2877         __put_user(result, _frames);
2878         return result < 0 ? result : 0;
2879 }
2880
2881 static int snd_pcm_common_ioctl(struct file *file,
2882                                  struct snd_pcm_substream *substream,
2883                                  unsigned int cmd, void __user *arg)
2884 {
2885         struct snd_pcm_file *pcm_file = file->private_data;
2886         int res;
2887
2888         if (PCM_RUNTIME_CHECK(substream))
2889                 return -ENXIO;
2890
2891         res = snd_power_wait(substream->pcm->card, SNDRV_CTL_POWER_D0);
2892         if (res < 0)
2893                 return res;
2894
2895         switch (cmd) {
2896         case SNDRV_PCM_IOCTL_PVERSION:
2897                 return put_user(SNDRV_PCM_VERSION, (int __user *)arg) ? -EFAULT : 0;
2898         case SNDRV_PCM_IOCTL_INFO:
2899                 return snd_pcm_info_user(substream, arg);
2900         case SNDRV_PCM_IOCTL_TSTAMP:    /* just for compatibility */
2901                 return 0;
2902         case SNDRV_PCM_IOCTL_TTSTAMP:
2903                 return snd_pcm_tstamp(substream, arg);
2904         case SNDRV_PCM_IOCTL_USER_PVERSION:
2905                 if (get_user(pcm_file->user_pversion,
2906                              (unsigned int __user *)arg))
2907                         return -EFAULT;
2908                 return 0;
2909         case SNDRV_PCM_IOCTL_HW_REFINE:
2910                 return snd_pcm_hw_refine_user(substream, arg);
2911         case SNDRV_PCM_IOCTL_HW_PARAMS:
2912                 return snd_pcm_hw_params_user(substream, arg);
2913         case SNDRV_PCM_IOCTL_HW_FREE:
2914                 return snd_pcm_hw_free(substream);
2915         case SNDRV_PCM_IOCTL_SW_PARAMS:
2916                 return snd_pcm_sw_params_user(substream, arg);
2917         case SNDRV_PCM_IOCTL_STATUS:
2918                 return snd_pcm_status_user(substream, arg, false);
2919         case SNDRV_PCM_IOCTL_STATUS_EXT:
2920                 return snd_pcm_status_user(substream, arg, true);
2921         case SNDRV_PCM_IOCTL_CHANNEL_INFO:
2922                 return snd_pcm_channel_info_user(substream, arg);
2923         case SNDRV_PCM_IOCTL_PREPARE:
2924                 return snd_pcm_prepare(substream, file);
2925         case SNDRV_PCM_IOCTL_RESET:
2926                 return snd_pcm_reset(substream);
2927         case SNDRV_PCM_IOCTL_START:
2928                 return snd_pcm_start_lock_irq(substream);
2929         case SNDRV_PCM_IOCTL_LINK:
2930                 return snd_pcm_link(substream, (int)(unsigned long) arg);
2931         case SNDRV_PCM_IOCTL_UNLINK:
2932                 return snd_pcm_unlink(substream);
2933         case SNDRV_PCM_IOCTL_RESUME:
2934                 return snd_pcm_resume(substream);
2935         case SNDRV_PCM_IOCTL_XRUN:
2936                 return snd_pcm_xrun(substream);
2937         case SNDRV_PCM_IOCTL_HWSYNC:
2938                 return snd_pcm_hwsync(substream);
2939         case SNDRV_PCM_IOCTL_DELAY:
2940         {
2941                 snd_pcm_sframes_t delay;
2942                 snd_pcm_sframes_t __user *res = arg;
2943                 int err;
2944
2945                 err = snd_pcm_delay(substream, &delay);
2946                 if (err)
2947                         return err;
2948                 if (put_user(delay, res))
2949                         return -EFAULT;
2950                 return 0;
2951         }
2952         case SNDRV_PCM_IOCTL_SYNC_PTR:
2953                 return snd_pcm_sync_ptr(substream, arg);
2954 #ifdef CONFIG_SND_SUPPORT_OLD_API
2955         case SNDRV_PCM_IOCTL_HW_REFINE_OLD:
2956                 return snd_pcm_hw_refine_old_user(substream, arg);
2957         case SNDRV_PCM_IOCTL_HW_PARAMS_OLD:
2958                 return snd_pcm_hw_params_old_user(substream, arg);
2959 #endif
2960         case SNDRV_PCM_IOCTL_DRAIN:
2961                 return snd_pcm_drain(substream, file);
2962         case SNDRV_PCM_IOCTL_DROP:
2963                 return snd_pcm_drop(substream);
2964         case SNDRV_PCM_IOCTL_PAUSE:
2965                 return snd_pcm_action_lock_irq(&snd_pcm_action_pause,
2966                                                substream,
2967                                                (int)(unsigned long)arg);
2968         case SNDRV_PCM_IOCTL_WRITEI_FRAMES:
2969         case SNDRV_PCM_IOCTL_READI_FRAMES:
2970                 return snd_pcm_xferi_frames_ioctl(substream, arg);
2971         case SNDRV_PCM_IOCTL_WRITEN_FRAMES:
2972         case SNDRV_PCM_IOCTL_READN_FRAMES:
2973                 return snd_pcm_xfern_frames_ioctl(substream, arg);
2974         case SNDRV_PCM_IOCTL_REWIND:
2975                 return snd_pcm_rewind_ioctl(substream, arg);
2976         case SNDRV_PCM_IOCTL_FORWARD:
2977                 return snd_pcm_forward_ioctl(substream, arg);
2978         }
2979         pcm_dbg(substream->pcm, "unknown ioctl = 0x%x\n", cmd);
2980         return -ENOTTY;
2981 }
2982
2983 static long snd_pcm_ioctl(struct file *file, unsigned int cmd,
2984                           unsigned long arg)
2985 {
2986         struct snd_pcm_file *pcm_file;
2987
2988         pcm_file = file->private_data;
2989
2990         if (((cmd >> 8) & 0xff) != 'A')
2991                 return -ENOTTY;
2992
2993         return snd_pcm_common_ioctl(file, pcm_file->substream, cmd,
2994                                      (void __user *)arg);
2995 }
2996
2997 /**
2998  * snd_pcm_kernel_ioctl - Execute PCM ioctl in the kernel-space
2999  * @substream: PCM substream
3000  * @cmd: IOCTL cmd
3001  * @arg: IOCTL argument
3002  *
3003  * The function is provided primarily for OSS layer and USB gadget drivers,
3004  * and it allows only the limited set of ioctls (hw_params, sw_params,
3005  * prepare, start, drain, drop, forward).
3006  */
3007 int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
3008                          unsigned int cmd, void *arg)
3009 {
3010         snd_pcm_uframes_t *frames = arg;
3011         snd_pcm_sframes_t result;
3012
3013         switch (cmd) {
3014         case SNDRV_PCM_IOCTL_FORWARD:
3015         {
3016                 /* provided only for OSS; capture-only and no value returned */
3017                 if (substream->stream != SNDRV_PCM_STREAM_CAPTURE)
3018                         return -EINVAL;
3019                 result = snd_pcm_forward(substream, *frames);
3020                 return result < 0 ? result : 0;
3021         }
3022         case SNDRV_PCM_IOCTL_HW_PARAMS:
3023                 return snd_pcm_hw_params(substream, arg);
3024         case SNDRV_PCM_IOCTL_SW_PARAMS:
3025                 return snd_pcm_sw_params(substream, arg);
3026         case SNDRV_PCM_IOCTL_PREPARE:
3027                 return snd_pcm_prepare(substream, NULL);
3028         case SNDRV_PCM_IOCTL_START:
3029                 return snd_pcm_start_lock_irq(substream);
3030         case SNDRV_PCM_IOCTL_DRAIN:
3031                 return snd_pcm_drain(substream, NULL);
3032         case SNDRV_PCM_IOCTL_DROP:
3033                 return snd_pcm_drop(substream);
3034         case SNDRV_PCM_IOCTL_DELAY:
3035                 return snd_pcm_delay(substream, frames);
3036         default:
3037                 return -EINVAL;
3038         }
3039 }
3040 EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
3041
3042 static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count,
3043                             loff_t * offset)
3044 {
3045         struct snd_pcm_file *pcm_file;
3046         struct snd_pcm_substream *substream;
3047         struct snd_pcm_runtime *runtime;
3048         snd_pcm_sframes_t result;
3049
3050         pcm_file = file->private_data;
3051         substream = pcm_file->substream;
3052         if (PCM_RUNTIME_CHECK(substream))
3053                 return -ENXIO;
3054         runtime = substream->runtime;
3055         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3056                 return -EBADFD;
3057         if (!frame_aligned(runtime, count))
3058                 return -EINVAL;
3059         count = bytes_to_frames(runtime, count);
3060         result = snd_pcm_lib_read(substream, buf, count);
3061         if (result > 0)
3062                 result = frames_to_bytes(runtime, result);
3063         return result;
3064 }
3065
3066 static ssize_t snd_pcm_write(struct file *file, const char __user *buf,
3067                              size_t count, loff_t * offset)
3068 {
3069         struct snd_pcm_file *pcm_file;
3070         struct snd_pcm_substream *substream;
3071         struct snd_pcm_runtime *runtime;
3072         snd_pcm_sframes_t result;
3073
3074         pcm_file = file->private_data;
3075         substream = pcm_file->substream;
3076         if (PCM_RUNTIME_CHECK(substream))
3077                 return -ENXIO;
3078         runtime = substream->runtime;
3079         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3080                 return -EBADFD;
3081         if (!frame_aligned(runtime, count))
3082                 return -EINVAL;
3083         count = bytes_to_frames(runtime, count);
3084         result = snd_pcm_lib_write(substream, buf, count);
3085         if (result > 0)
3086                 result = frames_to_bytes(runtime, result);
3087         return result;
3088 }
3089
3090 static ssize_t snd_pcm_readv(struct kiocb *iocb, struct iov_iter *to)
3091 {
3092         struct snd_pcm_file *pcm_file;
3093         struct snd_pcm_substream *substream;
3094         struct snd_pcm_runtime *runtime;
3095         snd_pcm_sframes_t result;
3096         unsigned long i;
3097         void __user **bufs;
3098         snd_pcm_uframes_t frames;
3099
3100         pcm_file = iocb->ki_filp->private_data;
3101         substream = pcm_file->substream;
3102         if (PCM_RUNTIME_CHECK(substream))
3103                 return -ENXIO;
3104         runtime = substream->runtime;
3105         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3106                 return -EBADFD;
3107         if (!iter_is_iovec(to))
3108                 return -EINVAL;
3109         if (to->nr_segs > 1024 || to->nr_segs != runtime->channels)
3110                 return -EINVAL;
3111         if (!frame_aligned(runtime, to->iov->iov_len))
3112                 return -EINVAL;
3113         frames = bytes_to_samples(runtime, to->iov->iov_len);
3114         bufs = kmalloc_array(to->nr_segs, sizeof(void *), GFP_KERNEL);
3115         if (bufs == NULL)
3116                 return -ENOMEM;
3117         for (i = 0; i < to->nr_segs; ++i)
3118                 bufs[i] = to->iov[i].iov_base;
3119         result = snd_pcm_lib_readv(substream, bufs, frames);
3120         if (result > 0)
3121                 result = frames_to_bytes(runtime, result);
3122         kfree(bufs);
3123         return result;
3124 }
3125
3126 static ssize_t snd_pcm_writev(struct kiocb *iocb, struct iov_iter *from)
3127 {
3128         struct snd_pcm_file *pcm_file;
3129         struct snd_pcm_substream *substream;
3130         struct snd_pcm_runtime *runtime;
3131         snd_pcm_sframes_t result;
3132         unsigned long i;
3133         void __user **bufs;
3134         snd_pcm_uframes_t frames;
3135
3136         pcm_file = iocb->ki_filp->private_data;
3137         substream = pcm_file->substream;
3138         if (PCM_RUNTIME_CHECK(substream))
3139                 return -ENXIO;
3140         runtime = substream->runtime;
3141         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3142                 return -EBADFD;
3143         if (!iter_is_iovec(from))
3144                 return -EINVAL;
3145         if (from->nr_segs > 128 || from->nr_segs != runtime->channels ||
3146             !frame_aligned(runtime, from->iov->iov_len))
3147                 return -EINVAL;
3148         frames = bytes_to_samples(runtime, from->iov->iov_len);
3149         bufs = kmalloc_array(from->nr_segs, sizeof(void *), GFP_KERNEL);
3150         if (bufs == NULL)
3151                 return -ENOMEM;
3152         for (i = 0; i < from->nr_segs; ++i)
3153                 bufs[i] = from->iov[i].iov_base;
3154         result = snd_pcm_lib_writev(substream, bufs, frames);
3155         if (result > 0)
3156                 result = frames_to_bytes(runtime, result);
3157         kfree(bufs);
3158         return result;
3159 }
3160
3161 static __poll_t snd_pcm_poll(struct file *file, poll_table *wait)
3162 {
3163         struct snd_pcm_file *pcm_file;
3164         struct snd_pcm_substream *substream;
3165         struct snd_pcm_runtime *runtime;
3166         __poll_t mask, ok;
3167         snd_pcm_uframes_t avail;
3168
3169         pcm_file = file->private_data;
3170
3171         substream = pcm_file->substream;
3172         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
3173                 ok = EPOLLOUT | EPOLLWRNORM;
3174         else
3175                 ok = EPOLLIN | EPOLLRDNORM;
3176         if (PCM_RUNTIME_CHECK(substream))
3177                 return ok | EPOLLERR;
3178
3179         runtime = substream->runtime;
3180         poll_wait(file, &runtime->sleep, wait);
3181
3182         mask = 0;
3183         snd_pcm_stream_lock_irq(substream);
3184         avail = snd_pcm_avail(substream);
3185         switch (runtime->status->state) {
3186         case SNDRV_PCM_STATE_RUNNING:
3187         case SNDRV_PCM_STATE_PREPARED:
3188         case SNDRV_PCM_STATE_PAUSED:
3189                 if (avail >= runtime->control->avail_min)
3190                         mask = ok;
3191                 break;
3192         case SNDRV_PCM_STATE_DRAINING:
3193                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
3194                         mask = ok;
3195                         if (!avail)
3196                                 mask |= EPOLLERR;
3197                 }
3198                 break;
3199         default:
3200                 mask = ok | EPOLLERR;
3201                 break;
3202         }
3203         snd_pcm_stream_unlock_irq(substream);
3204         return mask;
3205 }
3206
3207 /*
3208  * mmap support
3209  */
3210
3211 /*
3212  * Only on coherent architectures, we can mmap the status and the control records
3213  * for effcient data transfer.  On others, we have to use HWSYNC ioctl...
3214  */
3215 #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA)
3216 /*
3217  * mmap status record
3218  */
3219 static vm_fault_t snd_pcm_mmap_status_fault(struct vm_fault *vmf)
3220 {
3221         struct snd_pcm_substream *substream = vmf->vma->vm_private_data;
3222         struct snd_pcm_runtime *runtime;
3223
3224         if (substream == NULL)
3225                 return VM_FAULT_SIGBUS;
3226         runtime = substream->runtime;
3227         vmf->page = virt_to_page(runtime->status);
3228         get_page(vmf->page);
3229         return 0;
3230 }
3231
3232 static const struct vm_operations_struct snd_pcm_vm_ops_status =
3233 {
3234         .fault =        snd_pcm_mmap_status_fault,
3235 };
3236
3237 static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file,
3238                                struct vm_area_struct *area)
3239 {
3240         long size;
3241         if (!(area->vm_flags & VM_READ))
3242                 return -EINVAL;
3243         size = area->vm_end - area->vm_start;
3244         if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)))
3245                 return -EINVAL;
3246         area->vm_ops = &snd_pcm_vm_ops_status;
3247         area->vm_private_data = substream;
3248         area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
3249         return 0;
3250 }
3251
3252 /*
3253  * mmap control record
3254  */
3255 static vm_fault_t snd_pcm_mmap_control_fault(struct vm_fault *vmf)
3256 {
3257         struct snd_pcm_substream *substream = vmf->vma->vm_private_data;
3258         struct snd_pcm_runtime *runtime;
3259
3260         if (substream == NULL)
3261                 return VM_FAULT_SIGBUS;
3262         runtime = substream->runtime;
3263         vmf->page = virt_to_page(runtime->control);
3264         get_page(vmf->page);
3265         return 0;
3266 }
3267
3268 static const struct vm_operations_struct snd_pcm_vm_ops_control =
3269 {
3270         .fault =        snd_pcm_mmap_control_fault,
3271 };
3272
3273 static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file,
3274                                 struct vm_area_struct *area)
3275 {
3276         long size;
3277         if (!(area->vm_flags & VM_READ))
3278                 return -EINVAL;
3279         size = area->vm_end - area->vm_start;
3280         if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)))
3281                 return -EINVAL;
3282         area->vm_ops = &snd_pcm_vm_ops_control;
3283         area->vm_private_data = substream;
3284         area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
3285         return 0;
3286 }
3287
3288 static bool pcm_status_mmap_allowed(struct snd_pcm_file *pcm_file)
3289 {
3290         if (pcm_file->no_compat_mmap)
3291                 return false;
3292         /* See pcm_control_mmap_allowed() below.
3293          * Since older alsa-lib requires both status and control mmaps to be
3294          * coupled, we have to disable the status mmap for old alsa-lib, too.
3295          */
3296         if (pcm_file->user_pversion < SNDRV_PROTOCOL_VERSION(2, 0, 14) &&
3297             (pcm_file->substream->runtime->hw.info & SNDRV_PCM_INFO_SYNC_APPLPTR))
3298                 return false;
3299         return true;
3300 }
3301
3302 static bool pcm_control_mmap_allowed(struct snd_pcm_file *pcm_file)
3303 {
3304         if (pcm_file->no_compat_mmap)
3305                 return false;
3306         /* Disallow the control mmap when SYNC_APPLPTR flag is set;
3307          * it enforces the user-space to fall back to snd_pcm_sync_ptr(),
3308          * thus it effectively assures the manual update of appl_ptr.
3309          */
3310         if (pcm_file->substream->runtime->hw.info & SNDRV_PCM_INFO_SYNC_APPLPTR)
3311                 return false;
3312         return true;
3313 }
3314
3315 #else /* ! coherent mmap */
3316 /*
3317  * don't support mmap for status and control records.
3318  */
3319 #define pcm_status_mmap_allowed(pcm_file)       false
3320 #define pcm_control_mmap_allowed(pcm_file)      false
3321
3322 static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file,
3323                                struct vm_area_struct *area)
3324 {
3325         return -ENXIO;
3326 }
3327 static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file,
3328                                 struct vm_area_struct *area)
3329 {
3330         return -ENXIO;
3331 }
3332 #endif /* coherent mmap */
3333
3334 static inline struct page *
3335 snd_pcm_default_page_ops(struct snd_pcm_substream *substream, unsigned long ofs)
3336 {
3337         void *vaddr = substream->runtime->dma_area + ofs;
3338         return virt_to_page(vaddr);
3339 }
3340
3341 /*
3342  * fault callback for mmapping a RAM page
3343  */
3344 static vm_fault_t snd_pcm_mmap_data_fault(struct vm_fault *vmf)
3345 {
3346         struct snd_pcm_substream *substream = vmf->vma->vm_private_data;
3347         struct snd_pcm_runtime *runtime;
3348         unsigned long offset;
3349         struct page * page;
3350         size_t dma_bytes;
3351
3352         if (substream == NULL)
3353                 return VM_FAULT_SIGBUS;
3354         runtime = substream->runtime;
3355         offset = vmf->pgoff << PAGE_SHIFT;
3356         dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
3357         if (offset > dma_bytes - PAGE_SIZE)
3358                 return VM_FAULT_SIGBUS;
3359         if (substream->ops->page)
3360                 page = substream->ops->page(substream, offset);
3361         else
3362                 page = snd_pcm_default_page_ops(substream, offset);
3363         if (!page)
3364                 return VM_FAULT_SIGBUS;
3365         get_page(page);
3366         vmf->page = page;
3367         return 0;
3368 }
3369
3370 static const struct vm_operations_struct snd_pcm_vm_ops_data = {
3371         .open =         snd_pcm_mmap_data_open,
3372         .close =        snd_pcm_mmap_data_close,
3373 };
3374
3375 static const struct vm_operations_struct snd_pcm_vm_ops_data_fault = {
3376         .open =         snd_pcm_mmap_data_open,
3377         .close =        snd_pcm_mmap_data_close,
3378         .fault =        snd_pcm_mmap_data_fault,
3379 };
3380
3381 /*
3382  * mmap the DMA buffer on RAM
3383  */
3384
3385 /**
3386  * snd_pcm_lib_default_mmap - Default PCM data mmap function
3387  * @substream: PCM substream
3388  * @area: VMA
3389  *
3390  * This is the default mmap handler for PCM data.  When mmap pcm_ops is NULL,
3391  * this function is invoked implicitly.
3392  */
3393 int snd_pcm_lib_default_mmap(struct snd_pcm_substream *substream,
3394                              struct vm_area_struct *area)
3395 {
3396         area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
3397 #ifdef CONFIG_GENERIC_ALLOCATOR
3398         if (substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV_IRAM) {
3399                 area->vm_page_prot = pgprot_writecombine(area->vm_page_prot);
3400                 return remap_pfn_range(area, area->vm_start,
3401                                 substream->dma_buffer.addr >> PAGE_SHIFT,
3402                                 area->vm_end - area->vm_start, area->vm_page_prot);
3403         }
3404 #endif /* CONFIG_GENERIC_ALLOCATOR */
3405 #ifndef CONFIG_X86 /* for avoiding warnings arch/x86/mm/pat.c */
3406         if (IS_ENABLED(CONFIG_HAS_DMA) && !substream->ops->page &&
3407             substream->dma_buffer.dev.type == SNDRV_DMA_TYPE_DEV)
3408                 return dma_mmap_coherent(substream->dma_buffer.dev.dev,
3409                                          area,
3410                                          substream->runtime->dma_area,
3411                                          substream->runtime->dma_addr,
3412                                          substream->runtime->dma_bytes);
3413 #endif /* CONFIG_X86 */
3414         /* mmap with fault handler */
3415         area->vm_ops = &snd_pcm_vm_ops_data_fault;
3416         return 0;
3417 }
3418 EXPORT_SYMBOL_GPL(snd_pcm_lib_default_mmap);
3419
3420 /*
3421  * mmap the DMA buffer on I/O memory area
3422  */
3423 #if SNDRV_PCM_INFO_MMAP_IOMEM
3424 /**
3425  * snd_pcm_lib_mmap_iomem - Default PCM data mmap function for I/O mem
3426  * @substream: PCM substream
3427  * @area: VMA
3428  *
3429  * When your hardware uses the iomapped pages as the hardware buffer and
3430  * wants to mmap it, pass this function as mmap pcm_ops.  Note that this
3431  * is supposed to work only on limited architectures.
3432  */
3433 int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream,
3434                            struct vm_area_struct *area)
3435 {
3436         struct snd_pcm_runtime *runtime = substream->runtime;
3437
3438         area->vm_page_prot = pgprot_noncached(area->vm_page_prot);
3439         return vm_iomap_memory(area, runtime->dma_addr, runtime->dma_bytes);
3440 }
3441 EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
3442 #endif /* SNDRV_PCM_INFO_MMAP */
3443
3444 /*
3445  * mmap DMA buffer
3446  */
3447 int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file,
3448                       struct vm_area_struct *area)
3449 {
3450         struct snd_pcm_runtime *runtime;
3451         long size;
3452         unsigned long offset;
3453         size_t dma_bytes;
3454         int err;
3455
3456         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
3457                 if (!(area->vm_flags & (VM_WRITE|VM_READ)))
3458                         return -EINVAL;
3459         } else {
3460                 if (!(area->vm_flags & VM_READ))
3461                         return -EINVAL;
3462         }
3463         runtime = substream->runtime;
3464         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3465                 return -EBADFD;
3466         if (!(runtime->info & SNDRV_PCM_INFO_MMAP))
3467                 return -ENXIO;
3468         if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||
3469             runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
3470                 return -EINVAL;
3471         size = area->vm_end - area->vm_start;
3472         offset = area->vm_pgoff << PAGE_SHIFT;
3473         dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
3474         if ((size_t)size > dma_bytes)
3475                 return -EINVAL;
3476         if (offset > dma_bytes - size)
3477                 return -EINVAL;
3478
3479         area->vm_ops = &snd_pcm_vm_ops_data;
3480         area->vm_private_data = substream;
3481         if (substream->ops->mmap)
3482                 err = substream->ops->mmap(substream, area);
3483         else
3484                 err = snd_pcm_lib_default_mmap(substream, area);
3485         if (!err)
3486                 atomic_inc(&substream->mmap_count);
3487         return err;
3488 }
3489 EXPORT_SYMBOL(snd_pcm_mmap_data);
3490
3491 static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area)
3492 {
3493         struct snd_pcm_file * pcm_file;
3494         struct snd_pcm_substream *substream;
3495         unsigned long offset;
3496
3497         pcm_file = file->private_data;
3498         substream = pcm_file->substream;
3499         if (PCM_RUNTIME_CHECK(substream))
3500                 return -ENXIO;
3501
3502         offset = area->vm_pgoff << PAGE_SHIFT;
3503         switch (offset) {
3504         case SNDRV_PCM_MMAP_OFFSET_STATUS:
3505                 if (!pcm_status_mmap_allowed(pcm_file))
3506                         return -ENXIO;
3507                 return snd_pcm_mmap_status(substream, file, area);
3508         case SNDRV_PCM_MMAP_OFFSET_CONTROL:
3509                 if (!pcm_control_mmap_allowed(pcm_file))
3510                         return -ENXIO;
3511                 return snd_pcm_mmap_control(substream, file, area);
3512         default:
3513                 return snd_pcm_mmap_data(substream, file, area);
3514         }
3515         return 0;
3516 }
3517
3518 static int snd_pcm_fasync(int fd, struct file * file, int on)
3519 {
3520         struct snd_pcm_file * pcm_file;
3521         struct snd_pcm_substream *substream;
3522         struct snd_pcm_runtime *runtime;
3523
3524         pcm_file = file->private_data;
3525         substream = pcm_file->substream;
3526         if (PCM_RUNTIME_CHECK(substream))
3527                 return -ENXIO;
3528         runtime = substream->runtime;
3529         return fasync_helper(fd, file, on, &runtime->fasync);
3530 }
3531
3532 /*
3533  * ioctl32 compat
3534  */
3535 #ifdef CONFIG_COMPAT
3536 #include "pcm_compat.c"
3537 #else
3538 #define snd_pcm_ioctl_compat    NULL
3539 #endif
3540
3541 /*
3542  *  To be removed helpers to keep binary compatibility
3543  */
3544
3545 #ifdef CONFIG_SND_SUPPORT_OLD_API
3546 #define __OLD_TO_NEW_MASK(x) ((x&7)|((x&0x07fffff8)<<5))
3547 #define __NEW_TO_OLD_MASK(x) ((x&7)|((x&0xffffff00)>>5))
3548
3549 static void snd_pcm_hw_convert_from_old_params(struct snd_pcm_hw_params *params,
3550                                                struct snd_pcm_hw_params_old *oparams)
3551 {
3552         unsigned int i;
3553
3554         memset(params, 0, sizeof(*params));
3555         params->flags = oparams->flags;
3556         for (i = 0; i < ARRAY_SIZE(oparams->masks); i++)
3557                 params->masks[i].bits[0] = oparams->masks[i];
3558         memcpy(params->intervals, oparams->intervals, sizeof(oparams->intervals));
3559         params->rmask = __OLD_TO_NEW_MASK(oparams->rmask);
3560         params->cmask = __OLD_TO_NEW_MASK(oparams->cmask);
3561         params->info = oparams->info;
3562         params->msbits = oparams->msbits;
3563         params->rate_num = oparams->rate_num;
3564         params->rate_den = oparams->rate_den;
3565         params->fifo_size = oparams->fifo_size;
3566 }
3567
3568 static void snd_pcm_hw_convert_to_old_params(struct snd_pcm_hw_params_old *oparams,
3569                                              struct snd_pcm_hw_params *params)
3570 {
3571         unsigned int i;
3572
3573         memset(oparams, 0, sizeof(*oparams));
3574         oparams->flags = params->flags;
3575         for (i = 0; i < ARRAY_SIZE(oparams->masks); i++)
3576                 oparams->masks[i] = params->masks[i].bits[0];
3577         memcpy(oparams->intervals, params->intervals, sizeof(oparams->intervals));
3578         oparams->rmask = __NEW_TO_OLD_MASK(params->rmask);
3579         oparams->cmask = __NEW_TO_OLD_MASK(params->cmask);
3580         oparams->info = params->info;
3581         oparams->msbits = params->msbits;
3582         oparams->rate_num = params->rate_num;
3583         oparams->rate_den = params->rate_den;
3584         oparams->fifo_size = params->fifo_size;
3585 }
3586
3587 static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream,
3588                                       struct snd_pcm_hw_params_old __user * _oparams)
3589 {
3590         struct snd_pcm_hw_params *params;
3591         struct snd_pcm_hw_params_old *oparams = NULL;
3592         int err;
3593
3594         params = kmalloc(sizeof(*params), GFP_KERNEL);
3595         if (!params)
3596                 return -ENOMEM;
3597
3598         oparams = memdup_user(_oparams, sizeof(*oparams));
3599         if (IS_ERR(oparams)) {
3600                 err = PTR_ERR(oparams);
3601                 goto out;
3602         }
3603         snd_pcm_hw_convert_from_old_params(params, oparams);
3604         err = snd_pcm_hw_refine(substream, params);
3605         if (err < 0)
3606                 goto out_old;
3607
3608         err = fixup_unreferenced_params(substream, params);
3609         if (err < 0)
3610                 goto out_old;
3611
3612         snd_pcm_hw_convert_to_old_params(oparams, params);
3613         if (copy_to_user(_oparams, oparams, sizeof(*oparams)))
3614                 err = -EFAULT;
3615 out_old:
3616         kfree(oparams);
3617 out:
3618         kfree(params);
3619         return err;
3620 }
3621
3622 static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream,
3623                                       struct snd_pcm_hw_params_old __user * _oparams)
3624 {
3625         struct snd_pcm_hw_params *params;
3626         struct snd_pcm_hw_params_old *oparams = NULL;
3627         int err;
3628
3629         params = kmalloc(sizeof(*params), GFP_KERNEL);
3630         if (!params)
3631                 return -ENOMEM;
3632
3633         oparams = memdup_user(_oparams, sizeof(*oparams));
3634         if (IS_ERR(oparams)) {
3635                 err = PTR_ERR(oparams);
3636                 goto out;
3637         }
3638
3639         snd_pcm_hw_convert_from_old_params(params, oparams);
3640         err = snd_pcm_hw_params(substream, params);
3641         if (err < 0)
3642                 goto out_old;
3643
3644         snd_pcm_hw_convert_to_old_params(oparams, params);
3645         if (copy_to_user(_oparams, oparams, sizeof(*oparams)))
3646                 err = -EFAULT;
3647 out_old:
3648         kfree(oparams);
3649 out:
3650         kfree(params);
3651         return err;
3652 }
3653 #endif /* CONFIG_SND_SUPPORT_OLD_API */
3654
3655 #ifndef CONFIG_MMU
3656 static unsigned long snd_pcm_get_unmapped_area(struct file *file,
3657                                                unsigned long addr,
3658                                                unsigned long len,
3659                                                unsigned long pgoff,
3660                                                unsigned long flags)
3661 {
3662         struct snd_pcm_file *pcm_file = file->private_data;
3663         struct snd_pcm_substream *substream = pcm_file->substream;
3664         struct snd_pcm_runtime *runtime = substream->runtime;
3665         unsigned long offset = pgoff << PAGE_SHIFT;
3666
3667         switch (offset) {
3668         case SNDRV_PCM_MMAP_OFFSET_STATUS:
3669                 return (unsigned long)runtime->status;
3670         case SNDRV_PCM_MMAP_OFFSET_CONTROL:
3671                 return (unsigned long)runtime->control;
3672         default:
3673                 return (unsigned long)runtime->dma_area + offset;
3674         }
3675 }
3676 #else
3677 # define snd_pcm_get_unmapped_area NULL
3678 #endif
3679
3680 /*
3681  *  Register section
3682  */
3683
3684 const struct file_operations snd_pcm_f_ops[2] = {
3685         {
3686                 .owner =                THIS_MODULE,
3687                 .write =                snd_pcm_write,
3688                 .write_iter =           snd_pcm_writev,
3689                 .open =                 snd_pcm_playback_open,
3690                 .release =              snd_pcm_release,
3691                 .llseek =               no_llseek,
3692                 .poll =                 snd_pcm_poll,
3693                 .unlocked_ioctl =       snd_pcm_ioctl,
3694                 .compat_ioctl =         snd_pcm_ioctl_compat,
3695                 .mmap =                 snd_pcm_mmap,
3696                 .fasync =               snd_pcm_fasync,
3697                 .get_unmapped_area =    snd_pcm_get_unmapped_area,
3698         },
3699         {
3700                 .owner =                THIS_MODULE,
3701                 .read =                 snd_pcm_read,
3702                 .read_iter =            snd_pcm_readv,
3703                 .open =                 snd_pcm_capture_open,
3704                 .release =              snd_pcm_release,
3705                 .llseek =               no_llseek,
3706                 .poll =                 snd_pcm_poll,
3707                 .unlocked_ioctl =       snd_pcm_ioctl,
3708                 .compat_ioctl =         snd_pcm_ioctl_compat,
3709                 .mmap =                 snd_pcm_mmap,
3710                 .fasync =               snd_pcm_fasync,
3711                 .get_unmapped_area =    snd_pcm_get_unmapped_area,
3712         }
3713 };