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