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