1	// SPDX-License-Identifier: GPL-2.0+
2	//
3	// soc-pcm.c -- ALSA SoC PCM
4	//
5	// Copyright 2005 Wolfson Microelectronics PLC.
6	// Copyright 2005 Openedhand Ltd.
7	// Copyright (C) 2010 Slimlogic Ltd.
8	// Copyright (C) 2010 Texas Instruments Inc.
9	//
10	// Authors: Liam Girdwood <lrg@ti.com>
11	// Mark Brown <broonie@opensource.wolfsonmicro.com>
12
13	#include <linux/kernel.h>
14	#include <linux/init.h>
15	#include <linux/delay.h>
16	#include <linux/pinctrl/consumer.h>
17	#include <linux/slab.h>
18	#include <linux/workqueue.h>
19	#include <linux/export.h>
20	#include <linux/debugfs.h>
21	#include <sound/core.h>
22	#include <sound/pcm.h>
23	#include <sound/pcm_params.h>
24	#include <sound/soc.h>
25	#include <sound/soc-dpcm.h>
26	#include <sound/soc-link.h>
27	#include <sound/initval.h>
28
29	#define soc_pcm_ret(rtd, ret) _soc_pcm_ret(rtd, __func__, ret)
30	static inline int _soc_pcm_ret(struct snd_soc_pcm_runtime *rtd,
31	const char *func, int ret)
32	{
33	/* Positive, Zero values are not errors */
34	if (ret >= 0)
35	return ret;
36
37	/* Negative values might be errors */
38	switch (ret) {
39	case -EPROBE_DEFER:
40	case -ENOTSUPP:
41	case -EINVAL:
42	break;
43	default:
44	dev_err(rtd->dev,
45	"ASoC: error at %s on %s: %d\n",
46	func, rtd->dai_link->name, ret);
47	}
48
49	return ret;
50	}
51
52	static inline void snd_soc_dpcm_stream_lock_irq(struct snd_soc_pcm_runtime *rtd,
53	int stream)
54	{
55	snd_pcm_stream_lock_irq(substream: snd_soc_dpcm_get_substream(be: rtd, stream));
56	}
57
58	#define snd_soc_dpcm_stream_lock_irqsave_nested(rtd, stream, flags) \
59	snd_pcm_stream_lock_irqsave_nested(snd_soc_dpcm_get_substream(rtd, stream), flags)
60
61	static inline void snd_soc_dpcm_stream_unlock_irq(struct snd_soc_pcm_runtime *rtd,
62	int stream)
63	{
64	snd_pcm_stream_unlock_irq(substream: snd_soc_dpcm_get_substream(be: rtd, stream));
65	}
66
67	#define snd_soc_dpcm_stream_unlock_irqrestore(rtd, stream, flags) \
68	snd_pcm_stream_unlock_irqrestore(snd_soc_dpcm_get_substream(rtd, stream), flags)
69
70	#define DPCM_MAX_BE_USERS 8
71
72	static inline const char *soc_cpu_dai_name(struct snd_soc_pcm_runtime *rtd)
73	{
74	return (rtd)->dai_link->num_cpus == 1 ? snd_soc_rtd_to_cpu(rtd, 0)->name : "multicpu";
75	}
76	static inline const char *soc_codec_dai_name(struct snd_soc_pcm_runtime *rtd)
77	{
78	return (rtd)->dai_link->num_codecs == 1 ? snd_soc_rtd_to_codec(rtd, 0)->name : "multicodec";
79	}
80
81	#ifdef CONFIG_DEBUG_FS
82	static const char *dpcm_state_string(enum snd_soc_dpcm_state state)
83	{
84	switch (state) {
85	case SND_SOC_DPCM_STATE_NEW:
86	return "new";
87	case SND_SOC_DPCM_STATE_OPEN:
88	return "open";
89	case SND_SOC_DPCM_STATE_HW_PARAMS:
90	return "hw_params";
91	case SND_SOC_DPCM_STATE_PREPARE:
92	return "prepare";
93	case SND_SOC_DPCM_STATE_START:
94	return "start";
95	case SND_SOC_DPCM_STATE_STOP:
96	return "stop";
97	case SND_SOC_DPCM_STATE_SUSPEND:
98	return "suspend";
99	case SND_SOC_DPCM_STATE_PAUSED:
100	return "paused";
101	case SND_SOC_DPCM_STATE_HW_FREE:
102	return "hw_free";
103	case SND_SOC_DPCM_STATE_CLOSE:
104	return "close";
105	}
106
107	return "unknown";
108	}
109
110	static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe,
111	int stream, char *buf, size_t size)
112	{
113	struct snd_pcm_hw_params *params = &fe->dpcm[stream].hw_params;
114	struct snd_soc_dpcm *dpcm;
115	ssize_t offset = 0;
116
117	/* FE state */
118	offset += scnprintf(buf: buf + offset, size: size - offset,
119	fmt: "[%s - %s]\n", fe->dai_link->name,
120	stream ? "Capture" : "Playback");
121
122	offset += scnprintf(buf: buf + offset, size: size - offset, fmt: "State: %s\n",
123	dpcm_state_string(state: fe->dpcm[stream].state));
124
125	if ((fe->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
126	(fe->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
127	offset += scnprintf(buf: buf + offset, size: size - offset,
128	fmt: "Hardware Params: "
129	"Format = %s, Channels = %d, Rate = %d\n",
130	snd_pcm_format_name(format: params_format(p: params)),
131	params_channels(p: params),
132	params_rate(p: params));
133
134	/* BEs state */
135	offset += scnprintf(buf: buf + offset, size: size - offset, fmt: "Backends:\n");
136
137	if (list_empty(head: &fe->dpcm[stream].be_clients)) {
138	offset += scnprintf(buf: buf + offset, size: size - offset,
139	fmt: " No active DSP links\n");
140	goto out;
141	}
142
143	for_each_dpcm_be(fe, stream, dpcm) {
144	struct snd_soc_pcm_runtime *be = dpcm->be;
145	params = &be->dpcm[stream].hw_params;
146
147	offset += scnprintf(buf: buf + offset, size: size - offset,
148	fmt: "- %s\n", be->dai_link->name);
149
150	offset += scnprintf(buf: buf + offset, size: size - offset,
151	fmt: " State: %s\n",
152	dpcm_state_string(state: be->dpcm[stream].state));
153
154	if ((be->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
155	(be->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
156	offset += scnprintf(buf: buf + offset, size: size - offset,
157	fmt: " Hardware Params: "
158	"Format = %s, Channels = %d, Rate = %d\n",
159	snd_pcm_format_name(format: params_format(p: params)),
160	params_channels(p: params),
161	params_rate(p: params));
162	}
163	out:
164	return offset;
165	}
166
167	static ssize_t dpcm_state_read_file(struct file *file, char __user *user_buf,
168	size_t count, loff_t *ppos)
169	{
170	struct snd_soc_pcm_runtime *fe = file->private_data;
171	ssize_t out_count = PAGE_SIZE, offset = 0, ret = 0;
172	int stream;
173	char *buf;
174
175	if (fe->dai_link->num_cpus > 1) {
176	dev_err(fe->dev,
177	"%s doesn't support Multi CPU yet\n", __func__);
178	return -EINVAL;
179	}
180
181	buf = kmalloc(size: out_count, GFP_KERNEL);
182	if (!buf)
183	return -ENOMEM;
184
185	snd_soc_dpcm_mutex_lock(fe);
186	for_each_pcm_streams(stream)
187	if (snd_soc_dai_stream_valid(snd_soc_rtd_to_cpu(fe, 0), stream))
188	offset += dpcm_show_state(fe, stream,
189	buf: buf + offset,
190	size: out_count - offset);
191	snd_soc_dpcm_mutex_unlock(fe);
192
193	ret = simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: offset);
194
195	kfree(objp: buf);
196	return ret;
197	}
198
199	static const struct file_operations dpcm_state_fops = {
200	.open = simple_open,
201	.read = dpcm_state_read_file,
202	.llseek = default_llseek,
203	};
204
205	void soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd)
206	{
207	if (!rtd->dai_link->dynamic)
208	return;
209
210	if (!rtd->card->debugfs_card_root)
211	return;
212
213	rtd->debugfs_dpcm_root = debugfs_create_dir(name: rtd->dai_link->name,
214	parent: rtd->card->debugfs_card_root);
215
216	debugfs_create_file(name: "state", mode: 0444, parent: rtd->debugfs_dpcm_root,
217	data: rtd, fops: &dpcm_state_fops);
218	}
219
220	static void dpcm_create_debugfs_state(struct snd_soc_dpcm *dpcm, int stream)
221	{
222	char *name;
223
224	name = kasprintf(GFP_KERNEL, fmt: "%s:%s", dpcm->be->dai_link->name,
225	stream ? "capture" : "playback");
226	if (name) {
227	dpcm->debugfs_state = debugfs_create_dir(
228	name, parent: dpcm->fe->debugfs_dpcm_root);
229	debugfs_create_u32(name: "state", mode: 0644, parent: dpcm->debugfs_state,
230	value: &dpcm->state);
231	kfree(objp: name);
232	}
233	}
234
235	static void dpcm_remove_debugfs_state(struct snd_soc_dpcm *dpcm)
236	{
237	debugfs_remove_recursive(dentry: dpcm->debugfs_state);
238	}
239
240	#else
241	static inline void dpcm_create_debugfs_state(struct snd_soc_dpcm *dpcm,
242	int stream)
243	{
244	}
245
246	static inline void dpcm_remove_debugfs_state(struct snd_soc_dpcm *dpcm)
247	{
248	}
249	#endif
250
251	/* Set FE's runtime_update state; the state is protected via PCM stream lock
252	* for avoiding the race with trigger callback.
253	* If the state is unset and a trigger is pending while the previous operation,
254	* process the pending trigger action here.
255	*/
256	static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream *substream, int cmd);
257	static void dpcm_set_fe_update_state(struct snd_soc_pcm_runtime *fe,
258	int stream, enum snd_soc_dpcm_update state)
259	{
260	struct snd_pcm_substream *substream =
261	snd_soc_dpcm_get_substream(be: fe, stream);
262
263	snd_soc_dpcm_stream_lock_irq(rtd: fe, stream);
264	if (state == SND_SOC_DPCM_UPDATE_NO && fe->dpcm[stream].trigger_pending) {
265	dpcm_fe_dai_do_trigger(substream,
266	cmd: fe->dpcm[stream].trigger_pending - 1);
267	fe->dpcm[stream].trigger_pending = 0;
268	}
269	fe->dpcm[stream].runtime_update = state;
270	snd_soc_dpcm_stream_unlock_irq(rtd: fe, stream);
271	}
272
273	static void dpcm_set_be_update_state(struct snd_soc_pcm_runtime *be,
274	int stream, enum snd_soc_dpcm_update state)
275	{
276	be->dpcm[stream].runtime_update = state;
277	}
278
279	/**
280	* snd_soc_runtime_action() - Increment/Decrement active count for
281	* PCM runtime components
282	* @rtd: ASoC PCM runtime that is activated
283	* @stream: Direction of the PCM stream
284	* @action: Activate stream if 1. Deactivate if -1.
285	*
286	* Increments/Decrements the active count for all the DAIs and components
287	* attached to a PCM runtime.
288	* Should typically be called when a stream is opened.
289	*
290	* Must be called with the rtd->card->pcm_mutex being held
291	*/
292	void snd_soc_runtime_action(struct snd_soc_pcm_runtime *rtd,
293	int stream, int action)
294	{
295	struct snd_soc_component *component;
296	struct snd_soc_dai *dai;
297	int i;
298
299	snd_soc_dpcm_mutex_assert_held(rtd);
300
301	for_each_rtd_dais(rtd, i, dai)
302	snd_soc_dai_action(dai, stream, action);
303
304	/* Increments/Decrements the active count for components without DAIs */
305	for_each_rtd_components(rtd, i, component) {
306	if (component->num_dai)
307	continue;
308	component->active += action;
309	}
310	}
311	EXPORT_SYMBOL_GPL(snd_soc_runtime_action);
312
313	/**
314	* snd_soc_runtime_ignore_pmdown_time() - Check whether to ignore the power down delay
315	* @rtd: The ASoC PCM runtime that should be checked.
316	*
317	* This function checks whether the power down delay should be ignored for a
318	* specific PCM runtime. Returns true if the delay is 0, if it the DAI link has
319	* been configured to ignore the delay, or if none of the components benefits
320	* from having the delay.
321	*/
322	bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd)
323	{
324	struct snd_soc_component *component;
325	bool ignore = true;
326	int i;
327
328	if (!rtd->pmdown_time || rtd->dai_link->ignore_pmdown_time)
329	return true;
330
331	for_each_rtd_components(rtd, i, component)
332	ignore &= !component->driver->use_pmdown_time;
333
334	return ignore;
335	}
336
337	/**
338	* snd_soc_set_runtime_hwparams - set the runtime hardware parameters
339	* @substream: the pcm substream
340	* @hw: the hardware parameters
341	*
342	* Sets the substream runtime hardware parameters.
343	*/
344	int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
345	const struct snd_pcm_hardware *hw)
346	{
347	substream->runtime->hw = *hw;
348
349	return 0;
350	}
351	EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
352
353	/* DPCM stream event, send event to FE and all active BEs. */
354	int dpcm_dapm_stream_event(struct snd_soc_pcm_runtime *fe, int dir,
355	int event)
356	{
357	struct snd_soc_dpcm *dpcm;
358
359	snd_soc_dpcm_mutex_assert_held(fe);
360
361	for_each_dpcm_be(fe, dir, dpcm) {
362
363	struct snd_soc_pcm_runtime *be = dpcm->be;
364
365	dev_dbg(be->dev, "ASoC: BE %s event %d dir %d\n",
366	be->dai_link->name, event, dir);
367
368	if ((event == SND_SOC_DAPM_STREAM_STOP) &&
369	(be->dpcm[dir].users >= 1))
370	continue;
371
372	snd_soc_dapm_stream_event(rtd: be, stream: dir, event);
373	}
374
375	snd_soc_dapm_stream_event(rtd: fe, stream: dir, event);
376
377	return 0;
378	}
379
380	static void soc_pcm_set_dai_params(struct snd_soc_dai *dai,
381	struct snd_pcm_hw_params *params)
382	{
383	if (params) {
384	dai->rate = params_rate(p: params);
385	dai->channels = params_channels(p: params);
386	dai->sample_bits = snd_pcm_format_physical_width(format: params_format(p: params));
387	} else {
388	dai->rate = 0;
389	dai->channels = 0;
390	dai->sample_bits = 0;
391	}
392	}
393
394	static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream,
395	struct snd_soc_dai *soc_dai)
396	{
397	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
398	int ret;
399
400	if (!snd_soc_dai_active(dai: soc_dai))
401	return 0;
402
403	#define __soc_pcm_apply_symmetry(name, NAME) \
404	if (soc_dai->name && (soc_dai->driver->symmetric_##name || \
405	rtd->dai_link->symmetric_##name)) { \
406	dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %s to %d\n",\
407	#name, soc_dai->name); \
408	\
409	ret = snd_pcm_hw_constraint_single(substream->runtime, \
410	SNDRV_PCM_HW_PARAM_##NAME,\
411	soc_dai->name); \
412	if (ret < 0) { \
413	dev_err(soc_dai->dev, \
414	"ASoC: Unable to apply %s constraint: %d\n",\
415	#name, ret); \
416	return ret; \
417	} \
418	}
419
420	__soc_pcm_apply_symmetry(rate, RATE);
421	__soc_pcm_apply_symmetry(channels, CHANNELS);
422	__soc_pcm_apply_symmetry(sample_bits, SAMPLE_BITS);
423
424	return 0;
425	}
426
427	static int soc_pcm_params_symmetry(struct snd_pcm_substream *substream,
428	struct snd_pcm_hw_params *params)
429	{
430	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
431	struct snd_soc_dai d;
432	struct snd_soc_dai *dai;
433	struct snd_soc_dai *cpu_dai;
434	unsigned int symmetry, i;
435
436	d.name = __func__;
437	soc_pcm_set_dai_params(dai: &d, params);
438
439	#define __soc_pcm_params_symmetry(xxx) \
440	symmetry = rtd->dai_link->symmetric_##xxx; \
441	for_each_rtd_dais(rtd, i, dai) \
442	symmetry |= dai->driver->symmetric_##xxx; \
443	\
444	if (symmetry) \
445	for_each_rtd_cpu_dais(rtd, i, cpu_dai) \
446	if (!snd_soc_dai_is_dummy(cpu_dai) && \
447	cpu_dai->xxx && cpu_dai->xxx != d.xxx) { \
448	dev_err(rtd->dev, "ASoC: unmatched %s symmetry: %s:%d - %s:%d\n", \
449	#xxx, cpu_dai->name, cpu_dai->xxx, d.name, d.xxx); \
450	return -EINVAL; \
451	}
452
453	/* reject unmatched parameters when applying symmetry */
454	__soc_pcm_params_symmetry(rate);
455	__soc_pcm_params_symmetry(channels);
456	__soc_pcm_params_symmetry(sample_bits);
457
458	return 0;
459	}
460
461	static void soc_pcm_update_symmetry(struct snd_pcm_substream *substream)
462	{
463	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
464	struct snd_soc_dai_link *link = rtd->dai_link;
465	struct snd_soc_dai *dai;
466	unsigned int symmetry, i;
467
468	symmetry = link->symmetric_rate ||
469	link->symmetric_channels ||
470	link->symmetric_sample_bits;
471
472	for_each_rtd_dais(rtd, i, dai)
473	symmetry = symmetry ||
474	dai->driver->symmetric_rate ||
475	dai->driver->symmetric_channels ||
476	dai->driver->symmetric_sample_bits;
477
478	if (symmetry)
479	substream->runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX;
480	}
481
482	static void soc_pcm_set_msb(struct snd_pcm_substream *substream, int bits)
483	{
484	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
485	int ret;
486
487	if (!bits)
488	return;
489
490	ret = snd_pcm_hw_constraint_msbits(runtime: substream->runtime, cond: 0, width: 0, msbits: bits);
491	if (ret != 0)
492	dev_warn(rtd->dev, "ASoC: Failed to set MSB %d: %d\n",
493	bits, ret);
494	}
495
496	static void soc_pcm_apply_msb(struct snd_pcm_substream *substream)
497	{
498	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
499	struct snd_soc_dai *cpu_dai;
500	struct snd_soc_dai *codec_dai;
501	int stream = substream->stream;
502	int i;
503	unsigned int bits = 0, cpu_bits = 0;
504
505	for_each_rtd_codec_dais(rtd, i, codec_dai) {
506	struct snd_soc_pcm_stream *pcm_codec = snd_soc_dai_get_pcm_stream(dai: codec_dai, stream);
507
508	if (pcm_codec->sig_bits == 0) {
509	bits = 0;
510	break;
511	}
512	bits = max(pcm_codec->sig_bits, bits);
513	}
514
515	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
516	struct snd_soc_pcm_stream *pcm_cpu = snd_soc_dai_get_pcm_stream(dai: cpu_dai, stream);
517
518	if (pcm_cpu->sig_bits == 0) {
519	cpu_bits = 0;
520	break;
521	}
522	cpu_bits = max(pcm_cpu->sig_bits, cpu_bits);
523	}
524
525	soc_pcm_set_msb(substream, bits);
526	soc_pcm_set_msb(substream, bits: cpu_bits);
527	}
528
529	static void soc_pcm_hw_init(struct snd_pcm_hardware *hw)
530	{
531	hw->rates = UINT_MAX;
532	hw->rate_min = 0;
533	hw->rate_max = UINT_MAX;
534	hw->channels_min = 0;
535	hw->channels_max = UINT_MAX;
536	hw->formats = ULLONG_MAX;
537	}
538
539	static void soc_pcm_hw_update_rate(struct snd_pcm_hardware *hw,
540	struct snd_soc_pcm_stream *p)
541	{
542	hw->rates = snd_pcm_rate_mask_intersect(rates_a: hw->rates, rates_b: p->rates);
543
544	/* setup hw->rate_min/max via hw->rates first */
545	snd_pcm_hw_limit_rates(hw);
546
547	/* update hw->rate_min/max by snd_soc_pcm_stream */
548	hw->rate_min = max(hw->rate_min, p->rate_min);
549	hw->rate_max = min_not_zero(hw->rate_max, p->rate_max);
550	}
551
552	static void soc_pcm_hw_update_chan(struct snd_pcm_hardware *hw,
553	struct snd_soc_pcm_stream *p)
554	{
555	hw->channels_min = max(hw->channels_min, p->channels_min);
556	hw->channels_max = min(hw->channels_max, p->channels_max);
557	}
558
559	static void soc_pcm_hw_update_format(struct snd_pcm_hardware *hw,
560	struct snd_soc_pcm_stream *p)
561	{
562	hw->formats &= p->formats;
563	}
564
565	static void soc_pcm_hw_update_subformat(struct snd_pcm_hardware *hw,
566	struct snd_soc_pcm_stream *p)
567	{
568	hw->subformats &= p->subformats;
569	}
570
571	/**
572	* snd_soc_runtime_calc_hw() - Calculate hw limits for a PCM stream
573	* @rtd: ASoC PCM runtime
574	* @hw: PCM hardware parameters (output)
575	* @stream: Direction of the PCM stream
576	*
577	* Calculates the subset of stream parameters supported by all DAIs
578	* associated with the PCM stream.
579	*/
580	int snd_soc_runtime_calc_hw(struct snd_soc_pcm_runtime *rtd,
581	struct snd_pcm_hardware *hw, int stream)
582	{
583	struct snd_soc_dai *codec_dai;
584	struct snd_soc_dai *cpu_dai;
585	struct snd_soc_pcm_stream *codec_stream;
586	struct snd_soc_pcm_stream *cpu_stream;
587	unsigned int cpu_chan_min = 0, cpu_chan_max = UINT_MAX;
588	int i;
589
590	soc_pcm_hw_init(hw);
591
592	/* first calculate min/max only for CPUs in the DAI link */
593	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
594
595	/*
596	* Skip CPUs which don't support the current stream type.
597	* Otherwise, since the rate, channel, and format values will
598	* zero in that case, we would have no usable settings left,
599	* causing the resulting setup to fail.
600	*/
601	if (!snd_soc_dai_stream_valid(dai: cpu_dai, stream))
602	continue;
603
604	cpu_stream = snd_soc_dai_get_pcm_stream(dai: cpu_dai, stream);
605
606	soc_pcm_hw_update_chan(hw, p: cpu_stream);
607	soc_pcm_hw_update_rate(hw, p: cpu_stream);
608	soc_pcm_hw_update_format(hw, p: cpu_stream);
609	soc_pcm_hw_update_subformat(hw, p: cpu_stream);
610	}
611	cpu_chan_min = hw->channels_min;
612	cpu_chan_max = hw->channels_max;
613
614	/* second calculate min/max only for CODECs in the DAI link */
615	for_each_rtd_codec_dais(rtd, i, codec_dai) {
616
617	/*
618	* Skip CODECs which don't support the current stream type.
619	* Otherwise, since the rate, channel, and format values will
620	* zero in that case, we would have no usable settings left,
621	* causing the resulting setup to fail.
622	*/
623	if (!snd_soc_dai_stream_valid(dai: codec_dai, stream))
624	continue;
625
626	codec_stream = snd_soc_dai_get_pcm_stream(dai: codec_dai, stream);
627
628	soc_pcm_hw_update_chan(hw, p: codec_stream);
629	soc_pcm_hw_update_rate(hw, p: codec_stream);
630	soc_pcm_hw_update_format(hw, p: codec_stream);
631	soc_pcm_hw_update_subformat(hw, p: codec_stream);
632	}
633
634	/* Verify both a valid CPU DAI and a valid CODEC DAI were found */
635	if (!hw->channels_min)
636	return -EINVAL;
637
638	/*
639	* chan min/max cannot be enforced if there are multiple CODEC DAIs
640	* connected to CPU DAI(s), use CPU DAI's directly and let
641	* channel allocation be fixed up later
642	*/
643	if (rtd->dai_link->num_codecs > 1) {
644	hw->channels_min = cpu_chan_min;
645	hw->channels_max = cpu_chan_max;
646	}
647
648	return 0;
649	}
650	EXPORT_SYMBOL_GPL(snd_soc_runtime_calc_hw);
651
652	static void soc_pcm_init_runtime_hw(struct snd_pcm_substream *substream)
653	{
654	struct snd_pcm_hardware *hw = &substream->runtime->hw;
655	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
656	u64 formats = hw->formats;
657
658	/*
659	* At least one CPU and one CODEC should match. Otherwise, we should
660	* have bailed out on a higher level, since there would be no CPU or
661	* CODEC to support the transfer direction in that case.
662	*/
663	snd_soc_runtime_calc_hw(rtd, hw, substream->stream);
664
665	if (formats)
666	hw->formats &= formats;
667	}
668
669	static int soc_pcm_components_open(struct snd_pcm_substream *substream)
670	{
671	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
672	struct snd_soc_component *component;
673	int i, ret = 0;
674
675	for_each_rtd_components(rtd, i, component) {
676	ret = snd_soc_component_module_get_when_open(component, substream);
677	if (ret < 0)
678	break;
679
680	ret = snd_soc_component_open(component, substream);
681	if (ret < 0)
682	break;
683	}
684
685	return ret;
686	}
687
688	static int soc_pcm_components_close(struct snd_pcm_substream *substream,
689	int rollback)
690	{
691	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
692	struct snd_soc_component *component;
693	int i, ret = 0;
694
695	for_each_rtd_components(rtd, i, component) {
696	int r = snd_soc_component_close(component, substream, rollback);
697	if (r < 0)
698	ret = r; /* use last ret */
699
700	snd_soc_component_module_put_when_close(component, substream, rollback);
701	}
702
703	return ret;
704	}
705
706	static int soc_pcm_clean(struct snd_soc_pcm_runtime *rtd,
707	struct snd_pcm_substream *substream, int rollback)
708	{
709	struct snd_soc_component *component;
710	struct snd_soc_dai *dai;
711	int i;
712
713	snd_soc_dpcm_mutex_assert_held(rtd);
714
715	if (!rollback) {
716	snd_soc_runtime_deactivate(rtd, stream: substream->stream);
717
718	/* Make sure DAI parameters cleared if the DAI becomes inactive */
719	for_each_rtd_dais(rtd, i, dai) {
720	if (snd_soc_dai_active(dai) == 0 &&
721	(dai->rate || dai->channels || dai->sample_bits))
722	soc_pcm_set_dai_params(dai, NULL);
723	}
724	}
725
726	for_each_rtd_dais(rtd, i, dai)
727	snd_soc_dai_shutdown(dai, substream, rollback);
728
729	snd_soc_link_shutdown(substream, rollback);
730
731	soc_pcm_components_close(substream, rollback);
732
733	snd_soc_pcm_component_pm_runtime_put(rtd, stream: substream, rollback);
734
735	for_each_rtd_components(rtd, i, component)
736	if (!snd_soc_component_active(component))
737	pinctrl_pm_select_sleep_state(dev: component->dev);
738
739	return 0;
740	}
741
742	/*
743	* Called by ALSA when a PCM substream is closed. Private data can be
744	* freed here. The cpu DAI, codec DAI, machine and components are also
745	* shutdown.
746	*/
747	static int __soc_pcm_close(struct snd_soc_pcm_runtime *rtd,
748	struct snd_pcm_substream *substream)
749	{
750	return soc_pcm_clean(rtd, substream, rollback: 0);
751	}
752
753	/* PCM close ops for non-DPCM streams */
754	static int soc_pcm_close(struct snd_pcm_substream *substream)
755	{
756	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
757
758	snd_soc_dpcm_mutex_lock(rtd);
759	__soc_pcm_close(rtd, substream);
760	snd_soc_dpcm_mutex_unlock(rtd);
761	return 0;
762	}
763
764	static int soc_hw_sanity_check(struct snd_pcm_substream *substream)
765	{
766	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
767	struct snd_pcm_hardware *hw = &substream->runtime->hw;
768	const char *name_cpu = soc_cpu_dai_name(rtd);
769	const char *name_codec = soc_codec_dai_name(rtd);
770	const char *err_msg;
771	struct device *dev = rtd->dev;
772
773	err_msg = "rates";
774	if (!hw->rates)
775	goto config_err;
776
777	err_msg = "formats";
778	if (!hw->formats)
779	goto config_err;
780
781	err_msg = "channels";
782	if (!hw->channels_min || !hw->channels_max ||
783	hw->channels_min > hw->channels_max)
784	goto config_err;
785
786	dev_dbg(dev, "ASoC: %s <-> %s info:\n", name_codec,
787	name_cpu);
788	dev_dbg(dev, "ASoC: rate mask 0x%x\n", hw->rates);
789	dev_dbg(dev, "ASoC: ch min %d max %d\n", hw->channels_min,
790	hw->channels_max);
791	dev_dbg(dev, "ASoC: rate min %d max %d\n", hw->rate_min,
792	hw->rate_max);
793
794	return 0;
795
796	config_err:
797	dev_err(dev, "ASoC: %s <-> %s No matching %s\n",
798	name_codec, name_cpu, err_msg);
799	return -EINVAL;
800	}
801
802	/*
803	* Called by ALSA when a PCM substream is opened, the runtime->hw record is
804	* then initialized and any private data can be allocated. This also calls
805	* startup for the cpu DAI, component, machine and codec DAI.
806	*/
807	static int __soc_pcm_open(struct snd_soc_pcm_runtime *rtd,
808	struct snd_pcm_substream *substream)
809	{
810	struct snd_soc_component *component;
811	struct snd_soc_dai *dai;
812	int i, ret = 0;
813
814	snd_soc_dpcm_mutex_assert_held(rtd);
815
816	for_each_rtd_components(rtd, i, component)
817	pinctrl_pm_select_default_state(dev: component->dev);
818
819	ret = snd_soc_pcm_component_pm_runtime_get(rtd, stream: substream);
820	if (ret < 0)
821	goto err;
822
823	ret = soc_pcm_components_open(substream);
824	if (ret < 0)
825	goto err;
826
827	ret = snd_soc_link_startup(substream);
828	if (ret < 0)
829	goto err;
830
831	/* startup the audio subsystem */
832	for_each_rtd_dais(rtd, i, dai) {
833	ret = snd_soc_dai_startup(dai, substream);
834	if (ret < 0)
835	goto err;
836	}
837
838	/* Dynamic PCM DAI links compat checks use dynamic capabilities */
839	if (rtd->dai_link->dynamic || rtd->dai_link->no_pcm)
840	goto dynamic;
841
842	/* Check that the codec and cpu DAIs are compatible */
843	soc_pcm_init_runtime_hw(substream);
844
845	soc_pcm_update_symmetry(substream);
846
847	ret = soc_hw_sanity_check(substream);
848	if (ret < 0)
849	goto err;
850
851	soc_pcm_apply_msb(substream);
852
853	/* Symmetry only applies if we've already got an active stream. */
854	for_each_rtd_dais(rtd, i, dai) {
855	ret = soc_pcm_apply_symmetry(substream, soc_dai: dai);
856	if (ret != 0)
857	goto err;
858	}
859	dynamic:
860	snd_soc_runtime_activate(rtd, stream: substream->stream);
861	ret = 0;
862	err:
863	if (ret < 0)
864	soc_pcm_clean(rtd, substream, rollback: 1);
865
866	return soc_pcm_ret(rtd, ret);
867	}
868
869	/* PCM open ops for non-DPCM streams */
870	static int soc_pcm_open(struct snd_pcm_substream *substream)
871	{
872	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
873	int ret;
874
875	snd_soc_dpcm_mutex_lock(rtd);
876	ret = __soc_pcm_open(rtd, substream);
877	snd_soc_dpcm_mutex_unlock(rtd);
878	return ret;
879	}
880
881	/*
882	* Called by ALSA when the PCM substream is prepared, can set format, sample
883	* rate, etc. This function is non atomic and can be called multiple times,
884	* it can refer to the runtime info.
885	*/
886	static int __soc_pcm_prepare(struct snd_soc_pcm_runtime *rtd,
887	struct snd_pcm_substream *substream)
888	{
889	struct snd_soc_dai *dai;
890	int i, ret = 0;
891
892	snd_soc_dpcm_mutex_assert_held(rtd);
893
894	ret = snd_soc_link_prepare(substream);
895	if (ret < 0)
896	goto out;
897
898	ret = snd_soc_pcm_component_prepare(substream);
899	if (ret < 0)
900	goto out;
901
902	ret = snd_soc_pcm_dai_prepare(substream);
903	if (ret < 0)
904	goto out;
905
906	/* cancel any delayed stream shutdown that is pending */
907	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
908	rtd->pop_wait) {
909	rtd->pop_wait = 0;
910	cancel_delayed_work(dwork: &rtd->delayed_work);
911	}
912
913	snd_soc_dapm_stream_event(rtd, stream: substream->stream,
914	SND_SOC_DAPM_STREAM_START);
915
916	for_each_rtd_dais(rtd, i, dai) {
917	if (dai->driver->ops && !dai->driver->ops->mute_unmute_on_trigger)
918	snd_soc_dai_digital_mute(dai, mute: 0, direction: substream->stream);
919	}
920
921	out:
922	return soc_pcm_ret(rtd, ret);
923	}
924
925	/* PCM prepare ops for non-DPCM streams */
926	static int soc_pcm_prepare(struct snd_pcm_substream *substream)
927	{
928	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
929	int ret;
930
931	snd_soc_dpcm_mutex_lock(rtd);
932	ret = __soc_pcm_prepare(rtd, substream);
933	snd_soc_dpcm_mutex_unlock(rtd);
934	return ret;
935	}
936
937	static void soc_pcm_codec_params_fixup(struct snd_pcm_hw_params *params,
938	unsigned int mask)
939	{
940	struct snd_interval *interval;
941	int channels = hweight_long(w: mask);
942
943	interval = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
944	interval->min = channels;
945	interval->max = channels;
946	}
947
948	static int soc_pcm_hw_clean(struct snd_soc_pcm_runtime *rtd,
949	struct snd_pcm_substream *substream, int rollback)
950	{
951	struct snd_soc_dai *dai;
952	int i;
953
954	snd_soc_dpcm_mutex_assert_held(rtd);
955
956	/* clear the corresponding DAIs parameters when going to be inactive */
957	for_each_rtd_dais(rtd, i, dai) {
958	if (snd_soc_dai_active(dai) == 1)
959	soc_pcm_set_dai_params(dai, NULL);
960
961	if (snd_soc_dai_stream_active(dai, stream: substream->stream) == 1) {
962	if (dai->driver->ops && !dai->driver->ops->mute_unmute_on_trigger)
963	snd_soc_dai_digital_mute(dai, mute: 1, direction: substream->stream);
964	}
965	}
966
967	/* run the stream event */
968	snd_soc_dapm_stream_stop(rtd, stream: substream->stream);
969
970	/* free any machine hw params */
971	snd_soc_link_hw_free(substream, rollback);
972
973	/* free any component resources */
974	snd_soc_pcm_component_hw_free(substream, rollback);
975
976	/* now free hw params for the DAIs */
977	for_each_rtd_dais(rtd, i, dai)
978	if (snd_soc_dai_stream_valid(dai, stream: substream->stream))
979	snd_soc_dai_hw_free(dai, substream, rollback);
980
981	return 0;
982	}
983
984	/*
985	* Frees resources allocated by hw_params, can be called multiple times
986	*/
987	static int __soc_pcm_hw_free(struct snd_soc_pcm_runtime *rtd,
988	struct snd_pcm_substream *substream)
989	{
990	return soc_pcm_hw_clean(rtd, substream, rollback: 0);
991	}
992
993	/* hw_free PCM ops for non-DPCM streams */
994	static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
995	{
996	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
997	int ret;
998
999	snd_soc_dpcm_mutex_lock(rtd);
1000	ret = __soc_pcm_hw_free(rtd, substream);
1001	snd_soc_dpcm_mutex_unlock(rtd);
1002	return ret;
1003	}
1004
1005	/*
1006	* Called by ALSA when the hardware params are set by application. This
1007	* function can also be called multiple times and can allocate buffers
1008	* (using snd_pcm_lib_* ). It's non-atomic.
1009	*/
1010	static int __soc_pcm_hw_params(struct snd_soc_pcm_runtime *rtd,
1011	struct snd_pcm_substream *substream,
1012	struct snd_pcm_hw_params *params)
1013	{
1014	struct snd_soc_dai *cpu_dai;
1015	struct snd_soc_dai *codec_dai;
1016	struct snd_pcm_hw_params tmp_params;
1017	int i, ret = 0;
1018
1019	snd_soc_dpcm_mutex_assert_held(rtd);
1020
1021	ret = soc_pcm_params_symmetry(substream, params);
1022	if (ret)
1023	goto out;
1024
1025	ret = snd_soc_link_hw_params(substream, params);
1026	if (ret < 0)
1027	goto out;
1028
1029	for_each_rtd_codec_dais(rtd, i, codec_dai) {
1030	unsigned int tdm_mask = snd_soc_dai_tdm_mask_get(dai: codec_dai, stream: substream->stream);
1031
1032	/*
1033	* Skip CODECs which don't support the current stream type,
1034	* the idea being that if a CODEC is not used for the currently
1035	* set up transfer direction, it should not need to be
1036	* configured, especially since the configuration used might
1037	* not even be supported by that CODEC. There may be cases
1038	* however where a CODEC needs to be set up although it is
1039	* actually not being used for the transfer, e.g. if a
1040	* capture-only CODEC is acting as an LRCLK and/or BCLK master
1041	* for the DAI link including a playback-only CODEC.
1042	* If this becomes necessary, we will have to augment the
1043	* machine driver setup with information on how to act, so
1044	* we can do the right thing here.
1045	*/
1046	if (!snd_soc_dai_stream_valid(dai: codec_dai, stream: substream->stream))
1047	continue;
1048
1049	/* copy params for each codec */
1050	tmp_params = *params;
1051
1052	/* fixup params based on TDM slot masks */
1053	if (tdm_mask)
1054	soc_pcm_codec_params_fixup(params: &tmp_params, mask: tdm_mask);
1055
1056	ret = snd_soc_dai_hw_params(dai: codec_dai, substream,
1057	params: &tmp_params);
1058	if(ret < 0)
1059	goto out;
1060
1061	soc_pcm_set_dai_params(dai: codec_dai, params: &tmp_params);
1062	snd_soc_dapm_update_dai(substream, params: &tmp_params, dai: codec_dai);
1063	}
1064
1065	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
1066	struct snd_soc_dai_link_ch_map *ch_maps;
1067	unsigned int ch_mask = 0;
1068	int j;
1069
1070	/*
1071	* Skip CPUs which don't support the current stream
1072	* type. See soc_pcm_init_runtime_hw() for more details
1073	*/
1074	if (!snd_soc_dai_stream_valid(dai: cpu_dai, stream: substream->stream))
1075	continue;
1076
1077	/* copy params for each cpu */
1078	tmp_params = *params;
1079
1080	/*
1081	* construct cpu channel mask by combining ch_mask of each
1082	* codec which maps to the cpu.
1083	* see
1084	* soc.h :: [dai_link->ch_maps Image sample]
1085	*/
1086	for_each_rtd_ch_maps(rtd, j, ch_maps)
1087	if (ch_maps->cpu == i)
1088	ch_mask |= ch_maps->ch_mask;
1089
1090	/* fixup cpu channel number */
1091	if (ch_mask)
1092	soc_pcm_codec_params_fixup(params: &tmp_params, mask: ch_mask);
1093
1094	ret = snd_soc_dai_hw_params(dai: cpu_dai, substream, params: &tmp_params);
1095	if (ret < 0)
1096	goto out;
1097
1098	/* store the parameters for each DAI */
1099	soc_pcm_set_dai_params(dai: cpu_dai, params: &tmp_params);
1100	snd_soc_dapm_update_dai(substream, params: &tmp_params, dai: cpu_dai);
1101	}
1102
1103	ret = snd_soc_pcm_component_hw_params(substream, params);
1104	out:
1105	if (ret < 0)
1106	soc_pcm_hw_clean(rtd, substream, rollback: 1);
1107
1108	return soc_pcm_ret(rtd, ret);
1109	}
1110
1111	/* hw_params PCM ops for non-DPCM streams */
1112	static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
1113	struct snd_pcm_hw_params *params)
1114	{
1115	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
1116	int ret;
1117
1118	snd_soc_dpcm_mutex_lock(rtd);
1119	ret = __soc_pcm_hw_params(rtd, substream, params);
1120	snd_soc_dpcm_mutex_unlock(rtd);
1121	return ret;
1122	}
1123
1124	#define TRIGGER_MAX 3
1125	static int (* const trigger[][TRIGGER_MAX])(struct snd_pcm_substream *substream, int cmd, int rollback) = {
1126	[SND_SOC_TRIGGER_ORDER_DEFAULT] = {
1127	snd_soc_link_trigger,
1128	snd_soc_pcm_component_trigger,
1129	snd_soc_pcm_dai_trigger,
1130	},
1131	[SND_SOC_TRIGGER_ORDER_LDC] = {
1132	snd_soc_link_trigger,
1133	snd_soc_pcm_dai_trigger,
1134	snd_soc_pcm_component_trigger,
1135	},
1136	};
1137
1138	static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
1139	{
1140	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
1141	struct snd_soc_component *component;
1142	int ret = 0, r = 0, i;
1143	int rollback = 0;
1144	int start = 0, stop = 0;
1145
1146	/*
1147	* select START/STOP sequence
1148	*/
1149	for_each_rtd_components(rtd, i, component) {
1150	if (component->driver->trigger_start)
1151	start = component->driver->trigger_start;
1152	if (component->driver->trigger_stop)
1153	stop = component->driver->trigger_stop;
1154	}
1155	if (rtd->dai_link->trigger_start)
1156	start = rtd->dai_link->trigger_start;
1157	if (rtd->dai_link->trigger_stop)
1158	stop = rtd->dai_link->trigger_stop;
1159
1160	if (start < 0 || start >= SND_SOC_TRIGGER_ORDER_MAX ||
1161	stop < 0 || stop >= SND_SOC_TRIGGER_ORDER_MAX)
1162	return -EINVAL;
1163
1164	/*
1165	* START
1166	*/
1167	switch (cmd) {
1168	case SNDRV_PCM_TRIGGER_START:
1169	case SNDRV_PCM_TRIGGER_RESUME:
1170	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1171	for (i = 0; i < TRIGGER_MAX; i++) {
1172	r = trigger[start][i](substream, cmd, 0);
1173	if (r < 0)
1174	break;
1175	}
1176	}
1177
1178	/*
1179	* Rollback if START failed
1180	* find correspond STOP command
1181	*/
1182	if (r < 0) {
1183	rollback = 1;
1184	ret = r;
1185	switch (cmd) {
1186	case SNDRV_PCM_TRIGGER_START:
1187	cmd = SNDRV_PCM_TRIGGER_STOP;
1188	break;
1189	case SNDRV_PCM_TRIGGER_RESUME:
1190	cmd = SNDRV_PCM_TRIGGER_SUSPEND;
1191	break;
1192	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1193	cmd = SNDRV_PCM_TRIGGER_PAUSE_PUSH;
1194	break;
1195	}
1196	}
1197
1198	/*
1199	* STOP
1200	*/
1201	switch (cmd) {
1202	case SNDRV_PCM_TRIGGER_STOP:
1203	case SNDRV_PCM_TRIGGER_SUSPEND:
1204	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1205	for (i = TRIGGER_MAX; i > 0; i--) {
1206	r = trigger[stop][i - 1](substream, cmd, rollback);
1207	if (r < 0)
1208	ret = r;
1209	}
1210	}
1211
1212	return ret;
1213	}
1214
1215	/*
1216	* soc level wrapper for pointer callback
1217	* If cpu_dai, codec_dai, component driver has the delay callback, then
1218	* the runtime->delay will be updated via snd_soc_pcm_component/dai_delay().
1219	*/
1220	static snd_pcm_uframes_t soc_pcm_pointer(struct snd_pcm_substream *substream)
1221	{
1222	struct snd_pcm_runtime *runtime = substream->runtime;
1223	snd_pcm_uframes_t offset = 0;
1224	snd_pcm_sframes_t codec_delay = 0;
1225	snd_pcm_sframes_t cpu_delay = 0;
1226
1227	offset = snd_soc_pcm_component_pointer(substream);
1228
1229	/* should be called *after* snd_soc_pcm_component_pointer() */
1230	snd_soc_pcm_dai_delay(substream, cpu_delay: &cpu_delay, codec_delay: &codec_delay);
1231	snd_soc_pcm_component_delay(substream, cpu_delay: &cpu_delay, codec_delay: &codec_delay);
1232
1233	runtime->delay = cpu_delay + codec_delay;
1234
1235	return offset;
1236	}
1237
1238	/* connect a FE and BE */
1239	static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe,
1240	struct snd_soc_pcm_runtime *be, int stream)
1241	{
1242	struct snd_pcm_substream *fe_substream;
1243	struct snd_pcm_substream *be_substream;
1244	struct snd_soc_dpcm *dpcm;
1245
1246	snd_soc_dpcm_mutex_assert_held(fe);
1247
1248	/* only add new dpcms */
1249	for_each_dpcm_be(fe, stream, dpcm) {
1250	if (dpcm->be == be && dpcm->fe == fe)
1251	return 0;
1252	}
1253
1254	fe_substream = snd_soc_dpcm_get_substream(be: fe, stream);
1255	be_substream = snd_soc_dpcm_get_substream(be, stream);
1256
1257	if (!fe_substream->pcm->nonatomic && be_substream->pcm->nonatomic) {
1258	dev_err(be->dev, "%s: FE is atomic but BE is nonatomic, invalid configuration\n",
1259	__func__);
1260	return -EINVAL;
1261	}
1262	if (fe_substream->pcm->nonatomic && !be_substream->pcm->nonatomic) {
1263	dev_dbg(be->dev, "FE is nonatomic but BE is not, forcing BE as nonatomic\n");
1264	be_substream->pcm->nonatomic = 1;
1265	}
1266
1267	dpcm = kzalloc(size: sizeof(struct snd_soc_dpcm), GFP_KERNEL);
1268	if (!dpcm)
1269	return -ENOMEM;
1270
1271	dpcm->be = be;
1272	dpcm->fe = fe;
1273	dpcm->state = SND_SOC_DPCM_LINK_STATE_NEW;
1274	snd_soc_dpcm_stream_lock_irq(rtd: fe, stream);
1275	list_add(new: &dpcm->list_be, head: &fe->dpcm[stream].be_clients);
1276	list_add(new: &dpcm->list_fe, head: &be->dpcm[stream].fe_clients);
1277	snd_soc_dpcm_stream_unlock_irq(rtd: fe, stream);
1278
1279	dev_dbg(fe->dev, "connected new DPCM %s path %s %s %s\n",
1280	stream ? "capture" : "playback", fe->dai_link->name,
1281	stream ? "<-" : "->", be->dai_link->name);
1282
1283	dpcm_create_debugfs_state(dpcm, stream);
1284
1285	return 1;
1286	}
1287
1288	/* reparent a BE onto another FE */
1289	static void dpcm_be_reparent(struct snd_soc_pcm_runtime *fe,
1290	struct snd_soc_pcm_runtime *be, int stream)
1291	{
1292	struct snd_soc_dpcm *dpcm;
1293	struct snd_pcm_substream *fe_substream, *be_substream;
1294
1295	/* reparent if BE is connected to other FEs */
1296	if (!be->dpcm[stream].users)
1297	return;
1298
1299	be_substream = snd_soc_dpcm_get_substream(be, stream);
1300	if (!be_substream)
1301	return;
1302
1303	for_each_dpcm_fe(be, stream, dpcm) {
1304	if (dpcm->fe == fe)
1305	continue;
1306
1307	dev_dbg(fe->dev, "reparent %s path %s %s %s\n",
1308	stream ? "capture" : "playback",
1309	dpcm->fe->dai_link->name,
1310	stream ? "<-" : "->", dpcm->be->dai_link->name);
1311
1312	fe_substream = snd_soc_dpcm_get_substream(be: dpcm->fe, stream);
1313	be_substream->runtime = fe_substream->runtime;
1314	break;
1315	}
1316	}
1317
1318	/* disconnect a BE and FE */
1319	void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream)
1320	{
1321	struct snd_soc_dpcm *dpcm, *d;
1322	LIST_HEAD(deleted_dpcms);
1323
1324	snd_soc_dpcm_mutex_assert_held(fe);
1325
1326	snd_soc_dpcm_stream_lock_irq(rtd: fe, stream);
1327	for_each_dpcm_be_safe(fe, stream, dpcm, d) {
1328	dev_dbg(fe->dev, "ASoC: BE %s disconnect check for %s\n",
1329	stream ? "capture" : "playback",
1330	dpcm->be->dai_link->name);
1331
1332	if (dpcm->state != SND_SOC_DPCM_LINK_STATE_FREE)
1333	continue;
1334
1335	dev_dbg(fe->dev, "freed DSP %s path %s %s %s\n",
1336	stream ? "capture" : "playback", fe->dai_link->name,
1337	stream ? "<-" : "->", dpcm->be->dai_link->name);
1338
1339	/* BEs still alive need new FE */
1340	dpcm_be_reparent(fe, be: dpcm->be, stream);
1341
1342	list_del(entry: &dpcm->list_be);
1343	list_move(list: &dpcm->list_fe, head: &deleted_dpcms);
1344	}
1345	snd_soc_dpcm_stream_unlock_irq(rtd: fe, stream);
1346
1347	while (!list_empty(head: &deleted_dpcms)) {
1348	dpcm = list_first_entry(&deleted_dpcms, struct snd_soc_dpcm,
1349	list_fe);
1350	list_del(entry: &dpcm->list_fe);
1351	dpcm_remove_debugfs_state(dpcm);
1352	kfree(objp: dpcm);
1353	}
1354	}
1355
1356	/* get BE for DAI widget and stream */
1357	static struct snd_soc_pcm_runtime *dpcm_get_be(struct snd_soc_card *card,
1358	struct snd_soc_dapm_widget *widget, int stream)
1359	{
1360	struct snd_soc_pcm_runtime *be;
1361	struct snd_soc_dapm_widget *w;
1362	struct snd_soc_dai *dai;
1363	int i;
1364
1365	dev_dbg(card->dev, "ASoC: find BE for widget %s\n", widget->name);
1366
1367	for_each_card_rtds(card, be) {
1368
1369	if (!be->dai_link->no_pcm)
1370	continue;
1371
1372	if (!snd_soc_dpcm_get_substream(be, stream))
1373	continue;
1374
1375	for_each_rtd_dais(be, i, dai) {
1376	w = snd_soc_dai_get_widget(dai, stream);
1377
1378	dev_dbg(card->dev, "ASoC: try BE : %s\n",
1379	w ? w->name : "(not set)");
1380
1381	if (w == widget)
1382	return be;
1383	}
1384	}
1385
1386	/* Widget provided is not a BE */
1387	return NULL;
1388	}
1389
1390	int widget_in_list(struct snd_soc_dapm_widget_list *list,
1391	struct snd_soc_dapm_widget *widget)
1392	{
1393	struct snd_soc_dapm_widget *w;
1394	int i;
1395
1396	for_each_dapm_widgets(list, i, w)
1397	if (widget == w)
1398	return 1;
1399
1400	return 0;
1401	}
1402	EXPORT_SYMBOL_GPL(widget_in_list);
1403
1404	bool dpcm_end_walk_at_be(struct snd_soc_dapm_widget *widget, enum snd_soc_dapm_direction dir)
1405	{
1406	struct snd_soc_card *card = widget->dapm->card;
1407	struct snd_soc_pcm_runtime *rtd;
1408	int stream;
1409
1410	/* adjust dir to stream */
1411	if (dir == SND_SOC_DAPM_DIR_OUT)
1412	stream = SNDRV_PCM_STREAM_PLAYBACK;
1413	else
1414	stream = SNDRV_PCM_STREAM_CAPTURE;
1415
1416	rtd = dpcm_get_be(card, widget, stream);
1417	if (rtd)
1418	return true;
1419
1420	return false;
1421	}
1422	EXPORT_SYMBOL_GPL(dpcm_end_walk_at_be);
1423
1424	int dpcm_path_get(struct snd_soc_pcm_runtime *fe,
1425	int stream, struct snd_soc_dapm_widget_list **list)
1426	{
1427	struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(fe, 0);
1428	int paths;
1429
1430	if (fe->dai_link->num_cpus > 1) {
1431	dev_err(fe->dev,
1432	"%s doesn't support Multi CPU yet\n", __func__);
1433	return -EINVAL;
1434	}
1435
1436	/* get number of valid DAI paths and their widgets */
1437	paths = snd_soc_dapm_dai_get_connected_widgets(dai: cpu_dai, stream, list,
1438	custom_stop_condition: fe->card->component_chaining ?
1439	NULL : dpcm_end_walk_at_be);
1440
1441	if (paths > 0)
1442	dev_dbg(fe->dev, "ASoC: found %d audio %s paths\n", paths,
1443	stream ? "capture" : "playback");
1444	else if (paths == 0)
1445	dev_dbg(fe->dev, "ASoC: %s no valid %s path\n", fe->dai_link->name,
1446	stream ? "capture" : "playback");
1447
1448	return paths;
1449	}
1450
1451	void dpcm_path_put(struct snd_soc_dapm_widget_list **list)
1452	{
1453	snd_soc_dapm_dai_free_widgets(list);
1454	}
1455
1456	static bool dpcm_be_is_active(struct snd_soc_dpcm *dpcm, int stream,
1457	struct snd_soc_dapm_widget_list *list)
1458	{
1459	struct snd_soc_dai *dai;
1460	unsigned int i;
1461
1462	/* is there a valid DAI widget for this BE */
1463	for_each_rtd_dais(dpcm->be, i, dai) {
1464	struct snd_soc_dapm_widget *widget = snd_soc_dai_get_widget(dai, stream);
1465
1466	/*
1467	* The BE is pruned only if none of the dai
1468	* widgets are in the active list.
1469	*/
1470	if (widget && widget_in_list(list, widget))
1471	return true;
1472	}
1473
1474	return false;
1475	}
1476
1477	static int dpcm_prune_paths(struct snd_soc_pcm_runtime *fe, int stream,
1478	struct snd_soc_dapm_widget_list **list_)
1479	{
1480	struct snd_soc_dpcm *dpcm;
1481	int prune = 0;
1482
1483	/* Destroy any old FE <--> BE connections */
1484	for_each_dpcm_be(fe, stream, dpcm) {
1485	if (dpcm_be_is_active(dpcm, stream, list: *list_))
1486	continue;
1487
1488	dev_dbg(fe->dev, "ASoC: pruning %s BE %s for %s\n",
1489	stream ? "capture" : "playback",
1490	dpcm->be->dai_link->name, fe->dai_link->name);
1491	dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
1492	dpcm_set_be_update_state(be: dpcm->be, stream, state: SND_SOC_DPCM_UPDATE_BE);
1493	prune++;
1494	}
1495
1496	dev_dbg(fe->dev, "ASoC: found %d old BE paths for pruning\n", prune);
1497	return prune;
1498	}
1499
1500	static int dpcm_add_paths(struct snd_soc_pcm_runtime *fe, int stream,
1501	struct snd_soc_dapm_widget_list **list_)
1502	{
1503	struct snd_soc_card *card = fe->card;
1504	struct snd_soc_dapm_widget_list *list = *list_;
1505	struct snd_soc_pcm_runtime *be;
1506	struct snd_soc_dapm_widget *widget;
1507	struct snd_pcm_substream *fe_substream = snd_soc_dpcm_get_substream(be: fe, stream);
1508	int i, new = 0, err;
1509
1510	/* don't connect if FE is not running */
1511	if (!fe_substream->runtime && !fe->fe_compr)
1512	return new;
1513
1514	/* Create any new FE <--> BE connections */
1515	for_each_dapm_widgets(list, i, widget) {
1516
1517	switch (widget->id) {
1518	case snd_soc_dapm_dai_in:
1519	if (stream != SNDRV_PCM_STREAM_PLAYBACK)
1520	continue;
1521	break;
1522	case snd_soc_dapm_dai_out:
1523	if (stream != SNDRV_PCM_STREAM_CAPTURE)
1524	continue;
1525	break;
1526	default:
1527	continue;
1528	}
1529
1530	/* is there a valid BE rtd for this widget */
1531	be = dpcm_get_be(card, widget, stream);
1532	if (!be) {
1533	dev_dbg(fe->dev, "ASoC: no BE found for %s\n",
1534	widget->name);
1535	continue;
1536	}
1537
1538	/*
1539	* Filter for systems with 'component_chaining' enabled.
1540	* This helps to avoid unnecessary re-configuration of an
1541	* already active BE on such systems.
1542	*/
1543	if (fe->card->component_chaining &&
1544	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_NEW) &&
1545	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_CLOSE))
1546	continue;
1547
1548	/* newly connected FE and BE */
1549	err = dpcm_be_connect(fe, be, stream);
1550	if (err < 0) {
1551	dev_err(fe->dev, "ASoC: can't connect %s\n",
1552	widget->name);
1553	break;
1554	} else if (err == 0) /* already connected */
1555	continue;
1556
1557	/* new */
1558	dpcm_set_be_update_state(be, stream, state: SND_SOC_DPCM_UPDATE_BE);
1559	new++;
1560	}
1561
1562	dev_dbg(fe->dev, "ASoC: found %d new BE paths\n", new);
1563	return new;
1564	}
1565
1566	/*
1567	* Find the corresponding BE DAIs that source or sink audio to this
1568	* FE substream.
1569	*/
1570	int dpcm_process_paths(struct snd_soc_pcm_runtime *fe,
1571	int stream, struct snd_soc_dapm_widget_list **list, int new)
1572	{
1573	if (new)
1574	return dpcm_add_paths(fe, stream, list_: list);
1575	else
1576	return dpcm_prune_paths(fe, stream, list_: list);
1577	}
1578
1579	void dpcm_clear_pending_state(struct snd_soc_pcm_runtime *fe, int stream)
1580	{
1581	struct snd_soc_dpcm *dpcm;
1582
1583	for_each_dpcm_be(fe, stream, dpcm)
1584	dpcm_set_be_update_state(be: dpcm->be, stream, state: SND_SOC_DPCM_UPDATE_NO);
1585	}
1586
1587	void dpcm_be_dai_stop(struct snd_soc_pcm_runtime *fe, int stream,
1588	int do_hw_free, struct snd_soc_dpcm *last)
1589	{
1590	struct snd_soc_dpcm *dpcm;
1591
1592	/* disable any enabled and non active backends */
1593	for_each_dpcm_be(fe, stream, dpcm) {
1594	struct snd_soc_pcm_runtime *be = dpcm->be;
1595	struct snd_pcm_substream *be_substream =
1596	snd_soc_dpcm_get_substream(be, stream);
1597
1598	if (dpcm == last)
1599	return;
1600
1601	/* is this op for this BE ? */
1602	if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1603	continue;
1604
1605	if (be->dpcm[stream].users == 0) {
1606	dev_err(be->dev, "ASoC: no users %s at close - state %d\n",
1607	stream ? "capture" : "playback",
1608	be->dpcm[stream].state);
1609	continue;
1610	}
1611
1612	if (--be->dpcm[stream].users != 0)
1613	continue;
1614
1615	if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) {
1616	if (!do_hw_free)
1617	continue;
1618
1619	if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) {
1620	__soc_pcm_hw_free(rtd: be, substream: be_substream);
1621	be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
1622	}
1623	}
1624
1625	__soc_pcm_close(rtd: be, substream: be_substream);
1626	be_substream->runtime = NULL;
1627	be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1628	}
1629	}
1630
1631	int dpcm_be_dai_startup(struct snd_soc_pcm_runtime *fe, int stream)
1632	{
1633	struct snd_pcm_substream *fe_substream = snd_soc_dpcm_get_substream(be: fe, stream);
1634	struct snd_soc_pcm_runtime *be;
1635	struct snd_soc_dpcm *dpcm;
1636	int err, count = 0;
1637
1638	/* only startup BE DAIs that are either sinks or sources to this FE DAI */
1639	for_each_dpcm_be(fe, stream, dpcm) {
1640	struct snd_pcm_substream *be_substream;
1641
1642	be = dpcm->be;
1643	be_substream = snd_soc_dpcm_get_substream(be, stream);
1644
1645	if (!be_substream) {
1646	dev_err(be->dev, "ASoC: no backend %s stream\n",
1647	stream ? "capture" : "playback");
1648	continue;
1649	}
1650
1651	/* is this op for this BE ? */
1652	if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1653	continue;
1654
1655	/* first time the dpcm is open ? */
1656	if (be->dpcm[stream].users == DPCM_MAX_BE_USERS) {
1657	dev_err(be->dev, "ASoC: too many users %s at open %d\n",
1658	stream ? "capture" : "playback",
1659	be->dpcm[stream].state);
1660	continue;
1661	}
1662
1663	if (be->dpcm[stream].users++ != 0)
1664	continue;
1665
1666	if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_NEW) &&
1667	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_CLOSE))
1668	continue;
1669
1670	dev_dbg(be->dev, "ASoC: open %s BE %s\n",
1671	stream ? "capture" : "playback", be->dai_link->name);
1672
1673	be_substream->runtime = fe_substream->runtime;
1674	err = __soc_pcm_open(rtd: be, substream: be_substream);
1675	if (err < 0) {
1676	be->dpcm[stream].users--;
1677	if (be->dpcm[stream].users < 0)
1678	dev_err(be->dev, "ASoC: no users %s at unwind %d\n",
1679	stream ? "capture" : "playback",
1680	be->dpcm[stream].state);
1681
1682	be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1683	goto unwind;
1684	}
1685	be->dpcm[stream].be_start = 0;
1686	be->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
1687	count++;
1688	}
1689
1690	return count;
1691
1692	unwind:
1693	dpcm_be_dai_startup_rollback(fe, stream, dpcm);
1694
1695	return soc_pcm_ret(fe, err);
1696	}
1697
1698	static void dpcm_runtime_setup_fe(struct snd_pcm_substream *substream)
1699	{
1700	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
1701	struct snd_pcm_runtime *runtime = substream->runtime;
1702	struct snd_pcm_hardware *hw = &runtime->hw;
1703	struct snd_soc_dai *dai;
1704	int stream = substream->stream;
1705	u64 formats = hw->formats;
1706	int i;
1707
1708	soc_pcm_hw_init(hw);
1709
1710	if (formats)
1711	hw->formats &= formats;
1712
1713	for_each_rtd_cpu_dais(fe, i, dai) {
1714	struct snd_soc_pcm_stream *cpu_stream;
1715
1716	/*
1717	* Skip CPUs which don't support the current stream
1718	* type. See soc_pcm_init_runtime_hw() for more details
1719	*/
1720	if (!snd_soc_dai_stream_valid(dai, stream))
1721	continue;
1722
1723	cpu_stream = snd_soc_dai_get_pcm_stream(dai, stream);
1724
1725	soc_pcm_hw_update_rate(hw, p: cpu_stream);
1726	soc_pcm_hw_update_chan(hw, p: cpu_stream);
1727	soc_pcm_hw_update_format(hw, p: cpu_stream);
1728	soc_pcm_hw_update_subformat(hw, p: cpu_stream);
1729	}
1730
1731	}
1732
1733	static void dpcm_runtime_setup_be_format(struct snd_pcm_substream *substream)
1734	{
1735	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
1736	struct snd_pcm_runtime *runtime = substream->runtime;
1737	struct snd_pcm_hardware *hw = &runtime->hw;
1738	struct snd_soc_dpcm *dpcm;
1739	struct snd_soc_dai *dai;
1740	int stream = substream->stream;
1741
1742	if (!fe->dai_link->dpcm_merged_format)
1743	return;
1744
1745	/*
1746	* It returns merged BE codec format
1747	* if FE want to use it (= dpcm_merged_format)
1748	*/
1749
1750	for_each_dpcm_be(fe, stream, dpcm) {
1751	struct snd_soc_pcm_runtime *be = dpcm->be;
1752	struct snd_soc_pcm_stream *codec_stream;
1753	int i;
1754
1755	for_each_rtd_codec_dais(be, i, dai) {
1756	/*
1757	* Skip CODECs which don't support the current stream
1758	* type. See soc_pcm_init_runtime_hw() for more details
1759	*/
1760	if (!snd_soc_dai_stream_valid(dai, stream))
1761	continue;
1762
1763	codec_stream = snd_soc_dai_get_pcm_stream(dai, stream);
1764
1765	soc_pcm_hw_update_format(hw, p: codec_stream);
1766	soc_pcm_hw_update_subformat(hw, p: codec_stream);
1767	}
1768	}
1769	}
1770
1771	static void dpcm_runtime_setup_be_chan(struct snd_pcm_substream *substream)
1772	{
1773	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
1774	struct snd_pcm_runtime *runtime = substream->runtime;
1775	struct snd_pcm_hardware *hw = &runtime->hw;
1776	struct snd_soc_dpcm *dpcm;
1777	int stream = substream->stream;
1778
1779	if (!fe->dai_link->dpcm_merged_chan)
1780	return;
1781
1782	/*
1783	* It returns merged BE codec channel;
1784	* if FE want to use it (= dpcm_merged_chan)
1785	*/
1786
1787	for_each_dpcm_be(fe, stream, dpcm) {
1788	struct snd_soc_pcm_runtime *be = dpcm->be;
1789	struct snd_soc_pcm_stream *cpu_stream;
1790	struct snd_soc_dai *dai;
1791	int i;
1792
1793	for_each_rtd_cpu_dais(be, i, dai) {
1794	/*
1795	* Skip CPUs which don't support the current stream
1796	* type. See soc_pcm_init_runtime_hw() for more details
1797	*/
1798	if (!snd_soc_dai_stream_valid(dai, stream))
1799	continue;
1800
1801	cpu_stream = snd_soc_dai_get_pcm_stream(dai, stream);
1802
1803	soc_pcm_hw_update_chan(hw, p: cpu_stream);
1804	}
1805
1806	/*
1807	* chan min/max cannot be enforced if there are multiple CODEC
1808	* DAIs connected to a single CPU DAI, use CPU DAI's directly
1809	*/
1810	if (be->dai_link->num_codecs == 1) {
1811	struct snd_soc_pcm_stream *codec_stream = snd_soc_dai_get_pcm_stream(
1812	snd_soc_rtd_to_codec(be, 0), stream);
1813
1814	soc_pcm_hw_update_chan(hw, p: codec_stream);
1815	}
1816	}
1817	}
1818
1819	static void dpcm_runtime_setup_be_rate(struct snd_pcm_substream *substream)
1820	{
1821	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
1822	struct snd_pcm_runtime *runtime = substream->runtime;
1823	struct snd_pcm_hardware *hw = &runtime->hw;
1824	struct snd_soc_dpcm *dpcm;
1825	int stream = substream->stream;
1826
1827	if (!fe->dai_link->dpcm_merged_rate)
1828	return;
1829
1830	/*
1831	* It returns merged BE codec channel;
1832	* if FE want to use it (= dpcm_merged_chan)
1833	*/
1834
1835	for_each_dpcm_be(fe, stream, dpcm) {
1836	struct snd_soc_pcm_runtime *be = dpcm->be;
1837	struct snd_soc_pcm_stream *pcm;
1838	struct snd_soc_dai *dai;
1839	int i;
1840
1841	for_each_rtd_dais(be, i, dai) {
1842	/*
1843	* Skip DAIs which don't support the current stream
1844	* type. See soc_pcm_init_runtime_hw() for more details
1845	*/
1846	if (!snd_soc_dai_stream_valid(dai, stream))
1847	continue;
1848
1849	pcm = snd_soc_dai_get_pcm_stream(dai, stream);
1850
1851	soc_pcm_hw_update_rate(hw, p: pcm);
1852	}
1853	}
1854	}
1855
1856	static int dpcm_apply_symmetry(struct snd_pcm_substream *fe_substream,
1857	int stream)
1858	{
1859	struct snd_soc_dpcm *dpcm;
1860	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(fe_substream);
1861	struct snd_soc_dai *fe_cpu_dai;
1862	int err = 0;
1863	int i;
1864
1865	/* apply symmetry for FE */
1866	soc_pcm_update_symmetry(substream: fe_substream);
1867
1868	for_each_rtd_cpu_dais (fe, i, fe_cpu_dai) {
1869	/* Symmetry only applies if we've got an active stream. */
1870	err = soc_pcm_apply_symmetry(substream: fe_substream, soc_dai: fe_cpu_dai);
1871	if (err < 0)
1872	goto error;
1873	}
1874
1875	/* apply symmetry for BE */
1876	for_each_dpcm_be(fe, stream, dpcm) {
1877	struct snd_soc_pcm_runtime *be = dpcm->be;
1878	struct snd_pcm_substream *be_substream =
1879	snd_soc_dpcm_get_substream(be, stream);
1880	struct snd_soc_pcm_runtime *rtd;
1881	struct snd_soc_dai *dai;
1882
1883	/* A backend may not have the requested substream */
1884	if (!be_substream)
1885	continue;
1886
1887	rtd = snd_soc_substream_to_rtd(be_substream);
1888	if (rtd->dai_link->be_hw_params_fixup)
1889	continue;
1890
1891	soc_pcm_update_symmetry(substream: be_substream);
1892
1893	/* Symmetry only applies if we've got an active stream. */
1894	for_each_rtd_dais(rtd, i, dai) {
1895	err = soc_pcm_apply_symmetry(substream: fe_substream, soc_dai: dai);
1896	if (err < 0)
1897	goto error;
1898	}
1899	}
1900	error:
1901	return soc_pcm_ret(fe, err);
1902	}
1903
1904	static int dpcm_fe_dai_startup(struct snd_pcm_substream *fe_substream)
1905	{
1906	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(fe_substream);
1907	int stream = fe_substream->stream, ret = 0;
1908
1909	dpcm_set_fe_update_state(fe, stream, state: SND_SOC_DPCM_UPDATE_FE);
1910
1911	ret = dpcm_be_dai_startup(fe, stream);
1912	if (ret < 0)
1913	goto be_err;
1914
1915	dev_dbg(fe->dev, "ASoC: open FE %s\n", fe->dai_link->name);
1916
1917	/* start the DAI frontend */
1918	ret = __soc_pcm_open(rtd: fe, substream: fe_substream);
1919	if (ret < 0)
1920	goto unwind;
1921
1922	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
1923
1924	dpcm_runtime_setup_fe(substream: fe_substream);
1925
1926	dpcm_runtime_setup_be_format(substream: fe_substream);
1927	dpcm_runtime_setup_be_chan(substream: fe_substream);
1928	dpcm_runtime_setup_be_rate(substream: fe_substream);
1929
1930	ret = dpcm_apply_symmetry(fe_substream, stream);
1931
1932	unwind:
1933	if (ret < 0)
1934	dpcm_be_dai_startup_unwind(fe, stream);
1935	be_err:
1936	dpcm_set_fe_update_state(fe, stream, state: SND_SOC_DPCM_UPDATE_NO);
1937
1938	return soc_pcm_ret(fe, ret);
1939	}
1940
1941	static int dpcm_fe_dai_shutdown(struct snd_pcm_substream *substream)
1942	{
1943	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
1944	int stream = substream->stream;
1945
1946	snd_soc_dpcm_mutex_assert_held(fe);
1947
1948	dpcm_set_fe_update_state(fe, stream, state: SND_SOC_DPCM_UPDATE_FE);
1949
1950	/* shutdown the BEs */
1951	dpcm_be_dai_shutdown(fe, stream);
1952
1953	dev_dbg(fe->dev, "ASoC: close FE %s\n", fe->dai_link->name);
1954
1955	/* now shutdown the frontend */
1956	__soc_pcm_close(rtd: fe, substream);
1957
1958	/* run the stream stop event */
1959	dpcm_dapm_stream_event(fe, dir: stream, SND_SOC_DAPM_STREAM_STOP);
1960
1961	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1962	dpcm_set_fe_update_state(fe, stream, state: SND_SOC_DPCM_UPDATE_NO);
1963	return 0;
1964	}
1965
1966	void dpcm_be_dai_hw_free(struct snd_soc_pcm_runtime *fe, int stream)
1967	{
1968	struct snd_soc_dpcm *dpcm;
1969
1970	/* only hw_params backends that are either sinks or sources
1971	* to this frontend DAI */
1972	for_each_dpcm_be(fe, stream, dpcm) {
1973
1974	struct snd_soc_pcm_runtime *be = dpcm->be;
1975	struct snd_pcm_substream *be_substream =
1976	snd_soc_dpcm_get_substream(be, stream);
1977
1978	/* is this op for this BE ? */
1979	if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1980	continue;
1981
1982	/* only free hw when no longer used - check all FEs */
1983	if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
1984	continue;
1985
1986	/* do not free hw if this BE is used by other FE */
1987	if (be->dpcm[stream].users > 1)
1988	continue;
1989
1990	if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
1991	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
1992	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
1993	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED) &&
1994	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
1995	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
1996	continue;
1997
1998	dev_dbg(be->dev, "ASoC: hw_free BE %s\n",
1999	be->dai_link->name);
2000
2001	__soc_pcm_hw_free(rtd: be, substream: be_substream);
2002
2003	be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
2004	}
2005	}
2006
2007	static int dpcm_fe_dai_hw_free(struct snd_pcm_substream *substream)
2008	{
2009	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
2010	int stream = substream->stream;
2011
2012	snd_soc_dpcm_mutex_lock(fe);
2013	dpcm_set_fe_update_state(fe, stream, state: SND_SOC_DPCM_UPDATE_FE);
2014
2015	dev_dbg(fe->dev, "ASoC: hw_free FE %s\n", fe->dai_link->name);
2016
2017	/* call hw_free on the frontend */
2018	soc_pcm_hw_clean(rtd: fe, substream, rollback: 0);
2019
2020	/* only hw_params backends that are either sinks or sources
2021	* to this frontend DAI */
2022	dpcm_be_dai_hw_free(fe, stream);
2023
2024	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
2025	dpcm_set_fe_update_state(fe, stream, state: SND_SOC_DPCM_UPDATE_NO);
2026
2027	snd_soc_dpcm_mutex_unlock(fe);
2028	return 0;
2029	}
2030
2031	int dpcm_be_dai_hw_params(struct snd_soc_pcm_runtime *fe, int stream)
2032	{
2033	struct snd_soc_pcm_runtime *be;
2034	struct snd_pcm_substream *be_substream;
2035	struct snd_soc_dpcm *dpcm;
2036	int ret;
2037
2038	for_each_dpcm_be(fe, stream, dpcm) {
2039	struct snd_pcm_hw_params hw_params;
2040
2041	be = dpcm->be;
2042	be_substream = snd_soc_dpcm_get_substream(be, stream);
2043
2044	/* is this op for this BE ? */
2045	if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2046	continue;
2047
2048	/* copy params for each dpcm */
2049	memcpy(&hw_params, &fe->dpcm[stream].hw_params,
2050	sizeof(struct snd_pcm_hw_params));
2051
2052	/* perform any hw_params fixups */
2053	ret = snd_soc_link_be_hw_params_fixup(rtd: be, params: &hw_params);
2054	if (ret < 0)
2055	goto unwind;
2056
2057	/* copy the fixed-up hw params for BE dai */
2058	memcpy(&be->dpcm[stream].hw_params, &hw_params,
2059	sizeof(struct snd_pcm_hw_params));
2060
2061	/* only allow hw_params() if no connected FEs are running */
2062	if (!snd_soc_dpcm_can_be_params(fe, be, stream))
2063	continue;
2064
2065	if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
2066	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
2067	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE))
2068	continue;
2069
2070	dev_dbg(be->dev, "ASoC: hw_params BE %s\n",
2071	be->dai_link->name);
2072
2073	ret = __soc_pcm_hw_params(rtd: be, substream: be_substream, params: &hw_params);
2074	if (ret < 0)
2075	goto unwind;
2076
2077	be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
2078	}
2079	return 0;
2080
2081	unwind:
2082	dev_dbg(fe->dev, "ASoC: %s() failed at %s (%d)\n",
2083	__func__, be->dai_link->name, ret);
2084
2085	/* disable any enabled and non active backends */
2086	for_each_dpcm_be_rollback(fe, stream, dpcm) {
2087	be = dpcm->be;
2088	be_substream = snd_soc_dpcm_get_substream(be, stream);
2089
2090	if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2091	continue;
2092
2093	/* only allow hw_free() if no connected FEs are running */
2094	if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
2095	continue;
2096
2097	if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
2098	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
2099	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
2100	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP))
2101	continue;
2102
2103	__soc_pcm_hw_free(rtd: be, substream: be_substream);
2104	}
2105
2106	return ret;
2107	}
2108
2109	static int dpcm_fe_dai_hw_params(struct snd_pcm_substream *substream,
2110	struct snd_pcm_hw_params *params)
2111	{
2112	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
2113	int ret, stream = substream->stream;
2114
2115	snd_soc_dpcm_mutex_lock(fe);
2116	dpcm_set_fe_update_state(fe, stream, state: SND_SOC_DPCM_UPDATE_FE);
2117
2118	memcpy(&fe->dpcm[stream].hw_params, params,
2119	sizeof(struct snd_pcm_hw_params));
2120	ret = dpcm_be_dai_hw_params(fe, stream);
2121	if (ret < 0)
2122	goto out;
2123
2124	dev_dbg(fe->dev, "ASoC: hw_params FE %s rate %d chan %x fmt %d\n",
2125	fe->dai_link->name, params_rate(params),
2126	params_channels(params), params_format(params));
2127
2128	/* call hw_params on the frontend */
2129	ret = __soc_pcm_hw_params(rtd: fe, substream, params);
2130	if (ret < 0)
2131	dpcm_be_dai_hw_free(fe, stream);
2132	else
2133	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
2134
2135	out:
2136	dpcm_set_fe_update_state(fe, stream, state: SND_SOC_DPCM_UPDATE_NO);
2137	snd_soc_dpcm_mutex_unlock(fe);
2138
2139	return soc_pcm_ret(fe, ret);
2140	}
2141
2142	int dpcm_be_dai_trigger(struct snd_soc_pcm_runtime *fe, int stream,
2143	int cmd)
2144	{
2145	struct snd_soc_pcm_runtime *be;
2146	bool pause_stop_transition;
2147	struct snd_soc_dpcm *dpcm;
2148	unsigned long flags;
2149	int ret = 0;
2150
2151	for_each_dpcm_be(fe, stream, dpcm) {
2152	struct snd_pcm_substream *be_substream;
2153
2154	be = dpcm->be;
2155	be_substream = snd_soc_dpcm_get_substream(be, stream);
2156
2157	snd_soc_dpcm_stream_lock_irqsave_nested(be, stream, flags);
2158
2159	/* is this op for this BE ? */
2160	if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2161	goto next;
2162
2163	dev_dbg(be->dev, "ASoC: trigger BE %s cmd %d\n",
2164	be->dai_link->name, cmd);
2165
2166	switch (cmd) {
2167	case SNDRV_PCM_TRIGGER_START:
2168	if (!be->dpcm[stream].be_start &&
2169	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
2170	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
2171	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2172	goto next;
2173
2174	be->dpcm[stream].be_start++;
2175	if (be->dpcm[stream].be_start != 1)
2176	goto next;
2177
2178	if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_PAUSED)
2179	ret = soc_pcm_trigger(substream: be_substream,
2180	SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
2181	else
2182	ret = soc_pcm_trigger(substream: be_substream,
2183	SNDRV_PCM_TRIGGER_START);
2184	if (ret) {
2185	be->dpcm[stream].be_start--;
2186	goto next;
2187	}
2188
2189	be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2190	break;
2191	case SNDRV_PCM_TRIGGER_RESUME:
2192	if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
2193	goto next;
2194
2195	be->dpcm[stream].be_start++;
2196	if (be->dpcm[stream].be_start != 1)
2197	goto next;
2198
2199	ret = soc_pcm_trigger(substream: be_substream, cmd);
2200	if (ret) {
2201	be->dpcm[stream].be_start--;
2202	goto next;
2203	}
2204
2205	be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2206	break;
2207	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2208	if (!be->dpcm[stream].be_start &&
2209	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) &&
2210	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2211	goto next;
2212
2213	fe->dpcm[stream].fe_pause = false;
2214	be->dpcm[stream].be_pause--;
2215
2216	be->dpcm[stream].be_start++;
2217	if (be->dpcm[stream].be_start != 1)
2218	goto next;
2219
2220	ret = soc_pcm_trigger(substream: be_substream, cmd);
2221	if (ret) {
2222	be->dpcm[stream].be_start--;
2223	goto next;
2224	}
2225
2226	be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2227	break;
2228	case SNDRV_PCM_TRIGGER_STOP:
2229	if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) &&
2230	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2231	goto next;
2232
2233	if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_START)
2234	be->dpcm[stream].be_start--;
2235
2236	if (be->dpcm[stream].be_start != 0)
2237	goto next;
2238
2239	pause_stop_transition = false;
2240	if (fe->dpcm[stream].fe_pause) {
2241	pause_stop_transition = true;
2242	fe->dpcm[stream].fe_pause = false;
2243	be->dpcm[stream].be_pause--;
2244	}
2245
2246	if (be->dpcm[stream].be_pause != 0)
2247	ret = soc_pcm_trigger(substream: be_substream, SNDRV_PCM_TRIGGER_PAUSE_PUSH);
2248	else
2249	ret = soc_pcm_trigger(substream: be_substream, SNDRV_PCM_TRIGGER_STOP);
2250
2251	if (ret) {
2252	if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_START)
2253	be->dpcm[stream].be_start++;
2254	if (pause_stop_transition) {
2255	fe->dpcm[stream].fe_pause = true;
2256	be->dpcm[stream].be_pause++;
2257	}
2258	goto next;
2259	}
2260
2261	if (be->dpcm[stream].be_pause != 0)
2262	be->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
2263	else
2264	be->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
2265
2266	break;
2267	case SNDRV_PCM_TRIGGER_SUSPEND:
2268	if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
2269	goto next;
2270
2271	be->dpcm[stream].be_start--;
2272	if (be->dpcm[stream].be_start != 0)
2273	goto next;
2274
2275	ret = soc_pcm_trigger(substream: be_substream, cmd);
2276	if (ret) {
2277	be->dpcm[stream].be_start++;
2278	goto next;
2279	}
2280
2281	be->dpcm[stream].state = SND_SOC_DPCM_STATE_SUSPEND;
2282	break;
2283	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2284	if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
2285	goto next;
2286
2287	fe->dpcm[stream].fe_pause = true;
2288	be->dpcm[stream].be_pause++;
2289
2290	be->dpcm[stream].be_start--;
2291	if (be->dpcm[stream].be_start != 0)
2292	goto next;
2293
2294	ret = soc_pcm_trigger(substream: be_substream, cmd);
2295	if (ret) {
2296	be->dpcm[stream].be_start++;
2297	goto next;
2298	}
2299
2300	be->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
2301	break;
2302	}
2303	next:
2304	snd_soc_dpcm_stream_unlock_irqrestore(be, stream, flags);
2305	if (ret)
2306	break;
2307	}
2308	return soc_pcm_ret(fe, ret);
2309	}
2310	EXPORT_SYMBOL_GPL(dpcm_be_dai_trigger);
2311
2312	static int dpcm_dai_trigger_fe_be(struct snd_pcm_substream *substream,
2313	int cmd, bool fe_first)
2314	{
2315	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
2316	int ret;
2317
2318	/* call trigger on the frontend before the backend. */
2319	if (fe_first) {
2320	dev_dbg(fe->dev, "ASoC: pre trigger FE %s cmd %d\n",
2321	fe->dai_link->name, cmd);
2322
2323	ret = soc_pcm_trigger(substream, cmd);
2324	if (ret < 0)
2325	return ret;
2326
2327	ret = dpcm_be_dai_trigger(fe, substream->stream, cmd);
2328	return ret;
2329	}
2330
2331	/* call trigger on the frontend after the backend. */
2332	ret = dpcm_be_dai_trigger(fe, substream->stream, cmd);
2333	if (ret < 0)
2334	return ret;
2335
2336	dev_dbg(fe->dev, "ASoC: post trigger FE %s cmd %d\n",
2337	fe->dai_link->name, cmd);
2338
2339	ret = soc_pcm_trigger(substream, cmd);
2340
2341	return ret;
2342	}
2343
2344	static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream *substream, int cmd)
2345	{
2346	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
2347	int stream = substream->stream;
2348	int ret = 0;
2349	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2350
2351	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
2352
2353	switch (trigger) {
2354	case SND_SOC_DPCM_TRIGGER_PRE:
2355	switch (cmd) {
2356	case SNDRV_PCM_TRIGGER_START:
2357	case SNDRV_PCM_TRIGGER_RESUME:
2358	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2359	case SNDRV_PCM_TRIGGER_DRAIN:
2360	ret = dpcm_dai_trigger_fe_be(substream, cmd, fe_first: true);
2361	break;
2362	case SNDRV_PCM_TRIGGER_STOP:
2363	case SNDRV_PCM_TRIGGER_SUSPEND:
2364	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2365	ret = dpcm_dai_trigger_fe_be(substream, cmd, fe_first: false);
2366	break;
2367	default:
2368	ret = -EINVAL;
2369	break;
2370	}
2371	break;
2372	case SND_SOC_DPCM_TRIGGER_POST:
2373	switch (cmd) {
2374	case SNDRV_PCM_TRIGGER_START:
2375	case SNDRV_PCM_TRIGGER_RESUME:
2376	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2377	case SNDRV_PCM_TRIGGER_DRAIN:
2378	ret = dpcm_dai_trigger_fe_be(substream, cmd, fe_first: false);
2379	break;
2380	case SNDRV_PCM_TRIGGER_STOP:
2381	case SNDRV_PCM_TRIGGER_SUSPEND:
2382	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2383	ret = dpcm_dai_trigger_fe_be(substream, cmd, fe_first: true);
2384	break;
2385	default:
2386	ret = -EINVAL;
2387	break;
2388	}
2389	break;
2390	case SND_SOC_DPCM_TRIGGER_BESPOKE:
2391	/* bespoke trigger() - handles both FE and BEs */
2392
2393	dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd %d\n",
2394	fe->dai_link->name, cmd);
2395
2396	ret = snd_soc_pcm_dai_bespoke_trigger(substream, cmd);
2397	break;
2398	default:
2399	dev_err(fe->dev, "ASoC: invalid trigger cmd %d for %s\n", cmd,
2400	fe->dai_link->name);
2401	ret = -EINVAL;
2402	goto out;
2403	}
2404
2405	if (ret < 0) {
2406	dev_err(fe->dev, "ASoC: trigger FE cmd: %d failed: %d\n",
2407	cmd, ret);
2408	goto out;
2409	}
2410
2411	switch (cmd) {
2412	case SNDRV_PCM_TRIGGER_START:
2413	case SNDRV_PCM_TRIGGER_RESUME:
2414	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2415	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2416	break;
2417	case SNDRV_PCM_TRIGGER_STOP:
2418	case SNDRV_PCM_TRIGGER_SUSPEND:
2419	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
2420	break;
2421	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2422	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
2423	break;
2424	}
2425
2426	out:
2427	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
2428	return ret;
2429	}
2430
2431	static int dpcm_fe_dai_trigger(struct snd_pcm_substream *substream, int cmd)
2432	{
2433	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
2434	int stream = substream->stream;
2435
2436	/* if FE's runtime_update is already set, we're in race;
2437	* process this trigger later at exit
2438	*/
2439	if (fe->dpcm[stream].runtime_update != SND_SOC_DPCM_UPDATE_NO) {
2440	fe->dpcm[stream].trigger_pending = cmd + 1;
2441	return 0; /* delayed, assuming it's successful */
2442	}
2443
2444	/* we're alone, let's trigger */
2445	return dpcm_fe_dai_do_trigger(substream, cmd);
2446	}
2447
2448	int dpcm_be_dai_prepare(struct snd_soc_pcm_runtime *fe, int stream)
2449	{
2450	struct snd_soc_dpcm *dpcm;
2451	int ret = 0;
2452
2453	for_each_dpcm_be(fe, stream, dpcm) {
2454
2455	struct snd_soc_pcm_runtime *be = dpcm->be;
2456	struct snd_pcm_substream *be_substream =
2457	snd_soc_dpcm_get_substream(be, stream);
2458
2459	/* is this op for this BE ? */
2460	if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2461	continue;
2462
2463	if (!snd_soc_dpcm_can_be_prepared(fe, be, stream))
2464	continue;
2465
2466	if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
2467	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
2468	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND) &&
2469	(be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2470	continue;
2471
2472	dev_dbg(be->dev, "ASoC: prepare BE %s\n",
2473	be->dai_link->name);
2474
2475	ret = __soc_pcm_prepare(rtd: be, substream: be_substream);
2476	if (ret < 0)
2477	break;
2478
2479	be->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
2480	}
2481
2482	return soc_pcm_ret(fe, ret);
2483	}
2484
2485	static int dpcm_fe_dai_prepare(struct snd_pcm_substream *substream)
2486	{
2487	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
2488	int stream = substream->stream, ret = 0;
2489
2490	snd_soc_dpcm_mutex_lock(fe);
2491
2492	dev_dbg(fe->dev, "ASoC: prepare FE %s\n", fe->dai_link->name);
2493
2494	dpcm_set_fe_update_state(fe, stream, state: SND_SOC_DPCM_UPDATE_FE);
2495
2496	/* there is no point preparing this FE if there are no BEs */
2497	if (list_empty(head: &fe->dpcm[stream].be_clients)) {
2498	/* dev_err_once() for visibility, dev_dbg() for debugging UCM profiles */
2499	dev_err_once(fe->dev, "ASoC: no backend DAIs enabled for %s, possibly missing ALSA mixer-based routing or UCM profile\n",
2500	fe->dai_link->name);
2501	dev_dbg(fe->dev, "ASoC: no backend DAIs enabled for %s\n",
2502	fe->dai_link->name);
2503	ret = -EINVAL;
2504	goto out;
2505	}
2506
2507	ret = dpcm_be_dai_prepare(fe, stream);
2508	if (ret < 0)
2509	goto out;
2510
2511	/* call prepare on the frontend */
2512	ret = __soc_pcm_prepare(rtd: fe, substream);
2513	if (ret < 0)
2514	goto out;
2515
2516	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
2517
2518	out:
2519	dpcm_set_fe_update_state(fe, stream, state: SND_SOC_DPCM_UPDATE_NO);
2520	snd_soc_dpcm_mutex_unlock(fe);
2521
2522	return soc_pcm_ret(fe, ret);
2523	}
2524
2525	static int dpcm_run_update_shutdown(struct snd_soc_pcm_runtime *fe, int stream)
2526	{
2527	struct snd_pcm_substream *substream =
2528	snd_soc_dpcm_get_substream(be: fe, stream);
2529	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2530	int err;
2531
2532	dev_dbg(fe->dev, "ASoC: runtime %s close on FE %s\n",
2533	stream ? "capture" : "playback", fe->dai_link->name);
2534
2535	if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) {
2536	/* call bespoke trigger - FE takes care of all BE triggers */
2537	dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd stop\n",
2538	fe->dai_link->name);
2539
2540	err = snd_soc_pcm_dai_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_STOP);
2541	} else {
2542	dev_dbg(fe->dev, "ASoC: trigger FE %s cmd stop\n",
2543	fe->dai_link->name);
2544
2545	err = dpcm_be_dai_trigger(fe, stream, SNDRV_PCM_TRIGGER_STOP);
2546	}
2547
2548	dpcm_be_dai_hw_free(fe, stream);
2549
2550	dpcm_be_dai_shutdown(fe, stream);
2551
2552	/* run the stream event for each BE */
2553	dpcm_dapm_stream_event(fe, dir: stream, SND_SOC_DAPM_STREAM_NOP);
2554
2555	return soc_pcm_ret(fe, err);
2556	}
2557
2558	static int dpcm_run_update_startup(struct snd_soc_pcm_runtime *fe, int stream)
2559	{
2560	struct snd_pcm_substream *substream =
2561	snd_soc_dpcm_get_substream(be: fe, stream);
2562	struct snd_soc_dpcm *dpcm;
2563	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2564	int ret = 0;
2565
2566	dev_dbg(fe->dev, "ASoC: runtime %s open on FE %s\n",
2567	stream ? "capture" : "playback", fe->dai_link->name);
2568
2569	/* Only start the BE if the FE is ready */
2570	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_FREE ||
2571	fe->dpcm[stream].state == SND_SOC_DPCM_STATE_CLOSE) {
2572	dev_err(fe->dev, "ASoC: FE %s is not ready %d\n",
2573	fe->dai_link->name, fe->dpcm[stream].state);
2574	ret = -EINVAL;
2575	goto disconnect;
2576	}
2577
2578	/* startup must always be called for new BEs */
2579	ret = dpcm_be_dai_startup(fe, stream);
2580	if (ret < 0)
2581	goto disconnect;
2582
2583	/* keep going if FE state is > open */
2584	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_OPEN)
2585	return 0;
2586
2587	ret = dpcm_be_dai_hw_params(fe, stream);
2588	if (ret < 0)
2589	goto close;
2590
2591	/* keep going if FE state is > hw_params */
2592	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_PARAMS)
2593	return 0;
2594
2595	ret = dpcm_be_dai_prepare(fe, stream);
2596	if (ret < 0)
2597	goto hw_free;
2598
2599	/* run the stream event for each BE */
2600	dpcm_dapm_stream_event(fe, dir: stream, SND_SOC_DAPM_STREAM_NOP);
2601
2602	/* keep going if FE state is > prepare */
2603	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_PREPARE ||
2604	fe->dpcm[stream].state == SND_SOC_DPCM_STATE_STOP)
2605	return 0;
2606
2607	if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) {
2608	/* call trigger on the frontend - FE takes care of all BE triggers */
2609	dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd start\n",
2610	fe->dai_link->name);
2611
2612	ret = snd_soc_pcm_dai_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_START);
2613	if (ret < 0)
2614	goto hw_free;
2615	} else {
2616	dev_dbg(fe->dev, "ASoC: trigger FE %s cmd start\n",
2617	fe->dai_link->name);
2618
2619	ret = dpcm_be_dai_trigger(fe, stream,
2620	SNDRV_PCM_TRIGGER_START);
2621	if (ret < 0)
2622	goto hw_free;
2623	}
2624
2625	return 0;
2626
2627	hw_free:
2628	dpcm_be_dai_hw_free(fe, stream);
2629	close:
2630	dpcm_be_dai_shutdown(fe, stream);
2631	disconnect:
2632	/* disconnect any pending BEs */
2633	for_each_dpcm_be(fe, stream, dpcm) {
2634	struct snd_soc_pcm_runtime *be = dpcm->be;
2635
2636	/* is this op for this BE ? */
2637	if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2638	continue;
2639
2640	if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_CLOSE ||
2641	be->dpcm[stream].state == SND_SOC_DPCM_STATE_NEW)
2642	dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
2643	}
2644
2645	return soc_pcm_ret(fe, ret);
2646	}
2647
2648	static int soc_dpcm_fe_runtime_update(struct snd_soc_pcm_runtime *fe, int new)
2649	{
2650	struct snd_soc_dapm_widget_list *list;
2651	int stream;
2652	int count, paths;
2653
2654	if (!fe->dai_link->dynamic)
2655	return 0;
2656
2657	if (fe->dai_link->num_cpus > 1) {
2658	dev_err(fe->dev,
2659	"%s doesn't support Multi CPU yet\n", __func__);
2660	return -EINVAL;
2661	}
2662
2663	/* only check active links */
2664	if (!snd_soc_dai_active(snd_soc_rtd_to_cpu(fe, 0)))
2665	return 0;
2666
2667	/* DAPM sync will call this to update DSP paths */
2668	dev_dbg(fe->dev, "ASoC: DPCM %s runtime update for FE %s\n",
2669	new ? "new" : "old", fe->dai_link->name);
2670
2671	for_each_pcm_streams(stream) {
2672
2673	/* skip if FE doesn't have playback/capture capability */
2674	if (!snd_soc_dai_stream_valid(snd_soc_rtd_to_cpu(fe, 0), stream) ||
2675	!snd_soc_dai_stream_valid(snd_soc_rtd_to_codec(fe, 0), stream))
2676	continue;
2677
2678	/* skip if FE isn't currently playing/capturing */
2679	if (!snd_soc_dai_stream_active(snd_soc_rtd_to_cpu(fe, 0), stream) ||
2680	!snd_soc_dai_stream_active(snd_soc_rtd_to_codec(fe, 0), stream))
2681	continue;
2682
2683	paths = dpcm_path_get(fe, stream, list: &list);
2684	if (paths < 0)
2685	return paths;
2686
2687	/* update any playback/capture paths */
2688	count = dpcm_process_paths(fe, stream, list: &list, new);
2689	if (count) {
2690	dpcm_set_fe_update_state(fe, stream, state: SND_SOC_DPCM_UPDATE_BE);
2691	if (new)
2692	dpcm_run_update_startup(fe, stream);
2693	else
2694	dpcm_run_update_shutdown(fe, stream);
2695	dpcm_set_fe_update_state(fe, stream, state: SND_SOC_DPCM_UPDATE_NO);
2696
2697	dpcm_clear_pending_state(fe, stream);
2698	dpcm_be_disconnect(fe, stream);
2699	}
2700
2701	dpcm_path_put(list: &list);
2702	}
2703
2704	return 0;
2705	}
2706
2707	/* Called by DAPM mixer/mux changes to update audio routing between PCMs and
2708	* any DAI links.
2709	*/
2710	int snd_soc_dpcm_runtime_update(struct snd_soc_card *card)
2711	{
2712	struct snd_soc_pcm_runtime *fe;
2713	int ret = 0;
2714
2715	snd_soc_dpcm_mutex_lock(card);
2716	/* shutdown all old paths first */
2717	for_each_card_rtds(card, fe) {
2718	ret = soc_dpcm_fe_runtime_update(fe, new: 0);
2719	if (ret)
2720	goto out;
2721	}
2722
2723	/* bring new paths up */
2724	for_each_card_rtds(card, fe) {
2725	ret = soc_dpcm_fe_runtime_update(fe, new: 1);
2726	if (ret)
2727	goto out;
2728	}
2729
2730	out:
2731	snd_soc_dpcm_mutex_unlock(card);
2732	return ret;
2733	}
2734	EXPORT_SYMBOL_GPL(snd_soc_dpcm_runtime_update);
2735
2736	static void dpcm_fe_dai_cleanup(struct snd_pcm_substream *fe_substream)
2737	{
2738	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(fe_substream);
2739	struct snd_soc_dpcm *dpcm;
2740	int stream = fe_substream->stream;
2741
2742	snd_soc_dpcm_mutex_assert_held(fe);
2743
2744	/* mark FE's links ready to prune */
2745	for_each_dpcm_be(fe, stream, dpcm)
2746	dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
2747
2748	dpcm_be_disconnect(fe, stream);
2749	}
2750
2751	static int dpcm_fe_dai_close(struct snd_pcm_substream *fe_substream)
2752	{
2753	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(fe_substream);
2754	int ret;
2755
2756	snd_soc_dpcm_mutex_lock(fe);
2757	ret = dpcm_fe_dai_shutdown(substream: fe_substream);
2758
2759	dpcm_fe_dai_cleanup(fe_substream);
2760
2761	snd_soc_dpcm_mutex_unlock(fe);
2762	return ret;
2763	}
2764
2765	static int dpcm_fe_dai_open(struct snd_pcm_substream *fe_substream)
2766	{
2767	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(fe_substream);
2768	struct snd_soc_dapm_widget_list *list;
2769	int ret;
2770	int stream = fe_substream->stream;
2771
2772	snd_soc_dpcm_mutex_lock(fe);
2773
2774	ret = dpcm_path_get(fe, stream, list: &list);
2775	if (ret < 0)
2776	goto open_end;
2777
2778	/* calculate valid and active FE <-> BE dpcms */
2779	dpcm_process_paths(fe, stream, list: &list, new: 1);
2780
2781	ret = dpcm_fe_dai_startup(fe_substream);
2782	if (ret < 0)
2783	dpcm_fe_dai_cleanup(fe_substream);
2784
2785	dpcm_clear_pending_state(fe, stream);
2786	dpcm_path_put(list: &list);
2787	open_end:
2788	snd_soc_dpcm_mutex_unlock(fe);
2789	return ret;
2790	}
2791
2792	static int soc_get_playback_capture(struct snd_soc_pcm_runtime *rtd,
2793	int *playback, int *capture)
2794	{
2795	struct snd_soc_dai_link *dai_link = rtd->dai_link;
2796	struct snd_soc_dai *cpu_dai;
2797	int has_playback = 0;
2798	int has_capture = 0;
2799	int i;
2800
2801	if (dai_link->dynamic && dai_link->num_cpus > 1) {
2802	dev_err(rtd->dev, "DPCM doesn't support Multi CPU for Front-Ends yet\n");
2803	return -EINVAL;
2804	}
2805
2806	if (dai_link->dynamic || dai_link->no_pcm) {
2807	int stream;
2808
2809	if (dai_link->dpcm_playback) {
2810	stream = SNDRV_PCM_STREAM_PLAYBACK;
2811
2812	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
2813	if (snd_soc_dai_stream_valid(dai: cpu_dai, stream)) {
2814	has_playback = 1;
2815	break;
2816	}
2817	}
2818	if (!has_playback) {
2819	dev_err(rtd->card->dev,
2820	"No CPU DAIs support playback for stream %s\n",
2821	dai_link->stream_name);
2822	return -EINVAL;
2823	}
2824	}
2825	if (dai_link->dpcm_capture) {
2826	stream = SNDRV_PCM_STREAM_CAPTURE;
2827
2828	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
2829	if (snd_soc_dai_stream_valid(dai: cpu_dai, stream)) {
2830	has_capture = 1;
2831	break;
2832	}
2833	}
2834
2835	if (!has_capture) {
2836	dev_err(rtd->card->dev,
2837	"No CPU DAIs support capture for stream %s\n",
2838	dai_link->stream_name);
2839	return -EINVAL;
2840	}
2841	}
2842	} else {
2843	struct snd_soc_dai_link_ch_map *ch_maps;
2844	struct snd_soc_dai *codec_dai;
2845
2846	/* Adapt stream for codec2codec links */
2847	int cpu_capture = snd_soc_get_stream_cpu(dai_link, stream: SNDRV_PCM_STREAM_CAPTURE);
2848	int cpu_playback = snd_soc_get_stream_cpu(dai_link, stream: SNDRV_PCM_STREAM_PLAYBACK);
2849
2850	/*
2851	* see
2852	* soc.h :: [dai_link->ch_maps Image sample]
2853	*/
2854	for_each_rtd_ch_maps(rtd, i, ch_maps) {
2855	cpu_dai = snd_soc_rtd_to_cpu(rtd, ch_maps->cpu);
2856	codec_dai = snd_soc_rtd_to_codec(rtd, ch_maps->codec);
2857
2858	if (snd_soc_dai_stream_valid(dai: codec_dai, stream: SNDRV_PCM_STREAM_PLAYBACK) &&
2859	snd_soc_dai_stream_valid(dai: cpu_dai, stream: cpu_playback))
2860	has_playback = 1;
2861	if (snd_soc_dai_stream_valid(dai: codec_dai, stream: SNDRV_PCM_STREAM_CAPTURE) &&
2862	snd_soc_dai_stream_valid(dai: cpu_dai, stream: cpu_capture))
2863	has_capture = 1;
2864	}
2865	}
2866
2867	if (dai_link->playback_only)
2868	has_capture = 0;
2869
2870	if (dai_link->capture_only)
2871	has_playback = 0;
2872
2873	if (!has_playback && !has_capture) {
2874	dev_err(rtd->dev, "substream %s has no playback, no capture\n",
2875	dai_link->stream_name);
2876
2877	return -EINVAL;
2878	}
2879
2880	*playback = has_playback;
2881	*capture = has_capture;
2882
2883	return 0;
2884	}
2885
2886	static int soc_create_pcm(struct snd_pcm **pcm,
2887	struct snd_soc_pcm_runtime *rtd,
2888	int playback, int capture, int num)
2889	{
2890	char new_name[64];
2891	int ret;
2892
2893	/* create the PCM */
2894	if (rtd->dai_link->c2c_params) {
2895	snprintf(buf: new_name, size: sizeof(new_name), fmt: "codec2codec(%s)",
2896	rtd->dai_link->stream_name);
2897
2898	ret = snd_pcm_new_internal(card: rtd->card->snd_card, id: new_name, device: num,
2899	playback_count: playback, capture_count: capture, rpcm: pcm);
2900	} else if (rtd->dai_link->no_pcm) {
2901	snprintf(buf: new_name, size: sizeof(new_name), fmt: "(%s)",
2902	rtd->dai_link->stream_name);
2903
2904	ret = snd_pcm_new_internal(card: rtd->card->snd_card, id: new_name, device: num,
2905	playback_count: playback, capture_count: capture, rpcm: pcm);
2906	} else {
2907	if (rtd->dai_link->dynamic)
2908	snprintf(buf: new_name, size: sizeof(new_name), fmt: "%s (*)",
2909	rtd->dai_link->stream_name);
2910	else
2911	snprintf(buf: new_name, size: sizeof(new_name), fmt: "%s %s-%d",
2912	rtd->dai_link->stream_name,
2913	soc_codec_dai_name(rtd), num);
2914
2915	ret = snd_pcm_new(card: rtd->card->snd_card, id: new_name, device: num, playback_count: playback,
2916	capture_count: capture, rpcm: pcm);
2917	}
2918	if (ret < 0) {
2919	dev_err(rtd->card->dev, "ASoC: can't create pcm %s for dailink %s: %d\n",
2920	new_name, rtd->dai_link->name, ret);
2921	return ret;
2922	}
2923	dev_dbg(rtd->card->dev, "ASoC: registered pcm #%d %s\n",num, new_name);
2924
2925	return 0;
2926	}
2927
2928	/* create a new pcm */
2929	int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
2930	{
2931	struct snd_soc_component *component;
2932	struct snd_pcm *pcm;
2933	int ret = 0, playback = 0, capture = 0;
2934	int i;
2935
2936	ret = soc_get_playback_capture(rtd, playback: &playback, capture: &capture);
2937	if (ret < 0)
2938	return ret;
2939
2940	ret = soc_create_pcm(pcm: &pcm, rtd, playback, capture, num);
2941	if (ret < 0)
2942	return ret;
2943
2944	/* DAPM dai link stream work */
2945	/*
2946	* Currently nothing to do for c2c links
2947	* Since c2c links are internal nodes in the DAPM graph and
2948	* don't interface with the outside world or application layer
2949	* we don't have to do any special handling on close.
2950	*/
2951	if (!rtd->dai_link->c2c_params)
2952	rtd->close_delayed_work_func = snd_soc_close_delayed_work;
2953
2954	rtd->pcm = pcm;
2955	pcm->nonatomic = rtd->dai_link->nonatomic;
2956	pcm->private_data = rtd;
2957	pcm->no_device_suspend = true;
2958
2959	if (rtd->dai_link->no_pcm || rtd->dai_link->c2c_params) {
2960	if (playback)
2961	pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
2962	if (capture)
2963	pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
2964	goto out;
2965	}
2966
2967	/* ASoC PCM operations */
2968	if (rtd->dai_link->dynamic) {
2969	rtd->ops.open = dpcm_fe_dai_open;
2970	rtd->ops.hw_params = dpcm_fe_dai_hw_params;
2971	rtd->ops.prepare = dpcm_fe_dai_prepare;
2972	rtd->ops.trigger = dpcm_fe_dai_trigger;
2973	rtd->ops.hw_free = dpcm_fe_dai_hw_free;
2974	rtd->ops.close = dpcm_fe_dai_close;
2975	rtd->ops.pointer = soc_pcm_pointer;
2976	} else {
2977	rtd->ops.open = soc_pcm_open;
2978	rtd->ops.hw_params = soc_pcm_hw_params;
2979	rtd->ops.prepare = soc_pcm_prepare;
2980	rtd->ops.trigger = soc_pcm_trigger;
2981	rtd->ops.hw_free = soc_pcm_hw_free;
2982	rtd->ops.close = soc_pcm_close;
2983	rtd->ops.pointer = soc_pcm_pointer;
2984	}
2985
2986	for_each_rtd_components(rtd, i, component) {
2987	const struct snd_soc_component_driver *drv = component->driver;
2988
2989	if (drv->ioctl)
2990	rtd->ops.ioctl = snd_soc_pcm_component_ioctl;
2991	if (drv->sync_stop)
2992	rtd->ops.sync_stop = snd_soc_pcm_component_sync_stop;
2993	if (drv->copy)
2994	rtd->ops.copy = snd_soc_pcm_component_copy;
2995	if (drv->page)
2996	rtd->ops.page = snd_soc_pcm_component_page;
2997	if (drv->mmap)
2998	rtd->ops.mmap = snd_soc_pcm_component_mmap;
2999	if (drv->ack)
3000	rtd->ops.ack = snd_soc_pcm_component_ack;
3001	}
3002
3003	if (playback)
3004	snd_pcm_set_ops(pcm, direction: SNDRV_PCM_STREAM_PLAYBACK, ops: &rtd->ops);
3005
3006	if (capture)
3007	snd_pcm_set_ops(pcm, direction: SNDRV_PCM_STREAM_CAPTURE, ops: &rtd->ops);
3008
3009	ret = snd_soc_pcm_component_new(rtd);
3010	if (ret < 0)
3011	return ret;
3012	out:
3013	dev_dbg(rtd->card->dev, "%s <-> %s mapping ok\n",
3014	soc_codec_dai_name(rtd), soc_cpu_dai_name(rtd));
3015	return ret;
3016	}
3017
3018	/* is the current PCM operation for this FE ? */
3019	int snd_soc_dpcm_fe_can_update(struct snd_soc_pcm_runtime *fe, int stream)
3020	{
3021	if (fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE)
3022	return 1;
3023	return 0;
3024	}
3025	EXPORT_SYMBOL_GPL(snd_soc_dpcm_fe_can_update);
3026
3027	/* is the current PCM operation for this BE ? */
3028	int snd_soc_dpcm_be_can_update(struct snd_soc_pcm_runtime *fe,
3029	struct snd_soc_pcm_runtime *be, int stream)
3030	{
3031	if ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE) ||
3032	((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_BE) &&
3033	be->dpcm[stream].runtime_update))
3034	return 1;
3035	return 0;
3036	}
3037	EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_can_update);
3038
3039	/* get the substream for this BE */
3040	struct snd_pcm_substream *
3041	snd_soc_dpcm_get_substream(struct snd_soc_pcm_runtime *be, int stream)
3042	{
3043	return be->pcm->streams[stream].substream;
3044	}
3045	EXPORT_SYMBOL_GPL(snd_soc_dpcm_get_substream);
3046
3047	static int snd_soc_dpcm_check_state(struct snd_soc_pcm_runtime *fe,
3048	struct snd_soc_pcm_runtime *be,
3049	int stream,
3050	const enum snd_soc_dpcm_state *states,
3051	int num_states)
3052	{
3053	struct snd_soc_dpcm *dpcm;
3054	int state;
3055	int ret = 1;
3056	int i;
3057
3058	for_each_dpcm_fe(be, stream, dpcm) {
3059
3060	if (dpcm->fe == fe)
3061	continue;
3062
3063	state = dpcm->fe->dpcm[stream].state;
3064	for (i = 0; i < num_states; i++) {
3065	if (state == states[i]) {
3066	ret = 0;
3067	break;
3068	}
3069	}
3070	}
3071
3072	/* it's safe to do this BE DAI */
3073	return ret;
3074	}
3075
3076	/*
3077	* We can only hw_free, stop, pause or suspend a BE DAI if any of it's FE
3078	* are not running, paused or suspended for the specified stream direction.
3079	*/
3080	int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime *fe,
3081	struct snd_soc_pcm_runtime *be, int stream)
3082	{
3083	const enum snd_soc_dpcm_state state[] = {
3084	SND_SOC_DPCM_STATE_START,
3085	SND_SOC_DPCM_STATE_PAUSED,
3086	SND_SOC_DPCM_STATE_SUSPEND,
3087	};
3088
3089	return snd_soc_dpcm_check_state(fe, be, stream, states: state, ARRAY_SIZE(state));
3090	}
3091	EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop);
3092
3093	/*
3094	* We can only change hw params a BE DAI if any of it's FE are not prepared,
3095	* running, paused or suspended for the specified stream direction.
3096	*/
3097	int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime *fe,
3098	struct snd_soc_pcm_runtime *be, int stream)
3099	{
3100	const enum snd_soc_dpcm_state state[] = {
3101	SND_SOC_DPCM_STATE_START,
3102	SND_SOC_DPCM_STATE_PAUSED,
3103	SND_SOC_DPCM_STATE_SUSPEND,
3104	SND_SOC_DPCM_STATE_PREPARE,
3105	};
3106
3107	return snd_soc_dpcm_check_state(fe, be, stream, states: state, ARRAY_SIZE(state));
3108	}
3109	EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params);
3110
3111	/*
3112	* We can only prepare a BE DAI if any of it's FE are not prepared,
3113	* running or paused for the specified stream direction.
3114	*/
3115	int snd_soc_dpcm_can_be_prepared(struct snd_soc_pcm_runtime *fe,
3116	struct snd_soc_pcm_runtime *be, int stream)
3117	{
3118	const enum snd_soc_dpcm_state state[] = {
3119	SND_SOC_DPCM_STATE_START,
3120	SND_SOC_DPCM_STATE_PAUSED,
3121	SND_SOC_DPCM_STATE_PREPARE,
3122	};
3123
3124	return snd_soc_dpcm_check_state(fe, be, stream, states: state, ARRAY_SIZE(state));
3125	}
3126	EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_prepared);
3127