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