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