xref: /openbmc/linux/sound/soc/soc-pcm.c (revision ab49436eecf5cc779a1ff659ba59c88779685b47)
1ed517582SKuninori Morimoto // SPDX-License-Identifier: GPL-2.0+
2ed517582SKuninori Morimoto //
3ed517582SKuninori Morimoto // soc-pcm.c  --  ALSA SoC PCM
4ed517582SKuninori Morimoto //
5ed517582SKuninori Morimoto // Copyright 2005 Wolfson Microelectronics PLC.
6ed517582SKuninori Morimoto // Copyright 2005 Openedhand Ltd.
7ed517582SKuninori Morimoto // Copyright (C) 2010 Slimlogic Ltd.
8ed517582SKuninori Morimoto // Copyright (C) 2010 Texas Instruments Inc.
9ed517582SKuninori Morimoto //
10ed517582SKuninori Morimoto // Authors: Liam Girdwood <lrg@ti.com>
11ed517582SKuninori Morimoto //          Mark Brown <broonie@opensource.wolfsonmicro.com>
12ddee627cSLiam Girdwood 
13ddee627cSLiam Girdwood #include <linux/kernel.h>
14ddee627cSLiam Girdwood #include <linux/init.h>
15ddee627cSLiam Girdwood #include <linux/delay.h>
16988e8cc4SNicolin Chen #include <linux/pinctrl/consumer.h>
17d6652ef8SMark Brown #include <linux/pm_runtime.h>
18ddee627cSLiam Girdwood #include <linux/slab.h>
19ddee627cSLiam Girdwood #include <linux/workqueue.h>
2001d7584cSLiam Girdwood #include <linux/export.h>
21f86dcef8SLiam Girdwood #include <linux/debugfs.h>
22ddee627cSLiam Girdwood #include <sound/core.h>
23ddee627cSLiam Girdwood #include <sound/pcm.h>
24ddee627cSLiam Girdwood #include <sound/pcm_params.h>
25ddee627cSLiam Girdwood #include <sound/soc.h>
2601d7584cSLiam Girdwood #include <sound/soc-dpcm.h>
27a5e6c109SKuninori Morimoto #include <sound/soc-link.h>
28ddee627cSLiam Girdwood #include <sound/initval.h>
29ddee627cSLiam Girdwood 
3001d7584cSLiam Girdwood #define DPCM_MAX_BE_USERS	8
3101d7584cSLiam Girdwood 
32c3212829SKuninori Morimoto #ifdef CONFIG_DEBUG_FS
33c3212829SKuninori Morimoto static const char *dpcm_state_string(enum snd_soc_dpcm_state state)
34c3212829SKuninori Morimoto {
35c3212829SKuninori Morimoto 	switch (state) {
36c3212829SKuninori Morimoto 	case SND_SOC_DPCM_STATE_NEW:
37c3212829SKuninori Morimoto 		return "new";
38c3212829SKuninori Morimoto 	case SND_SOC_DPCM_STATE_OPEN:
39c3212829SKuninori Morimoto 		return "open";
40c3212829SKuninori Morimoto 	case SND_SOC_DPCM_STATE_HW_PARAMS:
41c3212829SKuninori Morimoto 		return "hw_params";
42c3212829SKuninori Morimoto 	case SND_SOC_DPCM_STATE_PREPARE:
43c3212829SKuninori Morimoto 		return "prepare";
44c3212829SKuninori Morimoto 	case SND_SOC_DPCM_STATE_START:
45c3212829SKuninori Morimoto 		return "start";
46c3212829SKuninori Morimoto 	case SND_SOC_DPCM_STATE_STOP:
47c3212829SKuninori Morimoto 		return "stop";
48c3212829SKuninori Morimoto 	case SND_SOC_DPCM_STATE_SUSPEND:
49c3212829SKuninori Morimoto 		return "suspend";
50c3212829SKuninori Morimoto 	case SND_SOC_DPCM_STATE_PAUSED:
51c3212829SKuninori Morimoto 		return "paused";
52c3212829SKuninori Morimoto 	case SND_SOC_DPCM_STATE_HW_FREE:
53c3212829SKuninori Morimoto 		return "hw_free";
54c3212829SKuninori Morimoto 	case SND_SOC_DPCM_STATE_CLOSE:
55c3212829SKuninori Morimoto 		return "close";
56c3212829SKuninori Morimoto 	}
57c3212829SKuninori Morimoto 
58c3212829SKuninori Morimoto 	return "unknown";
59c3212829SKuninori Morimoto }
60c3212829SKuninori Morimoto 
61c3212829SKuninori Morimoto static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe,
62c3212829SKuninori Morimoto 			       int stream, char *buf, size_t size)
63c3212829SKuninori Morimoto {
64c3212829SKuninori Morimoto 	struct snd_pcm_hw_params *params = &fe->dpcm[stream].hw_params;
65c3212829SKuninori Morimoto 	struct snd_soc_dpcm *dpcm;
66c3212829SKuninori Morimoto 	ssize_t offset = 0;
67c3212829SKuninori Morimoto 	unsigned long flags;
68c3212829SKuninori Morimoto 
69c3212829SKuninori Morimoto 	/* FE state */
70d0c9abb8STakashi Iwai 	offset += scnprintf(buf + offset, size - offset,
71c3212829SKuninori Morimoto 			   "[%s - %s]\n", fe->dai_link->name,
72c3212829SKuninori Morimoto 			   stream ? "Capture" : "Playback");
73c3212829SKuninori Morimoto 
74d0c9abb8STakashi Iwai 	offset += scnprintf(buf + offset, size - offset, "State: %s\n",
75c3212829SKuninori Morimoto 			   dpcm_state_string(fe->dpcm[stream].state));
76c3212829SKuninori Morimoto 
77c3212829SKuninori Morimoto 	if ((fe->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
78c3212829SKuninori Morimoto 	    (fe->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
79d0c9abb8STakashi Iwai 		offset += scnprintf(buf + offset, size - offset,
80c3212829SKuninori Morimoto 				   "Hardware Params: "
81c3212829SKuninori Morimoto 				   "Format = %s, Channels = %d, Rate = %d\n",
82c3212829SKuninori Morimoto 				   snd_pcm_format_name(params_format(params)),
83c3212829SKuninori Morimoto 				   params_channels(params),
84c3212829SKuninori Morimoto 				   params_rate(params));
85c3212829SKuninori Morimoto 
86c3212829SKuninori Morimoto 	/* BEs state */
87d0c9abb8STakashi Iwai 	offset += scnprintf(buf + offset, size - offset, "Backends:\n");
88c3212829SKuninori Morimoto 
89c3212829SKuninori Morimoto 	if (list_empty(&fe->dpcm[stream].be_clients)) {
90d0c9abb8STakashi Iwai 		offset += scnprintf(buf + offset, size - offset,
91c3212829SKuninori Morimoto 				   " No active DSP links\n");
92c3212829SKuninori Morimoto 		goto out;
93c3212829SKuninori Morimoto 	}
94c3212829SKuninori Morimoto 
95c3212829SKuninori Morimoto 	spin_lock_irqsave(&fe->card->dpcm_lock, flags);
96c3212829SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
97c3212829SKuninori Morimoto 		struct snd_soc_pcm_runtime *be = dpcm->be;
98c3212829SKuninori Morimoto 		params = &dpcm->hw_params;
99c3212829SKuninori Morimoto 
100d0c9abb8STakashi Iwai 		offset += scnprintf(buf + offset, size - offset,
101c3212829SKuninori Morimoto 				   "- %s\n", be->dai_link->name);
102c3212829SKuninori Morimoto 
103d0c9abb8STakashi Iwai 		offset += scnprintf(buf + offset, size - offset,
104c3212829SKuninori Morimoto 				   "   State: %s\n",
105c3212829SKuninori Morimoto 				   dpcm_state_string(be->dpcm[stream].state));
106c3212829SKuninori Morimoto 
107c3212829SKuninori Morimoto 		if ((be->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
108c3212829SKuninori Morimoto 		    (be->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
109d0c9abb8STakashi Iwai 			offset += scnprintf(buf + offset, size - offset,
110c3212829SKuninori Morimoto 					   "   Hardware Params: "
111c3212829SKuninori Morimoto 					   "Format = %s, Channels = %d, Rate = %d\n",
112c3212829SKuninori Morimoto 					   snd_pcm_format_name(params_format(params)),
113c3212829SKuninori Morimoto 					   params_channels(params),
114c3212829SKuninori Morimoto 					   params_rate(params));
115c3212829SKuninori Morimoto 	}
116c3212829SKuninori Morimoto 	spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
117c3212829SKuninori Morimoto out:
118c3212829SKuninori Morimoto 	return offset;
119c3212829SKuninori Morimoto }
120c3212829SKuninori Morimoto 
121c3212829SKuninori Morimoto static ssize_t dpcm_state_read_file(struct file *file, char __user *user_buf,
122c3212829SKuninori Morimoto 				    size_t count, loff_t *ppos)
123c3212829SKuninori Morimoto {
124c3212829SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = file->private_data;
125c3212829SKuninori Morimoto 	ssize_t out_count = PAGE_SIZE, offset = 0, ret = 0;
126c3212829SKuninori Morimoto 	int stream;
127c3212829SKuninori Morimoto 	char *buf;
128c3212829SKuninori Morimoto 
1296e1276a5SBard Liao 	if (fe->num_cpus > 1) {
1306e1276a5SBard Liao 		dev_err(fe->dev,
1316e1276a5SBard Liao 			"%s doesn't support Multi CPU yet\n", __func__);
1326e1276a5SBard Liao 		return -EINVAL;
1336e1276a5SBard Liao 	}
1346e1276a5SBard Liao 
135c3212829SKuninori Morimoto 	buf = kmalloc(out_count, GFP_KERNEL);
136c3212829SKuninori Morimoto 	if (!buf)
137c3212829SKuninori Morimoto 		return -ENOMEM;
138c3212829SKuninori Morimoto 
139c3212829SKuninori Morimoto 	for_each_pcm_streams(stream)
140c2233a26SKuninori Morimoto 		if (snd_soc_dai_stream_valid(asoc_rtd_to_cpu(fe, 0), stream))
141c3212829SKuninori Morimoto 			offset += dpcm_show_state(fe, stream,
142c3212829SKuninori Morimoto 						  buf + offset,
143c3212829SKuninori Morimoto 						  out_count - offset);
144c3212829SKuninori Morimoto 
145c3212829SKuninori Morimoto 	ret = simple_read_from_buffer(user_buf, count, ppos, buf, offset);
146c3212829SKuninori Morimoto 
147c3212829SKuninori Morimoto 	kfree(buf);
148c3212829SKuninori Morimoto 	return ret;
149c3212829SKuninori Morimoto }
150c3212829SKuninori Morimoto 
151c3212829SKuninori Morimoto static const struct file_operations dpcm_state_fops = {
152c3212829SKuninori Morimoto 	.open = simple_open,
153c3212829SKuninori Morimoto 	.read = dpcm_state_read_file,
154c3212829SKuninori Morimoto 	.llseek = default_llseek,
155c3212829SKuninori Morimoto };
156c3212829SKuninori Morimoto 
157c3212829SKuninori Morimoto void soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd)
158c3212829SKuninori Morimoto {
159c3212829SKuninori Morimoto 	if (!rtd->dai_link)
160c3212829SKuninori Morimoto 		return;
161c3212829SKuninori Morimoto 
162c3212829SKuninori Morimoto 	if (!rtd->dai_link->dynamic)
163c3212829SKuninori Morimoto 		return;
164c3212829SKuninori Morimoto 
165c3212829SKuninori Morimoto 	if (!rtd->card->debugfs_card_root)
166c3212829SKuninori Morimoto 		return;
167c3212829SKuninori Morimoto 
168c3212829SKuninori Morimoto 	rtd->debugfs_dpcm_root = debugfs_create_dir(rtd->dai_link->name,
169c3212829SKuninori Morimoto 						    rtd->card->debugfs_card_root);
170c3212829SKuninori Morimoto 
171c3212829SKuninori Morimoto 	debugfs_create_file("state", 0444, rtd->debugfs_dpcm_root,
172c3212829SKuninori Morimoto 			    rtd, &dpcm_state_fops);
173c3212829SKuninori Morimoto }
174154dae87SKuninori Morimoto 
175154dae87SKuninori Morimoto static void dpcm_create_debugfs_state(struct snd_soc_dpcm *dpcm, int stream)
176154dae87SKuninori Morimoto {
177154dae87SKuninori Morimoto 	char *name;
178154dae87SKuninori Morimoto 
179154dae87SKuninori Morimoto 	name = kasprintf(GFP_KERNEL, "%s:%s", dpcm->be->dai_link->name,
180154dae87SKuninori Morimoto 			 stream ? "capture" : "playback");
181154dae87SKuninori Morimoto 	if (name) {
182154dae87SKuninori Morimoto 		dpcm->debugfs_state = debugfs_create_dir(
183154dae87SKuninori Morimoto 			name, dpcm->fe->debugfs_dpcm_root);
184154dae87SKuninori Morimoto 		debugfs_create_u32("state", 0644, dpcm->debugfs_state,
185154dae87SKuninori Morimoto 				   &dpcm->state);
186154dae87SKuninori Morimoto 		kfree(name);
187154dae87SKuninori Morimoto 	}
188154dae87SKuninori Morimoto }
189154dae87SKuninori Morimoto 
190154dae87SKuninori Morimoto static void dpcm_remove_debugfs_state(struct snd_soc_dpcm *dpcm)
191154dae87SKuninori Morimoto {
192154dae87SKuninori Morimoto 	debugfs_remove_recursive(dpcm->debugfs_state);
193154dae87SKuninori Morimoto }
194154dae87SKuninori Morimoto 
195154dae87SKuninori Morimoto #else
196154dae87SKuninori Morimoto static inline void dpcm_create_debugfs_state(struct snd_soc_dpcm *dpcm,
197154dae87SKuninori Morimoto 					     int stream)
198154dae87SKuninori Morimoto {
199154dae87SKuninori Morimoto }
200154dae87SKuninori Morimoto 
201154dae87SKuninori Morimoto static inline void dpcm_remove_debugfs_state(struct snd_soc_dpcm *dpcm)
202154dae87SKuninori Morimoto {
203154dae87SKuninori Morimoto }
204c3212829SKuninori Morimoto #endif
205c3212829SKuninori Morimoto 
206d9051d86SKuninori Morimoto /**
207d9051d86SKuninori Morimoto  * snd_soc_runtime_action() - Increment/Decrement active count for
208d9051d86SKuninori Morimoto  * PCM runtime components
209d9051d86SKuninori Morimoto  * @rtd: ASoC PCM runtime that is activated
210d9051d86SKuninori Morimoto  * @stream: Direction of the PCM stream
211b6d6e9eaSColton Lewis  * @action: Activate stream if 1. Deactivate if -1.
212d9051d86SKuninori Morimoto  *
213d9051d86SKuninori Morimoto  * Increments/Decrements the active count for all the DAIs and components
214d9051d86SKuninori Morimoto  * attached to a PCM runtime.
215d9051d86SKuninori Morimoto  * Should typically be called when a stream is opened.
216d9051d86SKuninori Morimoto  *
217d9051d86SKuninori Morimoto  * Must be called with the rtd->card->pcm_mutex being held
218d9051d86SKuninori Morimoto  */
219d9051d86SKuninori Morimoto void snd_soc_runtime_action(struct snd_soc_pcm_runtime *rtd,
2207a5aaba4SKuninori Morimoto 			    int stream, int action)
2217a5aaba4SKuninori Morimoto {
222c840f769SKuninori Morimoto 	struct snd_soc_dai *dai;
2237a5aaba4SKuninori Morimoto 	int i;
2247a5aaba4SKuninori Morimoto 
2257a5aaba4SKuninori Morimoto 	lockdep_assert_held(&rtd->card->pcm_mutex);
2267a5aaba4SKuninori Morimoto 
227dc829106SKuninori Morimoto 	for_each_rtd_dais(rtd, i, dai)
228dc829106SKuninori Morimoto 		snd_soc_dai_action(dai, stream, action);
2297a5aaba4SKuninori Morimoto }
230d9051d86SKuninori Morimoto EXPORT_SYMBOL_GPL(snd_soc_runtime_action);
23124894b76SLars-Peter Clausen 
23224894b76SLars-Peter Clausen /**
233208a1589SLars-Peter Clausen  * snd_soc_runtime_ignore_pmdown_time() - Check whether to ignore the power down delay
234208a1589SLars-Peter Clausen  * @rtd: The ASoC PCM runtime that should be checked.
235208a1589SLars-Peter Clausen  *
236208a1589SLars-Peter Clausen  * This function checks whether the power down delay should be ignored for a
237208a1589SLars-Peter Clausen  * specific PCM runtime. Returns true if the delay is 0, if it the DAI link has
238208a1589SLars-Peter Clausen  * been configured to ignore the delay, or if none of the components benefits
239208a1589SLars-Peter Clausen  * from having the delay.
240208a1589SLars-Peter Clausen  */
241208a1589SLars-Peter Clausen bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd)
242208a1589SLars-Peter Clausen {
243fbb16563SKuninori Morimoto 	struct snd_soc_component *component;
2442e5894d7SBenoit Cousson 	bool ignore = true;
245613fb500SKuninori Morimoto 	int i;
2462e5894d7SBenoit Cousson 
247208a1589SLars-Peter Clausen 	if (!rtd->pmdown_time || rtd->dai_link->ignore_pmdown_time)
248208a1589SLars-Peter Clausen 		return true;
249208a1589SLars-Peter Clausen 
250613fb500SKuninori Morimoto 	for_each_rtd_components(rtd, i, component)
25172c38184SKuninori Morimoto 		ignore &= !component->driver->use_pmdown_time;
252fbb16563SKuninori Morimoto 
253fbb16563SKuninori Morimoto 	return ignore;
254208a1589SLars-Peter Clausen }
255208a1589SLars-Peter Clausen 
256208a1589SLars-Peter Clausen /**
25790996f43SLars-Peter Clausen  * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
25890996f43SLars-Peter Clausen  * @substream: the pcm substream
25990996f43SLars-Peter Clausen  * @hw: the hardware parameters
26090996f43SLars-Peter Clausen  *
26190996f43SLars-Peter Clausen  * Sets the substream runtime hardware parameters.
26290996f43SLars-Peter Clausen  */
26390996f43SLars-Peter Clausen int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
26490996f43SLars-Peter Clausen 	const struct snd_pcm_hardware *hw)
26590996f43SLars-Peter Clausen {
26690996f43SLars-Peter Clausen 	struct snd_pcm_runtime *runtime = substream->runtime;
26790996f43SLars-Peter Clausen 	runtime->hw.info = hw->info;
26890996f43SLars-Peter Clausen 	runtime->hw.formats = hw->formats;
26990996f43SLars-Peter Clausen 	runtime->hw.period_bytes_min = hw->period_bytes_min;
27090996f43SLars-Peter Clausen 	runtime->hw.period_bytes_max = hw->period_bytes_max;
27190996f43SLars-Peter Clausen 	runtime->hw.periods_min = hw->periods_min;
27290996f43SLars-Peter Clausen 	runtime->hw.periods_max = hw->periods_max;
27390996f43SLars-Peter Clausen 	runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
27490996f43SLars-Peter Clausen 	runtime->hw.fifo_size = hw->fifo_size;
27590996f43SLars-Peter Clausen 	return 0;
27690996f43SLars-Peter Clausen }
27790996f43SLars-Peter Clausen EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
27890996f43SLars-Peter Clausen 
27901d7584cSLiam Girdwood /* DPCM stream event, send event to FE and all active BEs. */
28023607025SLiam Girdwood int dpcm_dapm_stream_event(struct snd_soc_pcm_runtime *fe, int dir,
28101d7584cSLiam Girdwood 	int event)
28201d7584cSLiam Girdwood {
28301d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
28401d7584cSLiam Girdwood 
2858d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, dir, dpcm) {
28601d7584cSLiam Girdwood 
28701d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be = dpcm->be;
28801d7584cSLiam Girdwood 
289103d84a3SLiam Girdwood 		dev_dbg(be->dev, "ASoC: BE %s event %d dir %d\n",
29001d7584cSLiam Girdwood 				be->dai_link->name, event, dir);
29101d7584cSLiam Girdwood 
292b1cd2e34SBanajit Goswami 		if ((event == SND_SOC_DAPM_STREAM_STOP) &&
293b1cd2e34SBanajit Goswami 		    (be->dpcm[dir].users >= 1))
294b1cd2e34SBanajit Goswami 			continue;
295b1cd2e34SBanajit Goswami 
29601d7584cSLiam Girdwood 		snd_soc_dapm_stream_event(be, dir, event);
29701d7584cSLiam Girdwood 	}
29801d7584cSLiam Girdwood 
29901d7584cSLiam Girdwood 	snd_soc_dapm_stream_event(fe, dir, event);
30001d7584cSLiam Girdwood 
30101d7584cSLiam Girdwood 	return 0;
30201d7584cSLiam Girdwood }
30301d7584cSLiam Girdwood 
30417841020SDong Aisheng static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream,
30517841020SDong Aisheng 					struct snd_soc_dai *soc_dai)
306ddee627cSLiam Girdwood {
3070ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
308ddee627cSLiam Girdwood 	int ret;
309ddee627cSLiam Girdwood 
3103635bf09SNicolin Chen 	if (soc_dai->rate && (soc_dai->driver->symmetric_rates ||
3113635bf09SNicolin Chen 				rtd->dai_link->symmetric_rates)) {
3123635bf09SNicolin Chen 		dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %dHz rate\n",
3133635bf09SNicolin Chen 				soc_dai->rate);
314ddee627cSLiam Girdwood 
3154dcdd43bSLars-Peter Clausen 		ret = snd_pcm_hw_constraint_single(substream->runtime,
316ddee627cSLiam Girdwood 						SNDRV_PCM_HW_PARAM_RATE,
3174dcdd43bSLars-Peter Clausen 						soc_dai->rate);
318ddee627cSLiam Girdwood 		if (ret < 0) {
31917841020SDong Aisheng 			dev_err(soc_dai->dev,
3203635bf09SNicolin Chen 				"ASoC: Unable to apply rate constraint: %d\n",
321103d84a3SLiam Girdwood 				ret);
322ddee627cSLiam Girdwood 			return ret;
323ddee627cSLiam Girdwood 		}
3243635bf09SNicolin Chen 	}
3253635bf09SNicolin Chen 
3263635bf09SNicolin Chen 	if (soc_dai->channels && (soc_dai->driver->symmetric_channels ||
3273635bf09SNicolin Chen 				rtd->dai_link->symmetric_channels)) {
3283635bf09SNicolin Chen 		dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %d channel(s)\n",
3293635bf09SNicolin Chen 				soc_dai->channels);
3303635bf09SNicolin Chen 
3314dcdd43bSLars-Peter Clausen 		ret = snd_pcm_hw_constraint_single(substream->runtime,
3323635bf09SNicolin Chen 						SNDRV_PCM_HW_PARAM_CHANNELS,
3333635bf09SNicolin Chen 						soc_dai->channels);
3343635bf09SNicolin Chen 		if (ret < 0) {
3353635bf09SNicolin Chen 			dev_err(soc_dai->dev,
3363635bf09SNicolin Chen 				"ASoC: Unable to apply channel symmetry constraint: %d\n",
3373635bf09SNicolin Chen 				ret);
3383635bf09SNicolin Chen 			return ret;
3393635bf09SNicolin Chen 		}
3403635bf09SNicolin Chen 	}
3413635bf09SNicolin Chen 
3423635bf09SNicolin Chen 	if (soc_dai->sample_bits && (soc_dai->driver->symmetric_samplebits ||
3433635bf09SNicolin Chen 				rtd->dai_link->symmetric_samplebits)) {
3443635bf09SNicolin Chen 		dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %d sample bits\n",
3453635bf09SNicolin Chen 				soc_dai->sample_bits);
3463635bf09SNicolin Chen 
3474dcdd43bSLars-Peter Clausen 		ret = snd_pcm_hw_constraint_single(substream->runtime,
3483635bf09SNicolin Chen 						SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
3493635bf09SNicolin Chen 						soc_dai->sample_bits);
3503635bf09SNicolin Chen 		if (ret < 0) {
3513635bf09SNicolin Chen 			dev_err(soc_dai->dev,
3523635bf09SNicolin Chen 				"ASoC: Unable to apply sample bits symmetry constraint: %d\n",
3533635bf09SNicolin Chen 				ret);
3543635bf09SNicolin Chen 			return ret;
3553635bf09SNicolin Chen 		}
3563635bf09SNicolin Chen 	}
357ddee627cSLiam Girdwood 
358ddee627cSLiam Girdwood 	return 0;
359ddee627cSLiam Girdwood }
360ddee627cSLiam Girdwood 
3613635bf09SNicolin Chen static int soc_pcm_params_symmetry(struct snd_pcm_substream *substream,
3623635bf09SNicolin Chen 				struct snd_pcm_hw_params *params)
3633635bf09SNicolin Chen {
3640ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
365c840f769SKuninori Morimoto 	struct snd_soc_dai *dai;
36619bdcc7aSShreyas NC 	struct snd_soc_dai *cpu_dai;
3672e5894d7SBenoit Cousson 	unsigned int rate, channels, sample_bits, symmetry, i;
3683635bf09SNicolin Chen 
3693635bf09SNicolin Chen 	rate = params_rate(params);
3703635bf09SNicolin Chen 	channels = params_channels(params);
3713635bf09SNicolin Chen 	sample_bits = snd_pcm_format_physical_width(params_format(params));
3723635bf09SNicolin Chen 
3733635bf09SNicolin Chen 	/* reject unmatched parameters when applying symmetry */
37419bdcc7aSShreyas NC 	symmetry = rtd->dai_link->symmetric_rates;
37519bdcc7aSShreyas NC 
376c840f769SKuninori Morimoto 	for_each_rtd_cpu_dais(rtd, i, dai)
377c840f769SKuninori Morimoto 		symmetry |= dai->driver->symmetric_rates;
3782e5894d7SBenoit Cousson 
37919bdcc7aSShreyas NC 	if (symmetry) {
380a4be4187SKuninori Morimoto 		for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
38119bdcc7aSShreyas NC 			if (cpu_dai->rate && cpu_dai->rate != rate) {
3823635bf09SNicolin Chen 				dev_err(rtd->dev, "ASoC: unmatched rate symmetry: %d - %d\n",
3833635bf09SNicolin Chen 					cpu_dai->rate, rate);
3843635bf09SNicolin Chen 				return -EINVAL;
3853635bf09SNicolin Chen 			}
38619bdcc7aSShreyas NC 		}
38719bdcc7aSShreyas NC 	}
3883635bf09SNicolin Chen 
38919bdcc7aSShreyas NC 	symmetry = rtd->dai_link->symmetric_channels;
39019bdcc7aSShreyas NC 
391c840f769SKuninori Morimoto 	for_each_rtd_dais(rtd, i, dai)
392c840f769SKuninori Morimoto 		symmetry |= dai->driver->symmetric_channels;
3932e5894d7SBenoit Cousson 
39419bdcc7aSShreyas NC 	if (symmetry) {
395a4be4187SKuninori Morimoto 		for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
39619bdcc7aSShreyas NC 			if (cpu_dai->channels &&
39719bdcc7aSShreyas NC 			    cpu_dai->channels != channels) {
3983635bf09SNicolin Chen 				dev_err(rtd->dev, "ASoC: unmatched channel symmetry: %d - %d\n",
3993635bf09SNicolin Chen 					cpu_dai->channels, channels);
4003635bf09SNicolin Chen 				return -EINVAL;
4013635bf09SNicolin Chen 			}
40219bdcc7aSShreyas NC 		}
40319bdcc7aSShreyas NC 	}
4043635bf09SNicolin Chen 
40519bdcc7aSShreyas NC 	symmetry = rtd->dai_link->symmetric_samplebits;
40619bdcc7aSShreyas NC 
407c840f769SKuninori Morimoto 	for_each_rtd_dais(rtd, i, dai)
408c840f769SKuninori Morimoto 		symmetry |= dai->driver->symmetric_samplebits;
4092e5894d7SBenoit Cousson 
41019bdcc7aSShreyas NC 	if (symmetry) {
411a4be4187SKuninori Morimoto 		for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
41219bdcc7aSShreyas NC 			if (cpu_dai->sample_bits &&
41319bdcc7aSShreyas NC 			    cpu_dai->sample_bits != sample_bits) {
4143635bf09SNicolin Chen 				dev_err(rtd->dev, "ASoC: unmatched sample bits symmetry: %d - %d\n",
4153635bf09SNicolin Chen 					cpu_dai->sample_bits, sample_bits);
4163635bf09SNicolin Chen 				return -EINVAL;
4173635bf09SNicolin Chen 			}
41819bdcc7aSShreyas NC 		}
41919bdcc7aSShreyas NC 	}
420ddee627cSLiam Girdwood 
421ddee627cSLiam Girdwood 	return 0;
422ddee627cSLiam Girdwood }
423ddee627cSLiam Girdwood 
42462e5f676SLars-Peter Clausen static bool soc_pcm_has_symmetry(struct snd_pcm_substream *substream)
42562e5f676SLars-Peter Clausen {
4260ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
42762e5f676SLars-Peter Clausen 	struct snd_soc_dai_link *link = rtd->dai_link;
428c840f769SKuninori Morimoto 	struct snd_soc_dai *dai;
4292e5894d7SBenoit Cousson 	unsigned int symmetry, i;
43062e5f676SLars-Peter Clausen 
43119bdcc7aSShreyas NC 	symmetry = link->symmetric_rates ||
43219bdcc7aSShreyas NC 		link->symmetric_channels ||
43319bdcc7aSShreyas NC 		link->symmetric_samplebits;
43419bdcc7aSShreyas NC 
435c840f769SKuninori Morimoto 	for_each_rtd_dais(rtd, i, dai)
43619bdcc7aSShreyas NC 		symmetry = symmetry ||
437c840f769SKuninori Morimoto 			dai->driver->symmetric_rates ||
438c840f769SKuninori Morimoto 			dai->driver->symmetric_channels ||
439c840f769SKuninori Morimoto 			dai->driver->symmetric_samplebits;
4402e5894d7SBenoit Cousson 
4412e5894d7SBenoit Cousson 	return symmetry;
44262e5f676SLars-Peter Clausen }
44362e5f676SLars-Peter Clausen 
4442e5894d7SBenoit Cousson static void soc_pcm_set_msb(struct snd_pcm_substream *substream, int bits)
44558ba9b25SMark Brown {
4460ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
447c6068d3aSTakashi Iwai 	int ret;
44858ba9b25SMark Brown 
44958ba9b25SMark Brown 	if (!bits)
45058ba9b25SMark Brown 		return;
45158ba9b25SMark Brown 
4520e2a3751SLars-Peter Clausen 	ret = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 0, bits);
45358ba9b25SMark Brown 	if (ret != 0)
4540e2a3751SLars-Peter Clausen 		dev_warn(rtd->dev, "ASoC: Failed to set MSB %d: %d\n",
4550e2a3751SLars-Peter Clausen 				 bits, ret);
45658ba9b25SMark Brown }
45758ba9b25SMark Brown 
458c8dd1fecSBenoit Cousson static void soc_pcm_apply_msb(struct snd_pcm_substream *substream)
459bd477c31SLars-Peter Clausen {
4600ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
46119bdcc7aSShreyas NC 	struct snd_soc_dai *cpu_dai;
4622e5894d7SBenoit Cousson 	struct snd_soc_dai *codec_dai;
46357be9206SKuninori Morimoto 	struct snd_soc_pcm_stream *pcm_codec, *pcm_cpu;
46457be9206SKuninori Morimoto 	int stream = substream->stream;
4652e5894d7SBenoit Cousson 	int i;
46619bdcc7aSShreyas NC 	unsigned int bits = 0, cpu_bits = 0;
467c8dd1fecSBenoit Cousson 
468a4be4187SKuninori Morimoto 	for_each_rtd_codec_dais(rtd, i, codec_dai) {
46957be9206SKuninori Morimoto 		pcm_codec = snd_soc_dai_get_pcm_stream(codec_dai, stream);
47057be9206SKuninori Morimoto 
47157be9206SKuninori Morimoto 		if (pcm_codec->sig_bits == 0) {
4722e5894d7SBenoit Cousson 			bits = 0;
4732e5894d7SBenoit Cousson 			break;
4742e5894d7SBenoit Cousson 		}
47557be9206SKuninori Morimoto 		bits = max(pcm_codec->sig_bits, bits);
4762e5894d7SBenoit Cousson 	}
47757be9206SKuninori Morimoto 
478a4be4187SKuninori Morimoto 	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
47957be9206SKuninori Morimoto 		pcm_cpu = snd_soc_dai_get_pcm_stream(cpu_dai, stream);
48019bdcc7aSShreyas NC 
48119bdcc7aSShreyas NC 		if (pcm_cpu->sig_bits == 0) {
48219bdcc7aSShreyas NC 			cpu_bits = 0;
48319bdcc7aSShreyas NC 			break;
48419bdcc7aSShreyas NC 		}
48519bdcc7aSShreyas NC 		cpu_bits = max(pcm_cpu->sig_bits, cpu_bits);
48619bdcc7aSShreyas NC 	}
487c8dd1fecSBenoit Cousson 
4882e5894d7SBenoit Cousson 	soc_pcm_set_msb(substream, bits);
4892e5894d7SBenoit Cousson 	soc_pcm_set_msb(substream, cpu_bits);
490c8dd1fecSBenoit Cousson }
491c8dd1fecSBenoit Cousson 
4925854a464SSamuel Holland /**
4935854a464SSamuel Holland  * snd_soc_runtime_calc_hw() - Calculate hw limits for a PCM stream
4945854a464SSamuel Holland  * @rtd: ASoC PCM runtime
4955854a464SSamuel Holland  * @hw: PCM hardware parameters (output)
4965854a464SSamuel Holland  * @stream: Direction of the PCM stream
4975854a464SSamuel Holland  *
4985854a464SSamuel Holland  * Calculates the subset of stream parameters supported by all DAIs
4995854a464SSamuel Holland  * associated with the PCM stream.
5005854a464SSamuel Holland  */
5015854a464SSamuel Holland int snd_soc_runtime_calc_hw(struct snd_soc_pcm_runtime *rtd,
5025854a464SSamuel Holland 			    struct snd_pcm_hardware *hw, int stream)
503bd477c31SLars-Peter Clausen {
5040b7990e3SKuninori Morimoto 	struct snd_soc_dai *codec_dai;
50519bdcc7aSShreyas NC 	struct snd_soc_dai *cpu_dai;
5062e5894d7SBenoit Cousson 	struct snd_soc_pcm_stream *codec_stream;
5072e5894d7SBenoit Cousson 	struct snd_soc_pcm_stream *cpu_stream;
5082e5894d7SBenoit Cousson 	unsigned int chan_min = 0, chan_max = UINT_MAX;
50919bdcc7aSShreyas NC 	unsigned int cpu_chan_min = 0, cpu_chan_max = UINT_MAX;
5102e5894d7SBenoit Cousson 	unsigned int rate_min = 0, rate_max = UINT_MAX;
51119bdcc7aSShreyas NC 	unsigned int cpu_rate_min = 0, cpu_rate_max = UINT_MAX;
51219bdcc7aSShreyas NC 	unsigned int rates = UINT_MAX, cpu_rates = UINT_MAX;
5132e5894d7SBenoit Cousson 	u64 formats = ULLONG_MAX;
5142e5894d7SBenoit Cousson 	int i;
51578e45c99SLars-Peter Clausen 
51619bdcc7aSShreyas NC 	/* first calculate min/max only for CPUs in the DAI link */
517a4be4187SKuninori Morimoto 	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
5180e9cf4c4SBard Liao 
5190e9cf4c4SBard Liao 		/*
5200e9cf4c4SBard Liao 		 * Skip CPUs which don't support the current stream type.
5210e9cf4c4SBard Liao 		 * Otherwise, since the rate, channel, and format values will
5220e9cf4c4SBard Liao 		 * zero in that case, we would have no usable settings left,
5230e9cf4c4SBard Liao 		 * causing the resulting setup to fail.
5240e9cf4c4SBard Liao 		 */
5255854a464SSamuel Holland 		if (!snd_soc_dai_stream_valid(cpu_dai, stream))
5260e9cf4c4SBard Liao 			continue;
5270e9cf4c4SBard Liao 
52819bdcc7aSShreyas NC 		cpu_stream = snd_soc_dai_get_pcm_stream(cpu_dai, stream);
52978e45c99SLars-Peter Clausen 
53019bdcc7aSShreyas NC 		cpu_chan_min = max(cpu_chan_min, cpu_stream->channels_min);
53119bdcc7aSShreyas NC 		cpu_chan_max = min(cpu_chan_max, cpu_stream->channels_max);
53219bdcc7aSShreyas NC 		cpu_rate_min = max(cpu_rate_min, cpu_stream->rate_min);
53319bdcc7aSShreyas NC 		cpu_rate_max = min_not_zero(cpu_rate_max, cpu_stream->rate_max);
53419bdcc7aSShreyas NC 		formats &= cpu_stream->formats;
53519bdcc7aSShreyas NC 		cpu_rates = snd_pcm_rate_mask_intersect(cpu_stream->rates,
53619bdcc7aSShreyas NC 							cpu_rates);
53719bdcc7aSShreyas NC 	}
53819bdcc7aSShreyas NC 
53919bdcc7aSShreyas NC 	/* second calculate min/max only for CODECs in the DAI link */
540a4be4187SKuninori Morimoto 	for_each_rtd_codec_dais(rtd, i, codec_dai) {
541cde79035SRicard Wanderlof 
542cde79035SRicard Wanderlof 		/*
543cde79035SRicard Wanderlof 		 * Skip CODECs which don't support the current stream type.
544cde79035SRicard Wanderlof 		 * Otherwise, since the rate, channel, and format values will
545cde79035SRicard Wanderlof 		 * zero in that case, we would have no usable settings left,
546cde79035SRicard Wanderlof 		 * causing the resulting setup to fail.
547cde79035SRicard Wanderlof 		 */
54825c2f515SKuninori Morimoto 		if (!snd_soc_dai_stream_valid(codec_dai, stream))
549cde79035SRicard Wanderlof 			continue;
550cde79035SRicard Wanderlof 
551acf253c1SKuninori Morimoto 		codec_stream = snd_soc_dai_get_pcm_stream(codec_dai, stream);
552acf253c1SKuninori Morimoto 
5532e5894d7SBenoit Cousson 		chan_min = max(chan_min, codec_stream->channels_min);
5542e5894d7SBenoit Cousson 		chan_max = min(chan_max, codec_stream->channels_max);
5552e5894d7SBenoit Cousson 		rate_min = max(rate_min, codec_stream->rate_min);
5562e5894d7SBenoit Cousson 		rate_max = min_not_zero(rate_max, codec_stream->rate_max);
5572e5894d7SBenoit Cousson 		formats &= codec_stream->formats;
5582e5894d7SBenoit Cousson 		rates = snd_pcm_rate_mask_intersect(codec_stream->rates, rates);
5592e5894d7SBenoit Cousson 	}
5602e5894d7SBenoit Cousson 
5615854a464SSamuel Holland 	/* Verify both a valid CPU DAI and a valid CODEC DAI were found */
5625854a464SSamuel Holland 	if (!chan_min || !cpu_chan_min)
5635854a464SSamuel Holland 		return -EINVAL;
5645854a464SSamuel Holland 
5652e5894d7SBenoit Cousson 	/*
5662e5894d7SBenoit Cousson 	 * chan min/max cannot be enforced if there are multiple CODEC DAIs
56719bdcc7aSShreyas NC 	 * connected to CPU DAI(s), use CPU DAI's directly and let
5682e5894d7SBenoit Cousson 	 * channel allocation be fixed up later
5692e5894d7SBenoit Cousson 	 */
5702e5894d7SBenoit Cousson 	if (rtd->num_codecs > 1) {
57119bdcc7aSShreyas NC 		chan_min = cpu_chan_min;
57219bdcc7aSShreyas NC 		chan_max = cpu_chan_max;
5732e5894d7SBenoit Cousson 	}
5742e5894d7SBenoit Cousson 
57519bdcc7aSShreyas NC 	/* finally find a intersection between CODECs and CPUs */
57619bdcc7aSShreyas NC 	hw->channels_min = max(chan_min, cpu_chan_min);
57719bdcc7aSShreyas NC 	hw->channels_max = min(chan_max, cpu_chan_max);
57819bdcc7aSShreyas NC 	hw->formats = formats;
57919bdcc7aSShreyas NC 	hw->rates = snd_pcm_rate_mask_intersect(rates, cpu_rates);
58078e45c99SLars-Peter Clausen 
5815854a464SSamuel Holland 	snd_pcm_hw_limit_rates(hw);
58278e45c99SLars-Peter Clausen 
58319bdcc7aSShreyas NC 	hw->rate_min = max(hw->rate_min, cpu_rate_min);
5842e5894d7SBenoit Cousson 	hw->rate_min = max(hw->rate_min, rate_min);
58519bdcc7aSShreyas NC 	hw->rate_max = min_not_zero(hw->rate_max, cpu_rate_max);
5862e5894d7SBenoit Cousson 	hw->rate_max = min_not_zero(hw->rate_max, rate_max);
5875854a464SSamuel Holland 
5885854a464SSamuel Holland 	return 0;
5895854a464SSamuel Holland }
5905854a464SSamuel Holland EXPORT_SYMBOL_GPL(snd_soc_runtime_calc_hw);
5915854a464SSamuel Holland 
5925854a464SSamuel Holland static void soc_pcm_init_runtime_hw(struct snd_pcm_substream *substream)
5935854a464SSamuel Holland {
5945854a464SSamuel Holland 	struct snd_pcm_hardware *hw = &substream->runtime->hw;
5950ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
5965854a464SSamuel Holland 	u64 formats = hw->formats;
5975854a464SSamuel Holland 
5985854a464SSamuel Holland 	/*
5995854a464SSamuel Holland 	 * At least one CPU and one CODEC should match. Otherwise, we should
6005854a464SSamuel Holland 	 * have bailed out on a higher level, since there would be no CPU or
6015854a464SSamuel Holland 	 * CODEC to support the transfer direction in that case.
6025854a464SSamuel Holland 	 */
6035854a464SSamuel Holland 	snd_soc_runtime_calc_hw(rtd, hw, substream->stream);
6045854a464SSamuel Holland 
6055854a464SSamuel Holland 	if (formats)
6065854a464SSamuel Holland 		hw->formats &= formats;
607bd477c31SLars-Peter Clausen }
608bd477c31SLars-Peter Clausen 
609dd03907bSKuninori Morimoto static int soc_pcm_components_open(struct snd_pcm_substream *substream)
610e7ecfdb7SKuninori Morimoto {
6110ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
612e7ecfdb7SKuninori Morimoto 	struct snd_soc_component *component;
613613fb500SKuninori Morimoto 	int i, ret = 0;
614e7ecfdb7SKuninori Morimoto 
615613fb500SKuninori Morimoto 	for_each_rtd_components(rtd, i, component) {
61651aff91aSKuninori Morimoto 		ret = snd_soc_component_module_get_when_open(component, substream);
617bcae1631SKuninori Morimoto 		if (ret < 0)
618d2aaa8d8SKai Vehmanen 			break;
619e7ecfdb7SKuninori Morimoto 
620ae2f4849SKuninori Morimoto 		ret = snd_soc_component_open(component, substream);
621bcae1631SKuninori Morimoto 		if (ret < 0)
622d2aaa8d8SKai Vehmanen 			break;
623e7ecfdb7SKuninori Morimoto 	}
624dd03907bSKuninori Morimoto 
625d2aaa8d8SKai Vehmanen 	return ret;
626e7ecfdb7SKuninori Morimoto }
627e7ecfdb7SKuninori Morimoto 
62851aff91aSKuninori Morimoto static int soc_pcm_components_close(struct snd_pcm_substream *substream,
62951aff91aSKuninori Morimoto 				    int rollback)
630244e2936SCharles Keepax {
6310ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
632244e2936SCharles Keepax 	struct snd_soc_component *component;
633e82ebffcSKuninori Morimoto 	int i, r, ret = 0;
634244e2936SCharles Keepax 
635613fb500SKuninori Morimoto 	for_each_rtd_components(rtd, i, component) {
63651aff91aSKuninori Morimoto 		r = snd_soc_component_close(component, substream, rollback);
637e82ebffcSKuninori Morimoto 		if (r < 0)
638e82ebffcSKuninori Morimoto 			ret = r; /* use last ret */
639e82ebffcSKuninori Morimoto 
64051aff91aSKuninori Morimoto 		snd_soc_component_module_put_when_close(component, substream, rollback);
641244e2936SCharles Keepax 	}
642244e2936SCharles Keepax 
6433672beb8SKuninori Morimoto 	return ret;
644244e2936SCharles Keepax }
645244e2936SCharles Keepax 
646140a4532SKuninori Morimoto static int soc_pcm_clean(struct snd_pcm_substream *substream, int rollback)
64762c86d1dSKuninori Morimoto {
6480ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
64962c86d1dSKuninori Morimoto 	struct snd_soc_component *component;
650c840f769SKuninori Morimoto 	struct snd_soc_dai *dai;
65162c86d1dSKuninori Morimoto 	int i;
65262c86d1dSKuninori Morimoto 
65362c86d1dSKuninori Morimoto 	mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
65462c86d1dSKuninori Morimoto 
655140a4532SKuninori Morimoto 	if (!rollback)
65662c86d1dSKuninori Morimoto 		snd_soc_runtime_deactivate(rtd, substream->stream);
65762c86d1dSKuninori Morimoto 
658c840f769SKuninori Morimoto 	for_each_rtd_dais(rtd, i, dai)
659140a4532SKuninori Morimoto 		snd_soc_dai_shutdown(dai, substream, rollback);
66062c86d1dSKuninori Morimoto 
661140a4532SKuninori Morimoto 	snd_soc_link_shutdown(substream, rollback);
66262c86d1dSKuninori Morimoto 
663140a4532SKuninori Morimoto 	soc_pcm_components_close(substream, rollback);
66462c86d1dSKuninori Morimoto 
665140a4532SKuninori Morimoto 	if (!rollback)
66662c86d1dSKuninori Morimoto 		snd_soc_dapm_stream_stop(rtd, substream->stream);
66762c86d1dSKuninori Morimoto 
66862c86d1dSKuninori Morimoto 	mutex_unlock(&rtd->card->pcm_mutex);
66962c86d1dSKuninori Morimoto 
670140a4532SKuninori Morimoto 	snd_soc_pcm_component_pm_runtime_put(rtd, substream, rollback);
67162c86d1dSKuninori Morimoto 
67262c86d1dSKuninori Morimoto 	for_each_rtd_components(rtd, i, component)
673b3dea624SKuninori Morimoto 		if (!snd_soc_component_active(component))
67462c86d1dSKuninori Morimoto 			pinctrl_pm_select_sleep_state(component->dev);
67562c86d1dSKuninori Morimoto 
67662c86d1dSKuninori Morimoto 	return 0;
67762c86d1dSKuninori Morimoto }
67862c86d1dSKuninori Morimoto 
67962c86d1dSKuninori Morimoto /*
680140a4532SKuninori Morimoto  * Called by ALSA when a PCM substream is closed. Private data can be
681140a4532SKuninori Morimoto  * freed here. The cpu DAI, codec DAI, machine and components are also
682140a4532SKuninori Morimoto  * shutdown.
683140a4532SKuninori Morimoto  */
684140a4532SKuninori Morimoto static int soc_pcm_close(struct snd_pcm_substream *substream)
685140a4532SKuninori Morimoto {
686140a4532SKuninori Morimoto 	return soc_pcm_clean(substream, 0);
687140a4532SKuninori Morimoto }
688140a4532SKuninori Morimoto 
689140a4532SKuninori Morimoto /*
690ddee627cSLiam Girdwood  * Called by ALSA when a PCM substream is opened, the runtime->hw record is
691ddee627cSLiam Girdwood  * then initialized and any private data can be allocated. This also calls
692ef050becSCharles Keepax  * startup for the cpu DAI, component, machine and codec DAI.
693ddee627cSLiam Girdwood  */
694ddee627cSLiam Girdwood static int soc_pcm_open(struct snd_pcm_substream *substream)
695ddee627cSLiam Girdwood {
6960ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
697ddee627cSLiam Girdwood 	struct snd_pcm_runtime *runtime = substream->runtime;
69890be711eSKuninori Morimoto 	struct snd_soc_component *component;
699c840f769SKuninori Morimoto 	struct snd_soc_dai *dai;
7002e5894d7SBenoit Cousson 	const char *codec_dai_name = "multicodec";
70119bdcc7aSShreyas NC 	const char *cpu_dai_name = "multicpu";
702244e2936SCharles Keepax 	int i, ret = 0;
703ddee627cSLiam Girdwood 
70476c39e86SKuninori Morimoto 	for_each_rtd_components(rtd, i, component)
70576c39e86SKuninori Morimoto 		pinctrl_pm_select_default_state(component->dev);
70690be711eSKuninori Morimoto 
707939a5cfbSKuninori Morimoto 	ret = snd_soc_pcm_component_pm_runtime_get(rtd, substream);
708939a5cfbSKuninori Morimoto 	if (ret < 0)
709cb2fce94SKuninori Morimoto 		goto pm_err;
710d6652ef8SMark Brown 
71172b745e3SPeter Ujfalusi 	mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
712ddee627cSLiam Girdwood 
7135d9fa03eSKuninori Morimoto 	ret = soc_pcm_components_open(substream);
7145d9fa03eSKuninori Morimoto 	if (ret < 0)
715140a4532SKuninori Morimoto 		goto err;
7165d9fa03eSKuninori Morimoto 
7177cf3c5b4SKuninori Morimoto 	ret = snd_soc_link_startup(substream);
718a5e6c109SKuninori Morimoto 	if (ret < 0)
719140a4532SKuninori Morimoto 		goto err;
7205d9fa03eSKuninori Morimoto 
721ddee627cSLiam Girdwood 	/* startup the audio subsystem */
722c840f769SKuninori Morimoto 	for_each_rtd_dais(rtd, i, dai) {
723c840f769SKuninori Morimoto 		ret = snd_soc_dai_startup(dai, substream);
724ce820145SKuninori Morimoto 		if (ret < 0)
725140a4532SKuninori Morimoto 			goto err;
726ddee627cSLiam Girdwood 
7272e5894d7SBenoit Cousson 		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
728c840f769SKuninori Morimoto 			dai->tx_mask = 0;
7292e5894d7SBenoit Cousson 		else
730c840f769SKuninori Morimoto 			dai->rx_mask = 0;
7312e5894d7SBenoit Cousson 	}
7322e5894d7SBenoit Cousson 
73301d7584cSLiam Girdwood 	/* Dynamic PCM DAI links compat checks use dynamic capabilities */
73401d7584cSLiam Girdwood 	if (rtd->dai_link->dynamic || rtd->dai_link->no_pcm)
73501d7584cSLiam Girdwood 		goto dynamic;
73601d7584cSLiam Girdwood 
737ddee627cSLiam Girdwood 	/* Check that the codec and cpu DAIs are compatible */
7382e5894d7SBenoit Cousson 	soc_pcm_init_runtime_hw(substream);
7392e5894d7SBenoit Cousson 
7402e5894d7SBenoit Cousson 	if (rtd->num_codecs == 1)
741c2233a26SKuninori Morimoto 		codec_dai_name = asoc_rtd_to_codec(rtd, 0)->name;
742ddee627cSLiam Girdwood 
74319bdcc7aSShreyas NC 	if (rtd->num_cpus == 1)
744c2233a26SKuninori Morimoto 		cpu_dai_name = asoc_rtd_to_cpu(rtd, 0)->name;
74519bdcc7aSShreyas NC 
74662e5f676SLars-Peter Clausen 	if (soc_pcm_has_symmetry(substream))
74762e5f676SLars-Peter Clausen 		runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX;
74862e5f676SLars-Peter Clausen 
749ddee627cSLiam Girdwood 	ret = -EINVAL;
750ddee627cSLiam Girdwood 	if (!runtime->hw.rates) {
751103d84a3SLiam Girdwood 		printk(KERN_ERR "ASoC: %s <-> %s No matching rates\n",
75219bdcc7aSShreyas NC 			codec_dai_name, cpu_dai_name);
753140a4532SKuninori Morimoto 		goto err;
754ddee627cSLiam Girdwood 	}
755ddee627cSLiam Girdwood 	if (!runtime->hw.formats) {
756103d84a3SLiam Girdwood 		printk(KERN_ERR "ASoC: %s <-> %s No matching formats\n",
75719bdcc7aSShreyas NC 			codec_dai_name, cpu_dai_name);
758140a4532SKuninori Morimoto 		goto err;
759ddee627cSLiam Girdwood 	}
760ddee627cSLiam Girdwood 	if (!runtime->hw.channels_min || !runtime->hw.channels_max ||
761ddee627cSLiam Girdwood 	    runtime->hw.channels_min > runtime->hw.channels_max) {
762103d84a3SLiam Girdwood 		printk(KERN_ERR "ASoC: %s <-> %s No matching channels\n",
76319bdcc7aSShreyas NC 				codec_dai_name, cpu_dai_name);
764140a4532SKuninori Morimoto 		goto err;
765ddee627cSLiam Girdwood 	}
766ddee627cSLiam Girdwood 
767c8dd1fecSBenoit Cousson 	soc_pcm_apply_msb(substream);
76858ba9b25SMark Brown 
769ddee627cSLiam Girdwood 	/* Symmetry only applies if we've already got an active stream. */
770c840f769SKuninori Morimoto 	for_each_rtd_dais(rtd, i, dai) {
771b3dea624SKuninori Morimoto 		if (snd_soc_dai_active(dai)) {
772c840f769SKuninori Morimoto 			ret = soc_pcm_apply_symmetry(substream, dai);
773ddee627cSLiam Girdwood 			if (ret != 0)
774140a4532SKuninori Morimoto 				goto err;
775ddee627cSLiam Girdwood 		}
7762e5894d7SBenoit Cousson 	}
777ddee627cSLiam Girdwood 
778103d84a3SLiam Girdwood 	pr_debug("ASoC: %s <-> %s info:\n",
77919bdcc7aSShreyas NC 		 codec_dai_name, cpu_dai_name);
780103d84a3SLiam Girdwood 	pr_debug("ASoC: rate mask 0x%x\n", runtime->hw.rates);
781103d84a3SLiam Girdwood 	pr_debug("ASoC: min ch %d max ch %d\n", runtime->hw.channels_min,
782ddee627cSLiam Girdwood 		 runtime->hw.channels_max);
783103d84a3SLiam Girdwood 	pr_debug("ASoC: min rate %d max rate %d\n", runtime->hw.rate_min,
784ddee627cSLiam Girdwood 		 runtime->hw.rate_max);
78501d7584cSLiam Girdwood dynamic:
78624894b76SLars-Peter Clausen 	snd_soc_runtime_activate(rtd, substream->stream);
7878e7875aeSKuninori Morimoto 	ret = 0;
788140a4532SKuninori Morimoto err:
78972b745e3SPeter Ujfalusi 	mutex_unlock(&rtd->card->pcm_mutex);
790cb2fce94SKuninori Morimoto pm_err:
791140a4532SKuninori Morimoto 	if (ret < 0)
792140a4532SKuninori Morimoto 		soc_pcm_clean(substream, 1);
793d6652ef8SMark Brown 
794ddee627cSLiam Girdwood 	return ret;
795ddee627cSLiam Girdwood }
796ddee627cSLiam Girdwood 
7974bf2e385SCurtis Malainey static void codec2codec_close_delayed_work(struct snd_soc_pcm_runtime *rtd)
798a342031cSJerome Brunet {
799a342031cSJerome Brunet 	/*
800a342031cSJerome Brunet 	 * Currently nothing to do for c2c links
801a342031cSJerome Brunet 	 * Since c2c links are internal nodes in the DAPM graph and
802a342031cSJerome Brunet 	 * don't interface with the outside world or application layer
803a342031cSJerome Brunet 	 * we don't have to do any special handling on close.
804a342031cSJerome Brunet 	 */
805a342031cSJerome Brunet }
806a342031cSJerome Brunet 
807ddee627cSLiam Girdwood /*
808ddee627cSLiam Girdwood  * Called by ALSA when the PCM substream is prepared, can set format, sample
809ddee627cSLiam Girdwood  * rate, etc.  This function is non atomic and can be called multiple times,
810ddee627cSLiam Girdwood  * it can refer to the runtime info.
811ddee627cSLiam Girdwood  */
812ddee627cSLiam Girdwood static int soc_pcm_prepare(struct snd_pcm_substream *substream)
813ddee627cSLiam Girdwood {
8140ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
815c840f769SKuninori Morimoto 	struct snd_soc_dai *dai;
8162e5894d7SBenoit Cousson 	int i, ret = 0;
817ddee627cSLiam Girdwood 
81872b745e3SPeter Ujfalusi 	mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
819ddee627cSLiam Girdwood 
8207cf3c5b4SKuninori Morimoto 	ret = snd_soc_link_prepare(substream);
821a5e6c109SKuninori Morimoto 	if (ret < 0)
822ddee627cSLiam Girdwood 		goto out;
823ddee627cSLiam Girdwood 
8244f39514fSKuninori Morimoto 	ret = snd_soc_pcm_component_prepare(substream);
8254f39514fSKuninori Morimoto 	if (ret < 0)
826b8135864SKuninori Morimoto 		goto out;
827b8135864SKuninori Morimoto 
828d108c7fdSKuninori Morimoto 	ret = snd_soc_pcm_dai_prepare(substream);
829ddee627cSLiam Girdwood 	if (ret < 0) {
830d108c7fdSKuninori Morimoto 		dev_err(rtd->dev, "ASoC: DAI prepare error: %d\n", ret);
831ddee627cSLiam Girdwood 		goto out;
832ddee627cSLiam Girdwood 	}
833ddee627cSLiam Girdwood 
834ddee627cSLiam Girdwood 	/* cancel any delayed stream shutdown that is pending */
835ddee627cSLiam Girdwood 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
8369bffb1fbSMisael Lopez Cruz 	    rtd->pop_wait) {
8379bffb1fbSMisael Lopez Cruz 		rtd->pop_wait = 0;
838ddee627cSLiam Girdwood 		cancel_delayed_work(&rtd->delayed_work);
839ddee627cSLiam Girdwood 	}
840ddee627cSLiam Girdwood 
841d9b0951bSLiam Girdwood 	snd_soc_dapm_stream_event(rtd, substream->stream,
842ddee627cSLiam Girdwood 			SND_SOC_DAPM_STREAM_START);
843ddee627cSLiam Girdwood 
844c840f769SKuninori Morimoto 	for_each_rtd_dais(rtd, i, dai)
845c840f769SKuninori Morimoto 		snd_soc_dai_digital_mute(dai, 0, substream->stream);
846ddee627cSLiam Girdwood 
847ddee627cSLiam Girdwood out:
84872b745e3SPeter Ujfalusi 	mutex_unlock(&rtd->card->pcm_mutex);
849ddee627cSLiam Girdwood 	return ret;
850ddee627cSLiam Girdwood }
851ddee627cSLiam Girdwood 
8522e5894d7SBenoit Cousson static void soc_pcm_codec_params_fixup(struct snd_pcm_hw_params *params,
8532e5894d7SBenoit Cousson 				       unsigned int mask)
8542e5894d7SBenoit Cousson {
8552e5894d7SBenoit Cousson 	struct snd_interval *interval;
8562e5894d7SBenoit Cousson 	int channels = hweight_long(mask);
8572e5894d7SBenoit Cousson 
8582e5894d7SBenoit Cousson 	interval = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
8592e5894d7SBenoit Cousson 	interval->min = channels;
8602e5894d7SBenoit Cousson 	interval->max = channels;
8612e5894d7SBenoit Cousson }
8622e5894d7SBenoit Cousson 
863ddee627cSLiam Girdwood /*
864*ab49436eSKuninori Morimoto  * Frees resources allocated by hw_params, can be called multiple times
865*ab49436eSKuninori Morimoto  */
866*ab49436eSKuninori Morimoto static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
867*ab49436eSKuninori Morimoto {
868*ab49436eSKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
869*ab49436eSKuninori Morimoto 	struct snd_soc_dai *dai;
870*ab49436eSKuninori Morimoto 	int i;
871*ab49436eSKuninori Morimoto 
872*ab49436eSKuninori Morimoto 	mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
873*ab49436eSKuninori Morimoto 
874*ab49436eSKuninori Morimoto 	/* clear the corresponding DAIs parameters when going to be inactive */
875*ab49436eSKuninori Morimoto 	for_each_rtd_dais(rtd, i, dai) {
876*ab49436eSKuninori Morimoto 		int active = snd_soc_dai_stream_active(dai, substream->stream);
877*ab49436eSKuninori Morimoto 
878*ab49436eSKuninori Morimoto 		if (snd_soc_dai_active(dai) == 1) {
879*ab49436eSKuninori Morimoto 			dai->rate = 0;
880*ab49436eSKuninori Morimoto 			dai->channels = 0;
881*ab49436eSKuninori Morimoto 			dai->sample_bits = 0;
882*ab49436eSKuninori Morimoto 		}
883*ab49436eSKuninori Morimoto 
884*ab49436eSKuninori Morimoto 		if (active == 1)
885*ab49436eSKuninori Morimoto 			snd_soc_dai_digital_mute(dai, 1, substream->stream);
886*ab49436eSKuninori Morimoto 	}
887*ab49436eSKuninori Morimoto 
888*ab49436eSKuninori Morimoto 	/* free any machine hw params */
889*ab49436eSKuninori Morimoto 	snd_soc_link_hw_free(substream);
890*ab49436eSKuninori Morimoto 
891*ab49436eSKuninori Morimoto 	/* free any component resources */
892*ab49436eSKuninori Morimoto 	snd_soc_pcm_component_hw_free(substream, NULL);
893*ab49436eSKuninori Morimoto 
894*ab49436eSKuninori Morimoto 	/* now free hw params for the DAIs  */
895*ab49436eSKuninori Morimoto 	for_each_rtd_dais(rtd, i, dai) {
896*ab49436eSKuninori Morimoto 		if (!snd_soc_dai_stream_valid(dai, substream->stream))
897*ab49436eSKuninori Morimoto 			continue;
898*ab49436eSKuninori Morimoto 
899*ab49436eSKuninori Morimoto 		snd_soc_dai_hw_free(dai, substream);
900*ab49436eSKuninori Morimoto 	}
901*ab49436eSKuninori Morimoto 
902*ab49436eSKuninori Morimoto 	mutex_unlock(&rtd->card->pcm_mutex);
903*ab49436eSKuninori Morimoto 	return 0;
904*ab49436eSKuninori Morimoto }
905*ab49436eSKuninori Morimoto 
906*ab49436eSKuninori Morimoto /*
907ddee627cSLiam Girdwood  * Called by ALSA when the hardware params are set by application. This
908ddee627cSLiam Girdwood  * function can also be called multiple times and can allocate buffers
909ddee627cSLiam Girdwood  * (using snd_pcm_lib_* ). It's non-atomic.
910ddee627cSLiam Girdwood  */
911ddee627cSLiam Girdwood static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
912ddee627cSLiam Girdwood 				struct snd_pcm_hw_params *params)
913ddee627cSLiam Girdwood {
9140ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
915b8135864SKuninori Morimoto 	struct snd_soc_component *component;
91619bdcc7aSShreyas NC 	struct snd_soc_dai *cpu_dai;
9170b7990e3SKuninori Morimoto 	struct snd_soc_dai *codec_dai;
918244e2936SCharles Keepax 	int i, ret = 0;
919ddee627cSLiam Girdwood 
92072b745e3SPeter Ujfalusi 	mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
9215cca5951SShengjiu Wang 
9225cca5951SShengjiu Wang 	ret = soc_pcm_params_symmetry(substream, params);
9235cca5951SShengjiu Wang 	if (ret)
9245cca5951SShengjiu Wang 		goto out;
9255cca5951SShengjiu Wang 
9267cf3c5b4SKuninori Morimoto 	ret = snd_soc_link_hw_params(substream, params);
927a5e6c109SKuninori Morimoto 	if (ret < 0)
928ddee627cSLiam Girdwood 		goto out;
929ddee627cSLiam Girdwood 
930a4be4187SKuninori Morimoto 	for_each_rtd_codec_dais(rtd, i, codec_dai) {
9312e5894d7SBenoit Cousson 		struct snd_pcm_hw_params codec_params;
9322e5894d7SBenoit Cousson 
933cde79035SRicard Wanderlof 		/*
934cde79035SRicard Wanderlof 		 * Skip CODECs which don't support the current stream type,
935cde79035SRicard Wanderlof 		 * the idea being that if a CODEC is not used for the currently
936cde79035SRicard Wanderlof 		 * set up transfer direction, it should not need to be
937cde79035SRicard Wanderlof 		 * configured, especially since the configuration used might
938cde79035SRicard Wanderlof 		 * not even be supported by that CODEC. There may be cases
939cde79035SRicard Wanderlof 		 * however where a CODEC needs to be set up although it is
940cde79035SRicard Wanderlof 		 * actually not being used for the transfer, e.g. if a
941cde79035SRicard Wanderlof 		 * capture-only CODEC is acting as an LRCLK and/or BCLK master
942cde79035SRicard Wanderlof 		 * for the DAI link including a playback-only CODEC.
943cde79035SRicard Wanderlof 		 * If this becomes necessary, we will have to augment the
944cde79035SRicard Wanderlof 		 * machine driver setup with information on how to act, so
945cde79035SRicard Wanderlof 		 * we can do the right thing here.
946cde79035SRicard Wanderlof 		 */
947cde79035SRicard Wanderlof 		if (!snd_soc_dai_stream_valid(codec_dai, substream->stream))
948cde79035SRicard Wanderlof 			continue;
949cde79035SRicard Wanderlof 
9502e5894d7SBenoit Cousson 		/* copy params for each codec */
9512e5894d7SBenoit Cousson 		codec_params = *params;
9522e5894d7SBenoit Cousson 
9532e5894d7SBenoit Cousson 		/* fixup params based on TDM slot masks */
954570f18b6SRander Wang 		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
955570f18b6SRander Wang 		    codec_dai->tx_mask)
9562e5894d7SBenoit Cousson 			soc_pcm_codec_params_fixup(&codec_params,
9572e5894d7SBenoit Cousson 						   codec_dai->tx_mask);
958570f18b6SRander Wang 
959570f18b6SRander Wang 		if (substream->stream == SNDRV_PCM_STREAM_CAPTURE &&
960570f18b6SRander Wang 		    codec_dai->rx_mask)
9612e5894d7SBenoit Cousson 			soc_pcm_codec_params_fixup(&codec_params,
9622e5894d7SBenoit Cousson 						   codec_dai->rx_mask);
9632e5894d7SBenoit Cousson 
964aa6166c2SKuninori Morimoto 		ret = snd_soc_dai_hw_params(codec_dai, substream,
965aa6166c2SKuninori Morimoto 					    &codec_params);
96693e6958aSBenoit Cousson 		if(ret < 0)
967ddee627cSLiam Girdwood 			goto codec_err;
968ddee627cSLiam Girdwood 
9692e5894d7SBenoit Cousson 		codec_dai->rate = params_rate(&codec_params);
9702e5894d7SBenoit Cousson 		codec_dai->channels = params_channels(&codec_params);
9712e5894d7SBenoit Cousson 		codec_dai->sample_bits = snd_pcm_format_physical_width(
9722e5894d7SBenoit Cousson 						params_format(&codec_params));
973078a85f2SCharles Keepax 
974078a85f2SCharles Keepax 		snd_soc_dapm_update_dai(substream, &codec_params, codec_dai);
975ddee627cSLiam Girdwood 	}
976ddee627cSLiam Girdwood 
977a4be4187SKuninori Morimoto 	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
9780e9cf4c4SBard Liao 		/*
9790e9cf4c4SBard Liao 		 * Skip CPUs which don't support the current stream
9800e9cf4c4SBard Liao 		 * type. See soc_pcm_init_runtime_hw() for more details
9810e9cf4c4SBard Liao 		 */
9820e9cf4c4SBard Liao 		if (!snd_soc_dai_stream_valid(cpu_dai, substream->stream))
9830e9cf4c4SBard Liao 			continue;
9840e9cf4c4SBard Liao 
985aa6166c2SKuninori Morimoto 		ret = snd_soc_dai_hw_params(cpu_dai, substream, params);
98693e6958aSBenoit Cousson 		if (ret < 0)
987ddee627cSLiam Girdwood 			goto interface_err;
988ddee627cSLiam Girdwood 
98919bdcc7aSShreyas NC 		/* store the parameters for each DAI */
990ca58221dSKuninori Morimoto 		cpu_dai->rate = params_rate(params);
991ca58221dSKuninori Morimoto 		cpu_dai->channels = params_channels(params);
992ca58221dSKuninori Morimoto 		cpu_dai->sample_bits =
993ca58221dSKuninori Morimoto 			snd_pcm_format_physical_width(params_format(params));
994ca58221dSKuninori Morimoto 
995ca58221dSKuninori Morimoto 		snd_soc_dapm_update_dai(substream, params, cpu_dai);
99619bdcc7aSShreyas NC 	}
997ca58221dSKuninori Morimoto 
998e1bafa82SKuninori Morimoto 	ret = snd_soc_pcm_component_hw_params(substream, params, &component);
999e1bafa82SKuninori Morimoto 	if (ret < 0)
1000b8135864SKuninori Morimoto 		goto component_err;
1001b8135864SKuninori Morimoto 
1002ddee627cSLiam Girdwood out:
100372b745e3SPeter Ujfalusi 	mutex_unlock(&rtd->card->pcm_mutex);
1004ddee627cSLiam Girdwood 	return ret;
1005ddee627cSLiam Girdwood 
1006b8135864SKuninori Morimoto component_err:
100704751119SKuninori Morimoto 	snd_soc_pcm_component_hw_free(substream, component);
1008b8135864SKuninori Morimoto 
100919bdcc7aSShreyas NC 	i = rtd->num_cpus;
1010ddee627cSLiam Girdwood 
1011ddee627cSLiam Girdwood interface_err:
1012a4be4187SKuninori Morimoto 	for_each_rtd_cpu_dais_rollback(rtd, i, cpu_dai) {
10130e9cf4c4SBard Liao 		if (!snd_soc_dai_stream_valid(cpu_dai, substream->stream))
10140e9cf4c4SBard Liao 			continue;
10150e9cf4c4SBard Liao 
101619bdcc7aSShreyas NC 		snd_soc_dai_hw_free(cpu_dai, substream);
101719bdcc7aSShreyas NC 		cpu_dai->rate = 0;
101819bdcc7aSShreyas NC 	}
101919bdcc7aSShreyas NC 
10202e5894d7SBenoit Cousson 	i = rtd->num_codecs;
1021ddee627cSLiam Girdwood 
1022ddee627cSLiam Girdwood codec_err:
1023a4be4187SKuninori Morimoto 	for_each_rtd_codec_dais_rollback(rtd, i, codec_dai) {
1024f47b9ad9SJerome Brunet 		if (!snd_soc_dai_stream_valid(codec_dai, substream->stream))
1025f47b9ad9SJerome Brunet 			continue;
1026f47b9ad9SJerome Brunet 
1027846faaedSKuninori Morimoto 		snd_soc_dai_hw_free(codec_dai, substream);
10282e5894d7SBenoit Cousson 		codec_dai->rate = 0;
10292e5894d7SBenoit Cousson 	}
10302e5894d7SBenoit Cousson 
10317cf3c5b4SKuninori Morimoto 	snd_soc_link_hw_free(substream);
1032ddee627cSLiam Girdwood 
103372b745e3SPeter Ujfalusi 	mutex_unlock(&rtd->card->pcm_mutex);
1034ddee627cSLiam Girdwood 	return ret;
1035ddee627cSLiam Girdwood }
1036ddee627cSLiam Girdwood 
10374378f1fbSPeter Ujfalusi static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
10384378f1fbSPeter Ujfalusi {
1039836367beSKuninori Morimoto 	int ret = -EINVAL;
10404378f1fbSPeter Ujfalusi 
10414378f1fbSPeter Ujfalusi 	switch (cmd) {
10424378f1fbSPeter Ujfalusi 	case SNDRV_PCM_TRIGGER_START:
10434378f1fbSPeter Ujfalusi 	case SNDRV_PCM_TRIGGER_RESUME:
10444378f1fbSPeter Ujfalusi 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1045836367beSKuninori Morimoto 		ret = snd_soc_link_trigger(substream, cmd);
1046836367beSKuninori Morimoto 		if (ret < 0)
1047836367beSKuninori Morimoto 			break;
1048836367beSKuninori Morimoto 
1049836367beSKuninori Morimoto 		ret = snd_soc_pcm_component_trigger(substream, cmd);
1050836367beSKuninori Morimoto 		if (ret < 0)
1051836367beSKuninori Morimoto 			break;
1052836367beSKuninori Morimoto 
1053836367beSKuninori Morimoto 		ret = snd_soc_pcm_dai_trigger(substream, cmd);
10544378f1fbSPeter Ujfalusi 		break;
10554378f1fbSPeter Ujfalusi 	case SNDRV_PCM_TRIGGER_STOP:
10564378f1fbSPeter Ujfalusi 	case SNDRV_PCM_TRIGGER_SUSPEND:
10574378f1fbSPeter Ujfalusi 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1058836367beSKuninori Morimoto 		ret = snd_soc_pcm_dai_trigger(substream, cmd);
1059836367beSKuninori Morimoto 		if (ret < 0)
10604378f1fbSPeter Ujfalusi 			break;
1061836367beSKuninori Morimoto 
1062836367beSKuninori Morimoto 		ret = snd_soc_pcm_component_trigger(substream, cmd);
1063836367beSKuninori Morimoto 		if (ret < 0)
1064836367beSKuninori Morimoto 			break;
1065836367beSKuninori Morimoto 
1066836367beSKuninori Morimoto 		ret = snd_soc_link_trigger(substream, cmd);
1067836367beSKuninori Morimoto 		break;
10684378f1fbSPeter Ujfalusi 	}
10694378f1fbSPeter Ujfalusi 
10704378f1fbSPeter Ujfalusi 	return ret;
10714378f1fbSPeter Ujfalusi }
10724378f1fbSPeter Ujfalusi 
1073ddee627cSLiam Girdwood /*
1074ddee627cSLiam Girdwood  * soc level wrapper for pointer callback
1075ef050becSCharles Keepax  * If cpu_dai, codec_dai, component driver has the delay callback, then
1076ddee627cSLiam Girdwood  * the runtime->delay will be updated accordingly.
1077ddee627cSLiam Girdwood  */
1078ddee627cSLiam Girdwood static snd_pcm_uframes_t soc_pcm_pointer(struct snd_pcm_substream *substream)
1079ddee627cSLiam Girdwood {
10800ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
108119bdcc7aSShreyas NC 	struct snd_soc_dai *cpu_dai;
10822e5894d7SBenoit Cousson 	struct snd_soc_dai *codec_dai;
1083ddee627cSLiam Girdwood 	struct snd_pcm_runtime *runtime = substream->runtime;
1084ddee627cSLiam Girdwood 	snd_pcm_uframes_t offset = 0;
1085ddee627cSLiam Girdwood 	snd_pcm_sframes_t delay = 0;
10862e5894d7SBenoit Cousson 	snd_pcm_sframes_t codec_delay = 0;
108719bdcc7aSShreyas NC 	snd_pcm_sframes_t cpu_delay = 0;
10882e5894d7SBenoit Cousson 	int i;
1089ddee627cSLiam Girdwood 
10909fb4c2bfSAkshu Agrawal 	/* clearing the previous total delay */
10919fb4c2bfSAkshu Agrawal 	runtime->delay = 0;
10929fb4c2bfSAkshu Agrawal 
10930035e256SKuninori Morimoto 	offset = snd_soc_pcm_component_pointer(substream);
1094b8135864SKuninori Morimoto 
10959fb4c2bfSAkshu Agrawal 	/* base delay if assigned in pointer callback */
10969fb4c2bfSAkshu Agrawal 	delay = runtime->delay;
1097b8135864SKuninori Morimoto 
1098a4be4187SKuninori Morimoto 	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
109919bdcc7aSShreyas NC 		cpu_delay = max(cpu_delay,
110019bdcc7aSShreyas NC 				snd_soc_dai_delay(cpu_dai, substream));
110119bdcc7aSShreyas NC 	}
110219bdcc7aSShreyas NC 	delay += cpu_delay;
1103ddee627cSLiam Girdwood 
1104a4be4187SKuninori Morimoto 	for_each_rtd_codec_dais(rtd, i, codec_dai) {
11052e5894d7SBenoit Cousson 		codec_delay = max(codec_delay,
11061dea80d4SKuninori Morimoto 				  snd_soc_dai_delay(codec_dai, substream));
11072e5894d7SBenoit Cousson 	}
11082e5894d7SBenoit Cousson 	delay += codec_delay;
1109ddee627cSLiam Girdwood 
1110ddee627cSLiam Girdwood 	runtime->delay = delay;
1111ddee627cSLiam Girdwood 
1112ddee627cSLiam Girdwood 	return offset;
1113ddee627cSLiam Girdwood }
1114ddee627cSLiam Girdwood 
111501d7584cSLiam Girdwood /* connect a FE and BE */
111601d7584cSLiam Girdwood static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe,
111701d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be, int stream)
111801d7584cSLiam Girdwood {
111901d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
1120a9764869SKaiChieh Chuang 	unsigned long flags;
112101d7584cSLiam Girdwood 
112201d7584cSLiam Girdwood 	/* only add new dpcms */
11238d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
112401d7584cSLiam Girdwood 		if (dpcm->be == be && dpcm->fe == fe)
112501d7584cSLiam Girdwood 			return 0;
112601d7584cSLiam Girdwood 	}
112701d7584cSLiam Girdwood 
112801d7584cSLiam Girdwood 	dpcm = kzalloc(sizeof(struct snd_soc_dpcm), GFP_KERNEL);
112901d7584cSLiam Girdwood 	if (!dpcm)
113001d7584cSLiam Girdwood 		return -ENOMEM;
113101d7584cSLiam Girdwood 
113201d7584cSLiam Girdwood 	dpcm->be = be;
113301d7584cSLiam Girdwood 	dpcm->fe = fe;
113401d7584cSLiam Girdwood 	be->dpcm[stream].runtime = fe->dpcm[stream].runtime;
113501d7584cSLiam Girdwood 	dpcm->state = SND_SOC_DPCM_LINK_STATE_NEW;
1136a9764869SKaiChieh Chuang 	spin_lock_irqsave(&fe->card->dpcm_lock, flags);
113701d7584cSLiam Girdwood 	list_add(&dpcm->list_be, &fe->dpcm[stream].be_clients);
113801d7584cSLiam Girdwood 	list_add(&dpcm->list_fe, &be->dpcm[stream].fe_clients);
1139a9764869SKaiChieh Chuang 	spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
114001d7584cSLiam Girdwood 
114101d7584cSLiam Girdwood 	dev_dbg(fe->dev, "connected new DPCM %s path %s %s %s\n",
114201d7584cSLiam Girdwood 			stream ? "capture" : "playback",  fe->dai_link->name,
114301d7584cSLiam Girdwood 			stream ? "<-" : "->", be->dai_link->name);
114401d7584cSLiam Girdwood 
1145154dae87SKuninori Morimoto 	dpcm_create_debugfs_state(dpcm, stream);
1146154dae87SKuninori Morimoto 
114701d7584cSLiam Girdwood 	return 1;
114801d7584cSLiam Girdwood }
114901d7584cSLiam Girdwood 
115001d7584cSLiam Girdwood /* reparent a BE onto another FE */
115101d7584cSLiam Girdwood static void dpcm_be_reparent(struct snd_soc_pcm_runtime *fe,
115201d7584cSLiam Girdwood 			struct snd_soc_pcm_runtime *be, int stream)
115301d7584cSLiam Girdwood {
115401d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
115501d7584cSLiam Girdwood 	struct snd_pcm_substream *fe_substream, *be_substream;
115601d7584cSLiam Girdwood 
115701d7584cSLiam Girdwood 	/* reparent if BE is connected to other FEs */
115801d7584cSLiam Girdwood 	if (!be->dpcm[stream].users)
115901d7584cSLiam Girdwood 		return;
116001d7584cSLiam Girdwood 
116101d7584cSLiam Girdwood 	be_substream = snd_soc_dpcm_get_substream(be, stream);
116201d7584cSLiam Girdwood 
1163d2e24d64SKuninori Morimoto 	for_each_dpcm_fe(be, stream, dpcm) {
116401d7584cSLiam Girdwood 		if (dpcm->fe == fe)
116501d7584cSLiam Girdwood 			continue;
116601d7584cSLiam Girdwood 
116701d7584cSLiam Girdwood 		dev_dbg(fe->dev, "reparent %s path %s %s %s\n",
116801d7584cSLiam Girdwood 			stream ? "capture" : "playback",
116901d7584cSLiam Girdwood 			dpcm->fe->dai_link->name,
117001d7584cSLiam Girdwood 			stream ? "<-" : "->", dpcm->be->dai_link->name);
117101d7584cSLiam Girdwood 
117201d7584cSLiam Girdwood 		fe_substream = snd_soc_dpcm_get_substream(dpcm->fe, stream);
117301d7584cSLiam Girdwood 		be_substream->runtime = fe_substream->runtime;
117401d7584cSLiam Girdwood 		break;
117501d7584cSLiam Girdwood 	}
117601d7584cSLiam Girdwood }
117701d7584cSLiam Girdwood 
117801d7584cSLiam Girdwood /* disconnect a BE and FE */
117923607025SLiam Girdwood void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream)
118001d7584cSLiam Girdwood {
118101d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm, *d;
1182a9764869SKaiChieh Chuang 	unsigned long flags;
118301d7584cSLiam Girdwood 
11848d6258a4SKuninori Morimoto 	for_each_dpcm_be_safe(fe, stream, dpcm, d) {
1185103d84a3SLiam Girdwood 		dev_dbg(fe->dev, "ASoC: BE %s disconnect check for %s\n",
118601d7584cSLiam Girdwood 				stream ? "capture" : "playback",
118701d7584cSLiam Girdwood 				dpcm->be->dai_link->name);
118801d7584cSLiam Girdwood 
118901d7584cSLiam Girdwood 		if (dpcm->state != SND_SOC_DPCM_LINK_STATE_FREE)
119001d7584cSLiam Girdwood 			continue;
119101d7584cSLiam Girdwood 
119201d7584cSLiam Girdwood 		dev_dbg(fe->dev, "freed DSP %s path %s %s %s\n",
119301d7584cSLiam Girdwood 			stream ? "capture" : "playback", fe->dai_link->name,
119401d7584cSLiam Girdwood 			stream ? "<-" : "->", dpcm->be->dai_link->name);
119501d7584cSLiam Girdwood 
119601d7584cSLiam Girdwood 		/* BEs still alive need new FE */
119701d7584cSLiam Girdwood 		dpcm_be_reparent(fe, dpcm->be, stream);
119801d7584cSLiam Girdwood 
1199154dae87SKuninori Morimoto 		dpcm_remove_debugfs_state(dpcm);
1200154dae87SKuninori Morimoto 
1201a9764869SKaiChieh Chuang 		spin_lock_irqsave(&fe->card->dpcm_lock, flags);
120201d7584cSLiam Girdwood 		list_del(&dpcm->list_be);
120301d7584cSLiam Girdwood 		list_del(&dpcm->list_fe);
1204a9764869SKaiChieh Chuang 		spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
120501d7584cSLiam Girdwood 		kfree(dpcm);
120601d7584cSLiam Girdwood 	}
120701d7584cSLiam Girdwood }
120801d7584cSLiam Girdwood 
120901d7584cSLiam Girdwood /* get BE for DAI widget and stream */
121001d7584cSLiam Girdwood static struct snd_soc_pcm_runtime *dpcm_get_be(struct snd_soc_card *card,
121101d7584cSLiam Girdwood 		struct snd_soc_dapm_widget *widget, int stream)
121201d7584cSLiam Girdwood {
121301d7584cSLiam Girdwood 	struct snd_soc_pcm_runtime *be;
121493597faeSKuninori Morimoto 	struct snd_soc_dapm_widget *w;
12157afecb30SKuninori Morimoto 	struct snd_soc_dai *dai;
12161a497983SMengdong Lin 	int i;
121701d7584cSLiam Girdwood 
12183c146465SLiam Girdwood 	dev_dbg(card->dev, "ASoC: find BE for widget %s\n", widget->name);
12193c146465SLiam Girdwood 
1220bcb1fd1fSKuninori Morimoto 	for_each_card_rtds(card, be) {
122101d7584cSLiam Girdwood 
122235ea0655SLiam Girdwood 		if (!be->dai_link->no_pcm)
122335ea0655SLiam Girdwood 			continue;
122435ea0655SLiam Girdwood 
1225c840f769SKuninori Morimoto 		for_each_rtd_dais(be, i, dai) {
122619bdcc7aSShreyas NC 			w = snd_soc_dai_get_widget(dai, stream);
122793597faeSKuninori Morimoto 
12283c146465SLiam Girdwood 			dev_dbg(card->dev, "ASoC: try BE : %s\n",
122993597faeSKuninori Morimoto 				w ? w->name : "(not set)");
12303c146465SLiam Girdwood 
123193597faeSKuninori Morimoto 			if (w == widget)
123201d7584cSLiam Girdwood 				return be;
123319bdcc7aSShreyas NC 		}
123401d7584cSLiam Girdwood 	}
123501d7584cSLiam Girdwood 
12369d6ee365SJerome Brunet 	/* Widget provided is not a BE */
123701d7584cSLiam Girdwood 	return NULL;
123801d7584cSLiam Girdwood }
123901d7584cSLiam Girdwood 
124001d7584cSLiam Girdwood static int widget_in_list(struct snd_soc_dapm_widget_list *list,
124101d7584cSLiam Girdwood 		struct snd_soc_dapm_widget *widget)
124201d7584cSLiam Girdwood {
124309e88f8aSKuninori Morimoto 	struct snd_soc_dapm_widget *w;
124401d7584cSLiam Girdwood 	int i;
124501d7584cSLiam Girdwood 
124609e88f8aSKuninori Morimoto 	for_each_dapm_widgets(list, i, w)
124709e88f8aSKuninori Morimoto 		if (widget == w)
124801d7584cSLiam Girdwood 			return 1;
124901d7584cSLiam Girdwood 
125001d7584cSLiam Girdwood 	return 0;
125101d7584cSLiam Girdwood }
125201d7584cSLiam Girdwood 
12535fdd022cSPiotr Stankiewicz static bool dpcm_end_walk_at_be(struct snd_soc_dapm_widget *widget,
12545fdd022cSPiotr Stankiewicz 		enum snd_soc_dapm_direction dir)
12555fdd022cSPiotr Stankiewicz {
12565fdd022cSPiotr Stankiewicz 	struct snd_soc_card *card = widget->dapm->card;
12575fdd022cSPiotr Stankiewicz 	struct snd_soc_pcm_runtime *rtd;
1258c2cd8216SKuninori Morimoto 	int stream;
12595fdd022cSPiotr Stankiewicz 
1260c2cd8216SKuninori Morimoto 	/* adjust dir to stream */
1261c2cd8216SKuninori Morimoto 	if (dir == SND_SOC_DAPM_DIR_OUT)
1262c2cd8216SKuninori Morimoto 		stream = SNDRV_PCM_STREAM_PLAYBACK;
1263c2cd8216SKuninori Morimoto 	else
1264c2cd8216SKuninori Morimoto 		stream = SNDRV_PCM_STREAM_CAPTURE;
1265c2cd8216SKuninori Morimoto 
1266027a4838SKuninori Morimoto 	rtd = dpcm_get_be(card, widget, stream);
1267027a4838SKuninori Morimoto 	if (rtd)
12685fdd022cSPiotr Stankiewicz 		return true;
12695fdd022cSPiotr Stankiewicz 
12705fdd022cSPiotr Stankiewicz 	return false;
12715fdd022cSPiotr Stankiewicz }
12725fdd022cSPiotr Stankiewicz 
127323607025SLiam Girdwood int dpcm_path_get(struct snd_soc_pcm_runtime *fe,
12741ce43acfSLars-Peter Clausen 	int stream, struct snd_soc_dapm_widget_list **list)
127501d7584cSLiam Girdwood {
1276c2233a26SKuninori Morimoto 	struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0);
127701d7584cSLiam Girdwood 	int paths;
127801d7584cSLiam Girdwood 
12796e1276a5SBard Liao 	if (fe->num_cpus > 1) {
12806e1276a5SBard Liao 		dev_err(fe->dev,
12816e1276a5SBard Liao 			"%s doesn't support Multi CPU yet\n", __func__);
12826e1276a5SBard Liao 		return -EINVAL;
12836e1276a5SBard Liao 	}
12846e1276a5SBard Liao 
128501d7584cSLiam Girdwood 	/* get number of valid DAI paths and their widgets */
12866742064aSPiotr Stankiewicz 	paths = snd_soc_dapm_dai_get_connected_widgets(cpu_dai, stream, list,
12875fdd022cSPiotr Stankiewicz 			dpcm_end_walk_at_be);
128801d7584cSLiam Girdwood 
1289103d84a3SLiam Girdwood 	dev_dbg(fe->dev, "ASoC: found %d audio %s paths\n", paths,
129001d7584cSLiam Girdwood 			stream ? "capture" : "playback");
129101d7584cSLiam Girdwood 
129201d7584cSLiam Girdwood 	return paths;
129301d7584cSLiam Girdwood }
129401d7584cSLiam Girdwood 
129552645e33SKuninori Morimoto void dpcm_path_put(struct snd_soc_dapm_widget_list **list)
129652645e33SKuninori Morimoto {
129752645e33SKuninori Morimoto 	snd_soc_dapm_dai_free_widgets(list);
129852645e33SKuninori Morimoto }
129952645e33SKuninori Morimoto 
13008cce6569SGuennadi Liakhovetski static bool dpcm_be_is_active(struct snd_soc_dpcm *dpcm, int stream,
13018cce6569SGuennadi Liakhovetski 			      struct snd_soc_dapm_widget_list *list)
130201d7584cSLiam Girdwood {
130301d7584cSLiam Girdwood 	struct snd_soc_dapm_widget *widget;
13047afecb30SKuninori Morimoto 	struct snd_soc_dai *dai;
13052e5894d7SBenoit Cousson 	unsigned int i;
130601d7584cSLiam Girdwood 
1307c840f769SKuninori Morimoto 	/* is there a valid DAI widget for this BE */
1308c840f769SKuninori Morimoto 	for_each_rtd_dais(dpcm->be, i, dai) {
130919bdcc7aSShreyas NC 		widget = snd_soc_dai_get_widget(dai, stream);
131001d7584cSLiam Girdwood 
131119bdcc7aSShreyas NC 		/*
1312c840f769SKuninori Morimoto 		 * The BE is pruned only if none of the dai
131319bdcc7aSShreyas NC 		 * widgets are in the active list.
131419bdcc7aSShreyas NC 		 */
131501d7584cSLiam Girdwood 		if (widget && widget_in_list(list, widget))
13168cce6569SGuennadi Liakhovetski 			return true;
131719bdcc7aSShreyas NC 	}
131801d7584cSLiam Girdwood 
13198cce6569SGuennadi Liakhovetski 	return false;
13208cce6569SGuennadi Liakhovetski }
13218cce6569SGuennadi Liakhovetski 
13228cce6569SGuennadi Liakhovetski static int dpcm_prune_paths(struct snd_soc_pcm_runtime *fe, int stream,
13238cce6569SGuennadi Liakhovetski 			    struct snd_soc_dapm_widget_list **list_)
13248cce6569SGuennadi Liakhovetski {
13258cce6569SGuennadi Liakhovetski 	struct snd_soc_dpcm *dpcm;
13268cce6569SGuennadi Liakhovetski 	int prune = 0;
13278cce6569SGuennadi Liakhovetski 
13288cce6569SGuennadi Liakhovetski 	/* Destroy any old FE <--> BE connections */
13298cce6569SGuennadi Liakhovetski 	for_each_dpcm_be(fe, stream, dpcm) {
13308cce6569SGuennadi Liakhovetski 		if (dpcm_be_is_active(dpcm, stream, *list_))
1331bed646dcSKuninori Morimoto 			continue;
133201d7584cSLiam Girdwood 
1333103d84a3SLiam Girdwood 		dev_dbg(fe->dev, "ASoC: pruning %s BE %s for %s\n",
133401d7584cSLiam Girdwood 			stream ? "capture" : "playback",
133501d7584cSLiam Girdwood 			dpcm->be->dai_link->name, fe->dai_link->name);
133601d7584cSLiam Girdwood 		dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
133701d7584cSLiam Girdwood 		dpcm->be->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_BE;
133801d7584cSLiam Girdwood 		prune++;
133901d7584cSLiam Girdwood 	}
134001d7584cSLiam Girdwood 
1341103d84a3SLiam Girdwood 	dev_dbg(fe->dev, "ASoC: found %d old BE paths for pruning\n", prune);
134201d7584cSLiam Girdwood 	return prune;
134301d7584cSLiam Girdwood }
134401d7584cSLiam Girdwood 
134501d7584cSLiam Girdwood static int dpcm_add_paths(struct snd_soc_pcm_runtime *fe, int stream,
134601d7584cSLiam Girdwood 	struct snd_soc_dapm_widget_list **list_)
134701d7584cSLiam Girdwood {
134801d7584cSLiam Girdwood 	struct snd_soc_card *card = fe->card;
134901d7584cSLiam Girdwood 	struct snd_soc_dapm_widget_list *list = *list_;
135001d7584cSLiam Girdwood 	struct snd_soc_pcm_runtime *be;
135109e88f8aSKuninori Morimoto 	struct snd_soc_dapm_widget *widget;
135201d7584cSLiam Girdwood 	int i, new = 0, err;
135301d7584cSLiam Girdwood 
135401d7584cSLiam Girdwood 	/* Create any new FE <--> BE connections */
135509e88f8aSKuninori Morimoto 	for_each_dapm_widgets(list, i, widget) {
135601d7584cSLiam Girdwood 
135709e88f8aSKuninori Morimoto 		switch (widget->id) {
13584616274dSMark Brown 		case snd_soc_dapm_dai_in:
1359c5b8540dSKoro Chen 			if (stream != SNDRV_PCM_STREAM_PLAYBACK)
1360c5b8540dSKoro Chen 				continue;
1361c5b8540dSKoro Chen 			break;
13624616274dSMark Brown 		case snd_soc_dapm_dai_out:
1363c5b8540dSKoro Chen 			if (stream != SNDRV_PCM_STREAM_CAPTURE)
1364c5b8540dSKoro Chen 				continue;
13654616274dSMark Brown 			break;
13664616274dSMark Brown 		default:
136701d7584cSLiam Girdwood 			continue;
13684616274dSMark Brown 		}
136901d7584cSLiam Girdwood 
137001d7584cSLiam Girdwood 		/* is there a valid BE rtd for this widget */
137109e88f8aSKuninori Morimoto 		be = dpcm_get_be(card, widget, stream);
137201d7584cSLiam Girdwood 		if (!be) {
1373103d84a3SLiam Girdwood 			dev_err(fe->dev, "ASoC: no BE found for %s\n",
137409e88f8aSKuninori Morimoto 					widget->name);
137501d7584cSLiam Girdwood 			continue;
137601d7584cSLiam Girdwood 		}
137701d7584cSLiam Girdwood 
137801d7584cSLiam Girdwood 		/* don't connect if FE is not running */
137923607025SLiam Girdwood 		if (!fe->dpcm[stream].runtime && !fe->fe_compr)
138001d7584cSLiam Girdwood 			continue;
138101d7584cSLiam Girdwood 
138201d7584cSLiam Girdwood 		/* newly connected FE and BE */
138301d7584cSLiam Girdwood 		err = dpcm_be_connect(fe, be, stream);
138401d7584cSLiam Girdwood 		if (err < 0) {
1385103d84a3SLiam Girdwood 			dev_err(fe->dev, "ASoC: can't connect %s\n",
138609e88f8aSKuninori Morimoto 				widget->name);
138701d7584cSLiam Girdwood 			break;
138801d7584cSLiam Girdwood 		} else if (err == 0) /* already connected */
138901d7584cSLiam Girdwood 			continue;
139001d7584cSLiam Girdwood 
139101d7584cSLiam Girdwood 		/* new */
139201d7584cSLiam Girdwood 		be->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_BE;
139301d7584cSLiam Girdwood 		new++;
139401d7584cSLiam Girdwood 	}
139501d7584cSLiam Girdwood 
1396103d84a3SLiam Girdwood 	dev_dbg(fe->dev, "ASoC: found %d new BE paths\n", new);
139701d7584cSLiam Girdwood 	return new;
139801d7584cSLiam Girdwood }
139901d7584cSLiam Girdwood 
140001d7584cSLiam Girdwood /*
140101d7584cSLiam Girdwood  * Find the corresponding BE DAIs that source or sink audio to this
140201d7584cSLiam Girdwood  * FE substream.
140301d7584cSLiam Girdwood  */
140423607025SLiam Girdwood int dpcm_process_paths(struct snd_soc_pcm_runtime *fe,
140501d7584cSLiam Girdwood 	int stream, struct snd_soc_dapm_widget_list **list, int new)
140601d7584cSLiam Girdwood {
140701d7584cSLiam Girdwood 	if (new)
140801d7584cSLiam Girdwood 		return dpcm_add_paths(fe, stream, list);
140901d7584cSLiam Girdwood 	else
141001d7584cSLiam Girdwood 		return dpcm_prune_paths(fe, stream, list);
141101d7584cSLiam Girdwood }
141201d7584cSLiam Girdwood 
141323607025SLiam Girdwood void dpcm_clear_pending_state(struct snd_soc_pcm_runtime *fe, int stream)
141401d7584cSLiam Girdwood {
141501d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
1416a9764869SKaiChieh Chuang 	unsigned long flags;
141701d7584cSLiam Girdwood 
1418a9764869SKaiChieh Chuang 	spin_lock_irqsave(&fe->card->dpcm_lock, flags);
14198d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm)
142001d7584cSLiam Girdwood 		dpcm->be->dpcm[stream].runtime_update =
142101d7584cSLiam Girdwood 						SND_SOC_DPCM_UPDATE_NO;
1422a9764869SKaiChieh Chuang 	spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
142301d7584cSLiam Girdwood }
142401d7584cSLiam Girdwood 
142501d7584cSLiam Girdwood static void dpcm_be_dai_startup_unwind(struct snd_soc_pcm_runtime *fe,
142601d7584cSLiam Girdwood 	int stream)
142701d7584cSLiam Girdwood {
142801d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
142901d7584cSLiam Girdwood 
143001d7584cSLiam Girdwood 	/* disable any enabled and non active backends */
14318d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
143201d7584cSLiam Girdwood 
143301d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be = dpcm->be;
143401d7584cSLiam Girdwood 		struct snd_pcm_substream *be_substream =
143501d7584cSLiam Girdwood 			snd_soc_dpcm_get_substream(be, stream);
143601d7584cSLiam Girdwood 
143701d7584cSLiam Girdwood 		if (be->dpcm[stream].users == 0)
1438103d84a3SLiam Girdwood 			dev_err(be->dev, "ASoC: no users %s at close - state %d\n",
143901d7584cSLiam Girdwood 				stream ? "capture" : "playback",
144001d7584cSLiam Girdwood 				be->dpcm[stream].state);
144101d7584cSLiam Girdwood 
144201d7584cSLiam Girdwood 		if (--be->dpcm[stream].users != 0)
144301d7584cSLiam Girdwood 			continue;
144401d7584cSLiam Girdwood 
144501d7584cSLiam Girdwood 		if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN)
144601d7584cSLiam Girdwood 			continue;
144701d7584cSLiam Girdwood 
144801d7584cSLiam Girdwood 		soc_pcm_close(be_substream);
144901d7584cSLiam Girdwood 		be_substream->runtime = NULL;
145001d7584cSLiam Girdwood 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
145101d7584cSLiam Girdwood 	}
145201d7584cSLiam Girdwood }
145301d7584cSLiam Girdwood 
145423607025SLiam Girdwood int dpcm_be_dai_startup(struct snd_soc_pcm_runtime *fe, int stream)
145501d7584cSLiam Girdwood {
145601d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
145701d7584cSLiam Girdwood 	int err, count = 0;
145801d7584cSLiam Girdwood 
145901d7584cSLiam Girdwood 	/* only startup BE DAIs that are either sinks or sources to this FE DAI */
14608d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
146101d7584cSLiam Girdwood 
146201d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be = dpcm->be;
146301d7584cSLiam Girdwood 		struct snd_pcm_substream *be_substream =
146401d7584cSLiam Girdwood 			snd_soc_dpcm_get_substream(be, stream);
146501d7584cSLiam Girdwood 
14662062b4c5SRussell King - ARM Linux 		if (!be_substream) {
14672062b4c5SRussell King - ARM Linux 			dev_err(be->dev, "ASoC: no backend %s stream\n",
14682062b4c5SRussell King - ARM Linux 				stream ? "capture" : "playback");
14692062b4c5SRussell King - ARM Linux 			continue;
14702062b4c5SRussell King - ARM Linux 		}
14712062b4c5SRussell King - ARM Linux 
147201d7584cSLiam Girdwood 		/* is this op for this BE ? */
147301d7584cSLiam Girdwood 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
147401d7584cSLiam Girdwood 			continue;
147501d7584cSLiam Girdwood 
147601d7584cSLiam Girdwood 		/* first time the dpcm is open ? */
147701d7584cSLiam Girdwood 		if (be->dpcm[stream].users == DPCM_MAX_BE_USERS)
1478103d84a3SLiam Girdwood 			dev_err(be->dev, "ASoC: too many users %s at open %d\n",
147901d7584cSLiam Girdwood 				stream ? "capture" : "playback",
148001d7584cSLiam Girdwood 				be->dpcm[stream].state);
148101d7584cSLiam Girdwood 
148201d7584cSLiam Girdwood 		if (be->dpcm[stream].users++ != 0)
148301d7584cSLiam Girdwood 			continue;
148401d7584cSLiam Girdwood 
148501d7584cSLiam Girdwood 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_NEW) &&
148601d7584cSLiam Girdwood 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_CLOSE))
148701d7584cSLiam Girdwood 			continue;
148801d7584cSLiam Girdwood 
14892062b4c5SRussell King - ARM Linux 		dev_dbg(be->dev, "ASoC: open %s BE %s\n",
14902062b4c5SRussell King - ARM Linux 			stream ? "capture" : "playback", be->dai_link->name);
149101d7584cSLiam Girdwood 
149201d7584cSLiam Girdwood 		be_substream->runtime = be->dpcm[stream].runtime;
149301d7584cSLiam Girdwood 		err = soc_pcm_open(be_substream);
149401d7584cSLiam Girdwood 		if (err < 0) {
1495103d84a3SLiam Girdwood 			dev_err(be->dev, "ASoC: BE open failed %d\n", err);
149601d7584cSLiam Girdwood 			be->dpcm[stream].users--;
149701d7584cSLiam Girdwood 			if (be->dpcm[stream].users < 0)
1498103d84a3SLiam Girdwood 				dev_err(be->dev, "ASoC: no users %s at unwind %d\n",
149901d7584cSLiam Girdwood 					stream ? "capture" : "playback",
150001d7584cSLiam Girdwood 					be->dpcm[stream].state);
150101d7584cSLiam Girdwood 
150201d7584cSLiam Girdwood 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
150301d7584cSLiam Girdwood 			goto unwind;
150401d7584cSLiam Girdwood 		}
150501d7584cSLiam Girdwood 
150601d7584cSLiam Girdwood 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
150701d7584cSLiam Girdwood 		count++;
150801d7584cSLiam Girdwood 	}
150901d7584cSLiam Girdwood 
151001d7584cSLiam Girdwood 	return count;
151101d7584cSLiam Girdwood 
151201d7584cSLiam Girdwood unwind:
151301d7584cSLiam Girdwood 	/* disable any enabled and non active backends */
15148d6258a4SKuninori Morimoto 	for_each_dpcm_be_rollback(fe, stream, dpcm) {
151501d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be = dpcm->be;
151601d7584cSLiam Girdwood 		struct snd_pcm_substream *be_substream =
151701d7584cSLiam Girdwood 			snd_soc_dpcm_get_substream(be, stream);
151801d7584cSLiam Girdwood 
151901d7584cSLiam Girdwood 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
152001d7584cSLiam Girdwood 			continue;
152101d7584cSLiam Girdwood 
152201d7584cSLiam Girdwood 		if (be->dpcm[stream].users == 0)
1523103d84a3SLiam Girdwood 			dev_err(be->dev, "ASoC: no users %s at close %d\n",
152401d7584cSLiam Girdwood 				stream ? "capture" : "playback",
152501d7584cSLiam Girdwood 				be->dpcm[stream].state);
152601d7584cSLiam Girdwood 
152701d7584cSLiam Girdwood 		if (--be->dpcm[stream].users != 0)
152801d7584cSLiam Girdwood 			continue;
152901d7584cSLiam Girdwood 
153001d7584cSLiam Girdwood 		if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN)
153101d7584cSLiam Girdwood 			continue;
153201d7584cSLiam Girdwood 
153301d7584cSLiam Girdwood 		soc_pcm_close(be_substream);
153401d7584cSLiam Girdwood 		be_substream->runtime = NULL;
153501d7584cSLiam Girdwood 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
153601d7584cSLiam Girdwood 	}
153701d7584cSLiam Girdwood 
153801d7584cSLiam Girdwood 	return err;
153901d7584cSLiam Girdwood }
154001d7584cSLiam Girdwood 
154108ae9b45SLars-Peter Clausen static void dpcm_init_runtime_hw(struct snd_pcm_runtime *runtime,
1542435ffb76SJerome Brunet 				 struct snd_soc_pcm_stream *stream)
154308ae9b45SLars-Peter Clausen {
154408ae9b45SLars-Peter Clausen 	runtime->hw.rate_min = stream->rate_min;
1545e33ffbd9SCharles Keepax 	runtime->hw.rate_max = min_not_zero(stream->rate_max, UINT_MAX);
154608ae9b45SLars-Peter Clausen 	runtime->hw.channels_min = stream->channels_min;
154708ae9b45SLars-Peter Clausen 	runtime->hw.channels_max = stream->channels_max;
1548002220a9SLars-Peter Clausen 	if (runtime->hw.formats)
1549435ffb76SJerome Brunet 		runtime->hw.formats &= stream->formats;
1550002220a9SLars-Peter Clausen 	else
1551435ffb76SJerome Brunet 		runtime->hw.formats = stream->formats;
155208ae9b45SLars-Peter Clausen 	runtime->hw.rates = stream->rates;
155308ae9b45SLars-Peter Clausen }
155408ae9b45SLars-Peter Clausen 
1555435ffb76SJerome Brunet static void dpcm_runtime_merge_format(struct snd_pcm_substream *substream,
1556435ffb76SJerome Brunet 				      u64 *formats)
1557b073ed4eSKuninori Morimoto {
15580ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1559b073ed4eSKuninori Morimoto 	struct snd_soc_dpcm *dpcm;
15607afecb30SKuninori Morimoto 	struct snd_soc_dai *dai;
1561b073ed4eSKuninori Morimoto 	int stream = substream->stream;
1562b073ed4eSKuninori Morimoto 
1563b073ed4eSKuninori Morimoto 	if (!fe->dai_link->dpcm_merged_format)
1564435ffb76SJerome Brunet 		return;
1565b073ed4eSKuninori Morimoto 
1566b073ed4eSKuninori Morimoto 	/*
1567b073ed4eSKuninori Morimoto 	 * It returns merged BE codec format
1568b073ed4eSKuninori Morimoto 	 * if FE want to use it (= dpcm_merged_format)
1569b073ed4eSKuninori Morimoto 	 */
1570b073ed4eSKuninori Morimoto 
15718d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
1572b073ed4eSKuninori Morimoto 		struct snd_soc_pcm_runtime *be = dpcm->be;
1573b073ed4eSKuninori Morimoto 		struct snd_soc_pcm_stream *codec_stream;
1574b073ed4eSKuninori Morimoto 		int i;
1575b073ed4eSKuninori Morimoto 
1576a4be4187SKuninori Morimoto 		for_each_rtd_codec_dais(be, i, dai) {
15774febced1SJerome Brunet 			/*
15784febced1SJerome Brunet 			 * Skip CODECs which don't support the current stream
15794febced1SJerome Brunet 			 * type. See soc_pcm_init_runtime_hw() for more details
15804febced1SJerome Brunet 			 */
15817afecb30SKuninori Morimoto 			if (!snd_soc_dai_stream_valid(dai, stream))
15824febced1SJerome Brunet 				continue;
15834febced1SJerome Brunet 
1584acf253c1SKuninori Morimoto 			codec_stream = snd_soc_dai_get_pcm_stream(dai, stream);
1585b073ed4eSKuninori Morimoto 
1586435ffb76SJerome Brunet 			*formats &= codec_stream->formats;
1587435ffb76SJerome Brunet 		}
1588b073ed4eSKuninori Morimoto 	}
1589b073ed4eSKuninori Morimoto }
1590b073ed4eSKuninori Morimoto 
1591435ffb76SJerome Brunet static void dpcm_runtime_merge_chan(struct snd_pcm_substream *substream,
1592f4c277b8SJiada Wang 				    unsigned int *channels_min,
1593f4c277b8SJiada Wang 				    unsigned int *channels_max)
1594f4c277b8SJiada Wang {
15950ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1596f4c277b8SJiada Wang 	struct snd_soc_dpcm *dpcm;
1597f4c277b8SJiada Wang 	int stream = substream->stream;
1598f4c277b8SJiada Wang 
1599f4c277b8SJiada Wang 	if (!fe->dai_link->dpcm_merged_chan)
1600f4c277b8SJiada Wang 		return;
1601f4c277b8SJiada Wang 
1602f4c277b8SJiada Wang 	/*
1603f4c277b8SJiada Wang 	 * It returns merged BE codec channel;
1604f4c277b8SJiada Wang 	 * if FE want to use it (= dpcm_merged_chan)
1605f4c277b8SJiada Wang 	 */
1606f4c277b8SJiada Wang 
16078d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
1608f4c277b8SJiada Wang 		struct snd_soc_pcm_runtime *be = dpcm->be;
1609f4c277b8SJiada Wang 		struct snd_soc_pcm_stream *codec_stream;
16104f2bd18bSJerome Brunet 		struct snd_soc_pcm_stream *cpu_stream;
161119bdcc7aSShreyas NC 		struct snd_soc_dai *dai;
161219bdcc7aSShreyas NC 		int i;
1613f4c277b8SJiada Wang 
1614a4be4187SKuninori Morimoto 		for_each_rtd_cpu_dais(be, i, dai) {
16150e9cf4c4SBard Liao 			/*
16160e9cf4c4SBard Liao 			 * Skip CPUs which don't support the current stream
16170e9cf4c4SBard Liao 			 * type. See soc_pcm_init_runtime_hw() for more details
16180e9cf4c4SBard Liao 			 */
16190e9cf4c4SBard Liao 			if (!snd_soc_dai_stream_valid(dai, stream))
16200e9cf4c4SBard Liao 				continue;
16210e9cf4c4SBard Liao 
162219bdcc7aSShreyas NC 			cpu_stream = snd_soc_dai_get_pcm_stream(dai, stream);
16234f2bd18bSJerome Brunet 
162419bdcc7aSShreyas NC 			*channels_min = max(*channels_min,
162519bdcc7aSShreyas NC 					    cpu_stream->channels_min);
162619bdcc7aSShreyas NC 			*channels_max = min(*channels_max,
162719bdcc7aSShreyas NC 					    cpu_stream->channels_max);
162819bdcc7aSShreyas NC 		}
16294f2bd18bSJerome Brunet 
16304f2bd18bSJerome Brunet 		/*
16314f2bd18bSJerome Brunet 		 * chan min/max cannot be enforced if there are multiple CODEC
16324f2bd18bSJerome Brunet 		 * DAIs connected to a single CPU DAI, use CPU DAI's directly
16334f2bd18bSJerome Brunet 		 */
16344f2bd18bSJerome Brunet 		if (be->num_codecs == 1) {
1635c2233a26SKuninori Morimoto 			codec_stream = snd_soc_dai_get_pcm_stream(asoc_rtd_to_codec(be, 0), stream);
1636f4c277b8SJiada Wang 
1637f4c277b8SJiada Wang 			*channels_min = max(*channels_min,
1638f4c277b8SJiada Wang 					    codec_stream->channels_min);
1639f4c277b8SJiada Wang 			*channels_max = min(*channels_max,
1640f4c277b8SJiada Wang 					    codec_stream->channels_max);
1641f4c277b8SJiada Wang 		}
1642f4c277b8SJiada Wang 	}
1643f4c277b8SJiada Wang }
1644f4c277b8SJiada Wang 
1645baacd8d1SJerome Brunet static void dpcm_runtime_merge_rate(struct snd_pcm_substream *substream,
1646baacd8d1SJerome Brunet 				    unsigned int *rates,
1647baacd8d1SJerome Brunet 				    unsigned int *rate_min,
1648baacd8d1SJerome Brunet 				    unsigned int *rate_max)
1649baacd8d1SJerome Brunet {
16500ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1651baacd8d1SJerome Brunet 	struct snd_soc_dpcm *dpcm;
1652baacd8d1SJerome Brunet 	int stream = substream->stream;
1653baacd8d1SJerome Brunet 
1654baacd8d1SJerome Brunet 	if (!fe->dai_link->dpcm_merged_rate)
1655baacd8d1SJerome Brunet 		return;
1656baacd8d1SJerome Brunet 
1657baacd8d1SJerome Brunet 	/*
1658baacd8d1SJerome Brunet 	 * It returns merged BE codec channel;
1659baacd8d1SJerome Brunet 	 * if FE want to use it (= dpcm_merged_chan)
1660baacd8d1SJerome Brunet 	 */
1661baacd8d1SJerome Brunet 
16628d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
1663baacd8d1SJerome Brunet 		struct snd_soc_pcm_runtime *be = dpcm->be;
1664c840f769SKuninori Morimoto 		struct snd_soc_pcm_stream *pcm;
16657afecb30SKuninori Morimoto 		struct snd_soc_dai *dai;
1666baacd8d1SJerome Brunet 		int i;
1667baacd8d1SJerome Brunet 
1668c840f769SKuninori Morimoto 		for_each_rtd_dais(be, i, dai) {
16690e9cf4c4SBard Liao 			/*
1670c840f769SKuninori Morimoto 			 * Skip DAIs which don't support the current stream
16710e9cf4c4SBard Liao 			 * type. See soc_pcm_init_runtime_hw() for more details
16720e9cf4c4SBard Liao 			 */
16730e9cf4c4SBard Liao 			if (!snd_soc_dai_stream_valid(dai, stream))
16740e9cf4c4SBard Liao 				continue;
16750e9cf4c4SBard Liao 
1676c840f769SKuninori Morimoto 			pcm = snd_soc_dai_get_pcm_stream(dai, stream);
1677baacd8d1SJerome Brunet 
1678c840f769SKuninori Morimoto 			*rate_min = max(*rate_min, pcm->rate_min);
1679c840f769SKuninori Morimoto 			*rate_max = min_not_zero(*rate_max, pcm->rate_max);
1680c840f769SKuninori Morimoto 			*rates = snd_pcm_rate_mask_intersect(*rates, pcm->rates);
1681baacd8d1SJerome Brunet 		}
1682baacd8d1SJerome Brunet 	}
1683baacd8d1SJerome Brunet }
1684baacd8d1SJerome Brunet 
168545c0a188SMark Brown static void dpcm_set_fe_runtime(struct snd_pcm_substream *substream)
168601d7584cSLiam Girdwood {
168701d7584cSLiam Girdwood 	struct snd_pcm_runtime *runtime = substream->runtime;
16880ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
168919bdcc7aSShreyas NC 	struct snd_soc_dai *cpu_dai;
169019bdcc7aSShreyas NC 	int i;
169101d7584cSLiam Girdwood 
1692a4be4187SKuninori Morimoto 	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
16930e9cf4c4SBard Liao 		/*
16940e9cf4c4SBard Liao 		 * Skip CPUs which don't support the current stream
16950e9cf4c4SBard Liao 		 * type. See soc_pcm_init_runtime_hw() for more details
16960e9cf4c4SBard Liao 		 */
16970e9cf4c4SBard Liao 		if (!snd_soc_dai_stream_valid(cpu_dai, substream->stream))
16980e9cf4c4SBard Liao 			continue;
16990e9cf4c4SBard Liao 
17000c9ba720SKuninori Morimoto 		dpcm_init_runtime_hw(runtime,
17010c9ba720SKuninori Morimoto 			snd_soc_dai_get_pcm_stream(cpu_dai,
17020c9ba720SKuninori Morimoto 						   substream->stream));
170319bdcc7aSShreyas NC 	}
1704f4c277b8SJiada Wang 
1705435ffb76SJerome Brunet 	dpcm_runtime_merge_format(substream, &runtime->hw.formats);
1706435ffb76SJerome Brunet 	dpcm_runtime_merge_chan(substream, &runtime->hw.channels_min,
1707435ffb76SJerome Brunet 				&runtime->hw.channels_max);
1708baacd8d1SJerome Brunet 	dpcm_runtime_merge_rate(substream, &runtime->hw.rates,
1709baacd8d1SJerome Brunet 				&runtime->hw.rate_min, &runtime->hw.rate_max);
171001d7584cSLiam Girdwood }
171101d7584cSLiam Girdwood 
1712ea9d0d77STakashi Iwai static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream *substream, int cmd);
1713ea9d0d77STakashi Iwai 
1714ea9d0d77STakashi Iwai /* Set FE's runtime_update state; the state is protected via PCM stream lock
1715ea9d0d77STakashi Iwai  * for avoiding the race with trigger callback.
1716ea9d0d77STakashi Iwai  * If the state is unset and a trigger is pending while the previous operation,
1717ea9d0d77STakashi Iwai  * process the pending trigger action here.
1718ea9d0d77STakashi Iwai  */
1719ea9d0d77STakashi Iwai static void dpcm_set_fe_update_state(struct snd_soc_pcm_runtime *fe,
1720ea9d0d77STakashi Iwai 				     int stream, enum snd_soc_dpcm_update state)
1721ea9d0d77STakashi Iwai {
1722ea9d0d77STakashi Iwai 	struct snd_pcm_substream *substream =
1723ea9d0d77STakashi Iwai 		snd_soc_dpcm_get_substream(fe, stream);
1724ea9d0d77STakashi Iwai 
1725ea9d0d77STakashi Iwai 	snd_pcm_stream_lock_irq(substream);
1726ea9d0d77STakashi Iwai 	if (state == SND_SOC_DPCM_UPDATE_NO && fe->dpcm[stream].trigger_pending) {
1727ea9d0d77STakashi Iwai 		dpcm_fe_dai_do_trigger(substream,
1728ea9d0d77STakashi Iwai 				       fe->dpcm[stream].trigger_pending - 1);
1729ea9d0d77STakashi Iwai 		fe->dpcm[stream].trigger_pending = 0;
1730ea9d0d77STakashi Iwai 	}
1731ea9d0d77STakashi Iwai 	fe->dpcm[stream].runtime_update = state;
1732ea9d0d77STakashi Iwai 	snd_pcm_stream_unlock_irq(substream);
1733ea9d0d77STakashi Iwai }
1734ea9d0d77STakashi Iwai 
1735906c7d69SPC Liao static int dpcm_apply_symmetry(struct snd_pcm_substream *fe_substream,
1736906c7d69SPC Liao 			       int stream)
1737906c7d69SPC Liao {
1738906c7d69SPC Liao 	struct snd_soc_dpcm *dpcm;
17390ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
174019bdcc7aSShreyas NC 	struct snd_soc_dai *fe_cpu_dai;
1741906c7d69SPC Liao 	int err;
174219bdcc7aSShreyas NC 	int i;
1743906c7d69SPC Liao 
1744906c7d69SPC Liao 	/* apply symmetry for FE */
1745906c7d69SPC Liao 	if (soc_pcm_has_symmetry(fe_substream))
1746906c7d69SPC Liao 		fe_substream->runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX;
1747906c7d69SPC Liao 
1748a4be4187SKuninori Morimoto 	for_each_rtd_cpu_dais (fe, i, fe_cpu_dai) {
1749906c7d69SPC Liao 		/* Symmetry only applies if we've got an active stream. */
1750b3dea624SKuninori Morimoto 		if (snd_soc_dai_active(fe_cpu_dai)) {
1751906c7d69SPC Liao 			err = soc_pcm_apply_symmetry(fe_substream, fe_cpu_dai);
1752906c7d69SPC Liao 			if (err < 0)
1753906c7d69SPC Liao 				return err;
1754906c7d69SPC Liao 		}
175519bdcc7aSShreyas NC 	}
1756906c7d69SPC Liao 
1757906c7d69SPC Liao 	/* apply symmetry for BE */
17588d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
1759906c7d69SPC Liao 		struct snd_soc_pcm_runtime *be = dpcm->be;
1760906c7d69SPC Liao 		struct snd_pcm_substream *be_substream =
1761906c7d69SPC Liao 			snd_soc_dpcm_get_substream(be, stream);
17626246f283SJerome Brunet 		struct snd_soc_pcm_runtime *rtd;
1763c840f769SKuninori Morimoto 		struct snd_soc_dai *dai;
1764906c7d69SPC Liao 		int i;
1765906c7d69SPC Liao 
17666246f283SJerome Brunet 		/* A backend may not have the requested substream */
17676246f283SJerome Brunet 		if (!be_substream)
17686246f283SJerome Brunet 			continue;
17696246f283SJerome Brunet 
17700ceef681SKuninori Morimoto 		rtd = asoc_substream_to_rtd(be_substream);
1771f1176614SJeeja KP 		if (rtd->dai_link->be_hw_params_fixup)
1772f1176614SJeeja KP 			continue;
1773f1176614SJeeja KP 
1774906c7d69SPC Liao 		if (soc_pcm_has_symmetry(be_substream))
1775906c7d69SPC Liao 			be_substream->runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX;
1776906c7d69SPC Liao 
1777906c7d69SPC Liao 		/* Symmetry only applies if we've got an active stream. */
1778c840f769SKuninori Morimoto 		for_each_rtd_dais(rtd, i, dai) {
1779b3dea624SKuninori Morimoto 			if (snd_soc_dai_active(dai)) {
1780c840f769SKuninori Morimoto 				err = soc_pcm_apply_symmetry(fe_substream, dai);
1781906c7d69SPC Liao 				if (err < 0)
1782906c7d69SPC Liao 					return err;
1783906c7d69SPC Liao 			}
1784906c7d69SPC Liao 		}
1785906c7d69SPC Liao 	}
1786906c7d69SPC Liao 
1787906c7d69SPC Liao 	return 0;
1788906c7d69SPC Liao }
1789906c7d69SPC Liao 
179001d7584cSLiam Girdwood static int dpcm_fe_dai_startup(struct snd_pcm_substream *fe_substream)
179101d7584cSLiam Girdwood {
17920ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
179301d7584cSLiam Girdwood 	struct snd_pcm_runtime *runtime = fe_substream->runtime;
179401d7584cSLiam Girdwood 	int stream = fe_substream->stream, ret = 0;
179501d7584cSLiam Girdwood 
1796ea9d0d77STakashi Iwai 	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
179701d7584cSLiam Girdwood 
179825c2f515SKuninori Morimoto 	ret = dpcm_be_dai_startup(fe, stream);
179901d7584cSLiam Girdwood 	if (ret < 0) {
1800103d84a3SLiam Girdwood 		dev_err(fe->dev,"ASoC: failed to start some BEs %d\n", ret);
180101d7584cSLiam Girdwood 		goto be_err;
180201d7584cSLiam Girdwood 	}
180301d7584cSLiam Girdwood 
1804103d84a3SLiam Girdwood 	dev_dbg(fe->dev, "ASoC: open FE %s\n", fe->dai_link->name);
180501d7584cSLiam Girdwood 
180601d7584cSLiam Girdwood 	/* start the DAI frontend */
180701d7584cSLiam Girdwood 	ret = soc_pcm_open(fe_substream);
180801d7584cSLiam Girdwood 	if (ret < 0) {
1809103d84a3SLiam Girdwood 		dev_err(fe->dev,"ASoC: failed to start FE %d\n", ret);
181001d7584cSLiam Girdwood 		goto unwind;
181101d7584cSLiam Girdwood 	}
181201d7584cSLiam Girdwood 
181301d7584cSLiam Girdwood 	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
181401d7584cSLiam Girdwood 
181501d7584cSLiam Girdwood 	dpcm_set_fe_runtime(fe_substream);
181601d7584cSLiam Girdwood 	snd_pcm_limit_hw_rates(runtime);
181701d7584cSLiam Girdwood 
1818906c7d69SPC Liao 	ret = dpcm_apply_symmetry(fe_substream, stream);
18198a01fbf0SKuninori Morimoto 	if (ret < 0)
1820906c7d69SPC Liao 		dev_err(fe->dev, "ASoC: failed to apply dpcm symmetry %d\n",
1821906c7d69SPC Liao 			ret);
182201d7584cSLiam Girdwood 
182301d7584cSLiam Girdwood unwind:
18248a01fbf0SKuninori Morimoto 	if (ret < 0)
182525c2f515SKuninori Morimoto 		dpcm_be_dai_startup_unwind(fe, stream);
182601d7584cSLiam Girdwood be_err:
1827ea9d0d77STakashi Iwai 	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
182801d7584cSLiam Girdwood 	return ret;
182901d7584cSLiam Girdwood }
183001d7584cSLiam Girdwood 
183123607025SLiam Girdwood int dpcm_be_dai_shutdown(struct snd_soc_pcm_runtime *fe, int stream)
183201d7584cSLiam Girdwood {
183301d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
183401d7584cSLiam Girdwood 
183501d7584cSLiam Girdwood 	/* only shutdown BEs that are either sinks or sources to this FE DAI */
18368d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
183701d7584cSLiam Girdwood 
183801d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be = dpcm->be;
183901d7584cSLiam Girdwood 		struct snd_pcm_substream *be_substream =
184001d7584cSLiam Girdwood 			snd_soc_dpcm_get_substream(be, stream);
184101d7584cSLiam Girdwood 
184201d7584cSLiam Girdwood 		/* is this op for this BE ? */
184301d7584cSLiam Girdwood 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
184401d7584cSLiam Girdwood 			continue;
184501d7584cSLiam Girdwood 
184601d7584cSLiam Girdwood 		if (be->dpcm[stream].users == 0)
1847103d84a3SLiam Girdwood 			dev_err(be->dev, "ASoC: no users %s at close - state %d\n",
184801d7584cSLiam Girdwood 				stream ? "capture" : "playback",
184901d7584cSLiam Girdwood 				be->dpcm[stream].state);
185001d7584cSLiam Girdwood 
185101d7584cSLiam Girdwood 		if (--be->dpcm[stream].users != 0)
185201d7584cSLiam Girdwood 			continue;
185301d7584cSLiam Girdwood 
185401d7584cSLiam Girdwood 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
18559c0ac70aSKai Chieh Chuang 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN)) {
18569c0ac70aSKai Chieh Chuang 			soc_pcm_hw_free(be_substream);
18579c0ac70aSKai Chieh Chuang 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
18589c0ac70aSKai Chieh Chuang 		}
185901d7584cSLiam Girdwood 
1860103d84a3SLiam Girdwood 		dev_dbg(be->dev, "ASoC: close BE %s\n",
186194d215ccS彭东林 			be->dai_link->name);
186201d7584cSLiam Girdwood 
186301d7584cSLiam Girdwood 		soc_pcm_close(be_substream);
186401d7584cSLiam Girdwood 		be_substream->runtime = NULL;
186501d7584cSLiam Girdwood 
186601d7584cSLiam Girdwood 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
186701d7584cSLiam Girdwood 	}
186801d7584cSLiam Girdwood 	return 0;
186901d7584cSLiam Girdwood }
187001d7584cSLiam Girdwood 
187101d7584cSLiam Girdwood static int dpcm_fe_dai_shutdown(struct snd_pcm_substream *substream)
187201d7584cSLiam Girdwood {
18730ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
187401d7584cSLiam Girdwood 	int stream = substream->stream;
187501d7584cSLiam Girdwood 
1876ea9d0d77STakashi Iwai 	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
187701d7584cSLiam Girdwood 
187801d7584cSLiam Girdwood 	/* shutdown the BEs */
187925c2f515SKuninori Morimoto 	dpcm_be_dai_shutdown(fe, stream);
188001d7584cSLiam Girdwood 
1881103d84a3SLiam Girdwood 	dev_dbg(fe->dev, "ASoC: close FE %s\n", fe->dai_link->name);
188201d7584cSLiam Girdwood 
188301d7584cSLiam Girdwood 	/* now shutdown the frontend */
188401d7584cSLiam Girdwood 	soc_pcm_close(substream);
188501d7584cSLiam Girdwood 
188601d7584cSLiam Girdwood 	/* run the stream event for each BE */
18871c531230SKuninori Morimoto 	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
188801d7584cSLiam Girdwood 
188901d7584cSLiam Girdwood 	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1890ea9d0d77STakashi Iwai 	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
189101d7584cSLiam Girdwood 	return 0;
189201d7584cSLiam Girdwood }
189301d7584cSLiam Girdwood 
189423607025SLiam Girdwood int dpcm_be_dai_hw_free(struct snd_soc_pcm_runtime *fe, int stream)
189501d7584cSLiam Girdwood {
189601d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
189701d7584cSLiam Girdwood 
189801d7584cSLiam Girdwood 	/* only hw_params backends that are either sinks or sources
189901d7584cSLiam Girdwood 	 * to this frontend DAI */
19008d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
190101d7584cSLiam Girdwood 
190201d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be = dpcm->be;
190301d7584cSLiam Girdwood 		struct snd_pcm_substream *be_substream =
190401d7584cSLiam Girdwood 			snd_soc_dpcm_get_substream(be, stream);
190501d7584cSLiam Girdwood 
190601d7584cSLiam Girdwood 		/* is this op for this BE ? */
190701d7584cSLiam Girdwood 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
190801d7584cSLiam Girdwood 			continue;
190901d7584cSLiam Girdwood 
191001d7584cSLiam Girdwood 		/* only free hw when no longer used - check all FEs */
191101d7584cSLiam Girdwood 		if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
191201d7584cSLiam Girdwood 				continue;
191301d7584cSLiam Girdwood 
191436fba62cSQiao Zhou 		/* do not free hw if this BE is used by other FE */
191536fba62cSQiao Zhou 		if (be->dpcm[stream].users > 1)
191636fba62cSQiao Zhou 			continue;
191736fba62cSQiao Zhou 
191801d7584cSLiam Girdwood 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
191901d7584cSLiam Girdwood 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
192001d7584cSLiam Girdwood 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
192108b27848SPatrick Lai 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED) &&
19225e82d2beSVinod Koul 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
19235e82d2beSVinod Koul 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
192401d7584cSLiam Girdwood 			continue;
192501d7584cSLiam Girdwood 
1926103d84a3SLiam Girdwood 		dev_dbg(be->dev, "ASoC: hw_free BE %s\n",
192794d215ccS彭东林 			be->dai_link->name);
192801d7584cSLiam Girdwood 
192901d7584cSLiam Girdwood 		soc_pcm_hw_free(be_substream);
193001d7584cSLiam Girdwood 
193101d7584cSLiam Girdwood 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
193201d7584cSLiam Girdwood 	}
193301d7584cSLiam Girdwood 
193401d7584cSLiam Girdwood 	return 0;
193501d7584cSLiam Girdwood }
193601d7584cSLiam Girdwood 
193745c0a188SMark Brown static int dpcm_fe_dai_hw_free(struct snd_pcm_substream *substream)
193801d7584cSLiam Girdwood {
19390ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
194001d7584cSLiam Girdwood 	int err, stream = substream->stream;
194101d7584cSLiam Girdwood 
194201d7584cSLiam Girdwood 	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
1943ea9d0d77STakashi Iwai 	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
194401d7584cSLiam Girdwood 
1945103d84a3SLiam Girdwood 	dev_dbg(fe->dev, "ASoC: hw_free FE %s\n", fe->dai_link->name);
194601d7584cSLiam Girdwood 
194701d7584cSLiam Girdwood 	/* call hw_free on the frontend */
194801d7584cSLiam Girdwood 	err = soc_pcm_hw_free(substream);
194901d7584cSLiam Girdwood 	if (err < 0)
1950103d84a3SLiam Girdwood 		dev_err(fe->dev,"ASoC: hw_free FE %s failed\n",
195101d7584cSLiam Girdwood 			fe->dai_link->name);
195201d7584cSLiam Girdwood 
195301d7584cSLiam Girdwood 	/* only hw_params backends that are either sinks or sources
195401d7584cSLiam Girdwood 	 * to this frontend DAI */
195501d7584cSLiam Girdwood 	err = dpcm_be_dai_hw_free(fe, stream);
195601d7584cSLiam Girdwood 
195701d7584cSLiam Girdwood 	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
1958ea9d0d77STakashi Iwai 	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
195901d7584cSLiam Girdwood 
196001d7584cSLiam Girdwood 	mutex_unlock(&fe->card->mutex);
196101d7584cSLiam Girdwood 	return 0;
196201d7584cSLiam Girdwood }
196301d7584cSLiam Girdwood 
196423607025SLiam Girdwood int dpcm_be_dai_hw_params(struct snd_soc_pcm_runtime *fe, int stream)
196501d7584cSLiam Girdwood {
196601d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
196701d7584cSLiam Girdwood 	int ret;
196801d7584cSLiam Girdwood 
19698d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
197001d7584cSLiam Girdwood 
197101d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be = dpcm->be;
197201d7584cSLiam Girdwood 		struct snd_pcm_substream *be_substream =
197301d7584cSLiam Girdwood 			snd_soc_dpcm_get_substream(be, stream);
197401d7584cSLiam Girdwood 
197501d7584cSLiam Girdwood 		/* is this op for this BE ? */
197601d7584cSLiam Girdwood 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
197701d7584cSLiam Girdwood 			continue;
197801d7584cSLiam Girdwood 
197901d7584cSLiam Girdwood 		/* copy params for each dpcm */
198001d7584cSLiam Girdwood 		memcpy(&dpcm->hw_params, &fe->dpcm[stream].hw_params,
198101d7584cSLiam Girdwood 				sizeof(struct snd_pcm_hw_params));
198201d7584cSLiam Girdwood 
198301d7584cSLiam Girdwood 		/* perform any hw_params fixups */
19840cbbf8a0SKuninori Morimoto 		ret = snd_soc_link_be_hw_params_fixup(be, &dpcm->hw_params);
19850cbbf8a0SKuninori Morimoto 		if (ret < 0)
198601d7584cSLiam Girdwood 			goto unwind;
198701d7584cSLiam Girdwood 
1988ae061d2aSLibin Yang 		/* copy the fixed-up hw params for BE dai */
1989ae061d2aSLibin Yang 		memcpy(&be->dpcm[stream].hw_params, &dpcm->hw_params,
1990ae061d2aSLibin Yang 		       sizeof(struct snd_pcm_hw_params));
1991ae061d2aSLibin Yang 
1992b0639bd2SKuninori Morimoto 		/* only allow hw_params() if no connected FEs are running */
1993b0639bd2SKuninori Morimoto 		if (!snd_soc_dpcm_can_be_params(fe, be, stream))
1994b0639bd2SKuninori Morimoto 			continue;
1995b0639bd2SKuninori Morimoto 
1996b0639bd2SKuninori Morimoto 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
1997b0639bd2SKuninori Morimoto 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
1998b0639bd2SKuninori Morimoto 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE))
1999b0639bd2SKuninori Morimoto 			continue;
2000b0639bd2SKuninori Morimoto 
2001b0639bd2SKuninori Morimoto 		dev_dbg(be->dev, "ASoC: hw_params BE %s\n",
200294d215ccS彭东林 			be->dai_link->name);
2003b0639bd2SKuninori Morimoto 
200401d7584cSLiam Girdwood 		ret = soc_pcm_hw_params(be_substream, &dpcm->hw_params);
200501d7584cSLiam Girdwood 		if (ret < 0) {
200601d7584cSLiam Girdwood 			dev_err(dpcm->be->dev,
2007103d84a3SLiam Girdwood 				"ASoC: hw_params BE failed %d\n", ret);
200801d7584cSLiam Girdwood 			goto unwind;
200901d7584cSLiam Girdwood 		}
201001d7584cSLiam Girdwood 
201101d7584cSLiam Girdwood 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
201201d7584cSLiam Girdwood 	}
201301d7584cSLiam Girdwood 	return 0;
201401d7584cSLiam Girdwood 
201501d7584cSLiam Girdwood unwind:
201601d7584cSLiam Girdwood 	/* disable any enabled and non active backends */
20178d6258a4SKuninori Morimoto 	for_each_dpcm_be_rollback(fe, stream, dpcm) {
201801d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be = dpcm->be;
201901d7584cSLiam Girdwood 		struct snd_pcm_substream *be_substream =
202001d7584cSLiam Girdwood 			snd_soc_dpcm_get_substream(be, stream);
202101d7584cSLiam Girdwood 
202201d7584cSLiam Girdwood 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
202301d7584cSLiam Girdwood 			continue;
202401d7584cSLiam Girdwood 
202501d7584cSLiam Girdwood 		/* only allow hw_free() if no connected FEs are running */
202601d7584cSLiam Girdwood 		if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
202701d7584cSLiam Girdwood 			continue;
202801d7584cSLiam Girdwood 
202901d7584cSLiam Girdwood 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
203001d7584cSLiam Girdwood 		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
203101d7584cSLiam Girdwood 		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
203201d7584cSLiam Girdwood 		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP))
203301d7584cSLiam Girdwood 			continue;
203401d7584cSLiam Girdwood 
203501d7584cSLiam Girdwood 		soc_pcm_hw_free(be_substream);
203601d7584cSLiam Girdwood 	}
203701d7584cSLiam Girdwood 
203801d7584cSLiam Girdwood 	return ret;
203901d7584cSLiam Girdwood }
204001d7584cSLiam Girdwood 
204145c0a188SMark Brown static int dpcm_fe_dai_hw_params(struct snd_pcm_substream *substream,
204201d7584cSLiam Girdwood 				 struct snd_pcm_hw_params *params)
204301d7584cSLiam Girdwood {
20440ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
204501d7584cSLiam Girdwood 	int ret, stream = substream->stream;
204601d7584cSLiam Girdwood 
204701d7584cSLiam Girdwood 	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
2048ea9d0d77STakashi Iwai 	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
204901d7584cSLiam Girdwood 
205025c2f515SKuninori Morimoto 	memcpy(&fe->dpcm[stream].hw_params, params,
205101d7584cSLiam Girdwood 			sizeof(struct snd_pcm_hw_params));
205225c2f515SKuninori Morimoto 	ret = dpcm_be_dai_hw_params(fe, stream);
205301d7584cSLiam Girdwood 	if (ret < 0) {
2054103d84a3SLiam Girdwood 		dev_err(fe->dev,"ASoC: hw_params BE failed %d\n", ret);
205501d7584cSLiam Girdwood 		goto out;
205601d7584cSLiam Girdwood 	}
205701d7584cSLiam Girdwood 
2058103d84a3SLiam Girdwood 	dev_dbg(fe->dev, "ASoC: hw_params FE %s rate %d chan %x fmt %d\n",
205901d7584cSLiam Girdwood 			fe->dai_link->name, params_rate(params),
206001d7584cSLiam Girdwood 			params_channels(params), params_format(params));
206101d7584cSLiam Girdwood 
206201d7584cSLiam Girdwood 	/* call hw_params on the frontend */
206301d7584cSLiam Girdwood 	ret = soc_pcm_hw_params(substream, params);
206401d7584cSLiam Girdwood 	if (ret < 0) {
2065103d84a3SLiam Girdwood 		dev_err(fe->dev,"ASoC: hw_params FE failed %d\n", ret);
206601d7584cSLiam Girdwood 		dpcm_be_dai_hw_free(fe, stream);
206701d7584cSLiam Girdwood 	 } else
206801d7584cSLiam Girdwood 		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
206901d7584cSLiam Girdwood 
207001d7584cSLiam Girdwood out:
2071ea9d0d77STakashi Iwai 	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
207201d7584cSLiam Girdwood 	mutex_unlock(&fe->card->mutex);
207301d7584cSLiam Girdwood 	return ret;
207401d7584cSLiam Girdwood }
207501d7584cSLiam Girdwood 
207601d7584cSLiam Girdwood static int dpcm_do_trigger(struct snd_soc_dpcm *dpcm,
207701d7584cSLiam Girdwood 		struct snd_pcm_substream *substream, int cmd)
207801d7584cSLiam Girdwood {
207901d7584cSLiam Girdwood 	int ret;
208001d7584cSLiam Girdwood 
2081103d84a3SLiam Girdwood 	dev_dbg(dpcm->be->dev, "ASoC: trigger BE %s cmd %d\n",
208294d215ccS彭东林 			dpcm->be->dai_link->name, cmd);
208301d7584cSLiam Girdwood 
208401d7584cSLiam Girdwood 	ret = soc_pcm_trigger(substream, cmd);
208501d7584cSLiam Girdwood 	if (ret < 0)
2086103d84a3SLiam Girdwood 		dev_err(dpcm->be->dev,"ASoC: trigger BE failed %d\n", ret);
208701d7584cSLiam Girdwood 
208801d7584cSLiam Girdwood 	return ret;
208901d7584cSLiam Girdwood }
209001d7584cSLiam Girdwood 
209123607025SLiam Girdwood int dpcm_be_dai_trigger(struct snd_soc_pcm_runtime *fe, int stream,
209245c0a188SMark Brown 			       int cmd)
209301d7584cSLiam Girdwood {
209401d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
209501d7584cSLiam Girdwood 	int ret = 0;
209601d7584cSLiam Girdwood 
20978d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
209801d7584cSLiam Girdwood 
209901d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be = dpcm->be;
210001d7584cSLiam Girdwood 		struct snd_pcm_substream *be_substream =
210101d7584cSLiam Girdwood 			snd_soc_dpcm_get_substream(be, stream);
210201d7584cSLiam Girdwood 
210301d7584cSLiam Girdwood 		/* is this op for this BE ? */
210401d7584cSLiam Girdwood 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
210501d7584cSLiam Girdwood 			continue;
210601d7584cSLiam Girdwood 
210701d7584cSLiam Girdwood 		switch (cmd) {
210801d7584cSLiam Girdwood 		case SNDRV_PCM_TRIGGER_START:
210901d7584cSLiam Girdwood 			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
211021fca8bdS이경택 			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
211121fca8bdS이경택 			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
211201d7584cSLiam Girdwood 				continue;
211301d7584cSLiam Girdwood 
211401d7584cSLiam Girdwood 			ret = dpcm_do_trigger(dpcm, be_substream, cmd);
211501d7584cSLiam Girdwood 			if (ret)
211601d7584cSLiam Girdwood 				return ret;
211701d7584cSLiam Girdwood 
211801d7584cSLiam Girdwood 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
211901d7584cSLiam Girdwood 			break;
212001d7584cSLiam Girdwood 		case SNDRV_PCM_TRIGGER_RESUME:
212101d7584cSLiam Girdwood 			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
212201d7584cSLiam Girdwood 				continue;
212301d7584cSLiam Girdwood 
212401d7584cSLiam Girdwood 			ret = dpcm_do_trigger(dpcm, be_substream, cmd);
212501d7584cSLiam Girdwood 			if (ret)
212601d7584cSLiam Girdwood 				return ret;
212701d7584cSLiam Girdwood 
212801d7584cSLiam Girdwood 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
212901d7584cSLiam Girdwood 			break;
213001d7584cSLiam Girdwood 		case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
213101d7584cSLiam Girdwood 			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
213201d7584cSLiam Girdwood 				continue;
213301d7584cSLiam Girdwood 
213401d7584cSLiam Girdwood 			ret = dpcm_do_trigger(dpcm, be_substream, cmd);
213501d7584cSLiam Girdwood 			if (ret)
213601d7584cSLiam Girdwood 				return ret;
213701d7584cSLiam Girdwood 
213801d7584cSLiam Girdwood 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
213901d7584cSLiam Girdwood 			break;
214001d7584cSLiam Girdwood 		case SNDRV_PCM_TRIGGER_STOP:
214121fca8bdS이경택 			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) &&
214221fca8bdS이경택 			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
214301d7584cSLiam Girdwood 				continue;
214401d7584cSLiam Girdwood 
214501d7584cSLiam Girdwood 			if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
214601d7584cSLiam Girdwood 				continue;
214701d7584cSLiam Girdwood 
214801d7584cSLiam Girdwood 			ret = dpcm_do_trigger(dpcm, be_substream, cmd);
214901d7584cSLiam Girdwood 			if (ret)
215001d7584cSLiam Girdwood 				return ret;
215101d7584cSLiam Girdwood 
215201d7584cSLiam Girdwood 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
215301d7584cSLiam Girdwood 			break;
215401d7584cSLiam Girdwood 		case SNDRV_PCM_TRIGGER_SUSPEND:
2155868a6ca8SNicolin Chen 			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
215601d7584cSLiam Girdwood 				continue;
215701d7584cSLiam Girdwood 
215801d7584cSLiam Girdwood 			if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
215901d7584cSLiam Girdwood 				continue;
216001d7584cSLiam Girdwood 
216101d7584cSLiam Girdwood 			ret = dpcm_do_trigger(dpcm, be_substream, cmd);
216201d7584cSLiam Girdwood 			if (ret)
216301d7584cSLiam Girdwood 				return ret;
216401d7584cSLiam Girdwood 
216501d7584cSLiam Girdwood 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_SUSPEND;
216601d7584cSLiam Girdwood 			break;
216701d7584cSLiam Girdwood 		case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
216801d7584cSLiam Girdwood 			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
216901d7584cSLiam Girdwood 				continue;
217001d7584cSLiam Girdwood 
217101d7584cSLiam Girdwood 			if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
217201d7584cSLiam Girdwood 				continue;
217301d7584cSLiam Girdwood 
217401d7584cSLiam Girdwood 			ret = dpcm_do_trigger(dpcm, be_substream, cmd);
217501d7584cSLiam Girdwood 			if (ret)
217601d7584cSLiam Girdwood 				return ret;
217701d7584cSLiam Girdwood 
217801d7584cSLiam Girdwood 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
217901d7584cSLiam Girdwood 			break;
218001d7584cSLiam Girdwood 		}
218101d7584cSLiam Girdwood 	}
218201d7584cSLiam Girdwood 
218301d7584cSLiam Girdwood 	return ret;
218401d7584cSLiam Girdwood }
218501d7584cSLiam Girdwood EXPORT_SYMBOL_GPL(dpcm_be_dai_trigger);
218601d7584cSLiam Girdwood 
2187acbf2774SRanjani Sridharan static int dpcm_dai_trigger_fe_be(struct snd_pcm_substream *substream,
2188acbf2774SRanjani Sridharan 				  int cmd, bool fe_first)
2189acbf2774SRanjani Sridharan {
21900ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
2191acbf2774SRanjani Sridharan 	int ret;
2192acbf2774SRanjani Sridharan 
2193acbf2774SRanjani Sridharan 	/* call trigger on the frontend before the backend. */
2194acbf2774SRanjani Sridharan 	if (fe_first) {
2195acbf2774SRanjani Sridharan 		dev_dbg(fe->dev, "ASoC: pre trigger FE %s cmd %d\n",
2196acbf2774SRanjani Sridharan 			fe->dai_link->name, cmd);
2197acbf2774SRanjani Sridharan 
2198acbf2774SRanjani Sridharan 		ret = soc_pcm_trigger(substream, cmd);
2199acbf2774SRanjani Sridharan 		if (ret < 0)
2200acbf2774SRanjani Sridharan 			return ret;
2201acbf2774SRanjani Sridharan 
2202acbf2774SRanjani Sridharan 		ret = dpcm_be_dai_trigger(fe, substream->stream, cmd);
2203acbf2774SRanjani Sridharan 		return ret;
2204acbf2774SRanjani Sridharan 	}
2205acbf2774SRanjani Sridharan 
2206acbf2774SRanjani Sridharan 	/* call trigger on the frontend after the backend. */
2207acbf2774SRanjani Sridharan 	ret = dpcm_be_dai_trigger(fe, substream->stream, cmd);
2208acbf2774SRanjani Sridharan 	if (ret < 0)
2209acbf2774SRanjani Sridharan 		return ret;
2210acbf2774SRanjani Sridharan 
2211acbf2774SRanjani Sridharan 	dev_dbg(fe->dev, "ASoC: post trigger FE %s cmd %d\n",
2212acbf2774SRanjani Sridharan 		fe->dai_link->name, cmd);
2213acbf2774SRanjani Sridharan 
2214acbf2774SRanjani Sridharan 	ret = soc_pcm_trigger(substream, cmd);
2215acbf2774SRanjani Sridharan 
2216acbf2774SRanjani Sridharan 	return ret;
2217acbf2774SRanjani Sridharan }
2218acbf2774SRanjani Sridharan 
2219ea9d0d77STakashi Iwai static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream *substream, int cmd)
222001d7584cSLiam Girdwood {
22210ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
2222acbf2774SRanjani Sridharan 	int stream = substream->stream;
2223acbf2774SRanjani Sridharan 	int ret = 0;
222401d7584cSLiam Girdwood 	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
222501d7584cSLiam Girdwood 
222601d7584cSLiam Girdwood 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
222701d7584cSLiam Girdwood 
222801d7584cSLiam Girdwood 	switch (trigger) {
222901d7584cSLiam Girdwood 	case SND_SOC_DPCM_TRIGGER_PRE:
2230acbf2774SRanjani Sridharan 		switch (cmd) {
2231acbf2774SRanjani Sridharan 		case SNDRV_PCM_TRIGGER_START:
2232acbf2774SRanjani Sridharan 		case SNDRV_PCM_TRIGGER_RESUME:
2233acbf2774SRanjani Sridharan 		case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2234acbf2774SRanjani Sridharan 			ret = dpcm_dai_trigger_fe_be(substream, cmd, true);
2235acbf2774SRanjani Sridharan 			break;
2236acbf2774SRanjani Sridharan 		case SNDRV_PCM_TRIGGER_STOP:
2237acbf2774SRanjani Sridharan 		case SNDRV_PCM_TRIGGER_SUSPEND:
2238acbf2774SRanjani Sridharan 		case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2239acbf2774SRanjani Sridharan 			ret = dpcm_dai_trigger_fe_be(substream, cmd, false);
2240acbf2774SRanjani Sridharan 			break;
2241acbf2774SRanjani Sridharan 		default:
2242acbf2774SRanjani Sridharan 			ret = -EINVAL;
2243acbf2774SRanjani Sridharan 			break;
224401d7584cSLiam Girdwood 		}
224501d7584cSLiam Girdwood 		break;
224601d7584cSLiam Girdwood 	case SND_SOC_DPCM_TRIGGER_POST:
2247acbf2774SRanjani Sridharan 		switch (cmd) {
2248acbf2774SRanjani Sridharan 		case SNDRV_PCM_TRIGGER_START:
2249acbf2774SRanjani Sridharan 		case SNDRV_PCM_TRIGGER_RESUME:
2250acbf2774SRanjani Sridharan 		case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2251acbf2774SRanjani Sridharan 			ret = dpcm_dai_trigger_fe_be(substream, cmd, false);
2252acbf2774SRanjani Sridharan 			break;
2253acbf2774SRanjani Sridharan 		case SNDRV_PCM_TRIGGER_STOP:
2254acbf2774SRanjani Sridharan 		case SNDRV_PCM_TRIGGER_SUSPEND:
2255acbf2774SRanjani Sridharan 		case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2256acbf2774SRanjani Sridharan 			ret = dpcm_dai_trigger_fe_be(substream, cmd, true);
2257acbf2774SRanjani Sridharan 			break;
2258acbf2774SRanjani Sridharan 		default:
2259acbf2774SRanjani Sridharan 			ret = -EINVAL;
2260acbf2774SRanjani Sridharan 			break;
226101d7584cSLiam Girdwood 		}
226201d7584cSLiam Girdwood 		break;
226307bf84aaSLiam Girdwood 	case SND_SOC_DPCM_TRIGGER_BESPOKE:
226407bf84aaSLiam Girdwood 		/* bespoke trigger() - handles both FE and BEs */
226507bf84aaSLiam Girdwood 
2266103d84a3SLiam Girdwood 		dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd %d\n",
226707bf84aaSLiam Girdwood 				fe->dai_link->name, cmd);
226807bf84aaSLiam Girdwood 
226930819358SKuninori Morimoto 		ret = snd_soc_pcm_dai_bespoke_trigger(substream, cmd);
227007bf84aaSLiam Girdwood 		break;
227101d7584cSLiam Girdwood 	default:
2272103d84a3SLiam Girdwood 		dev_err(fe->dev, "ASoC: invalid trigger cmd %d for %s\n", cmd,
227301d7584cSLiam Girdwood 				fe->dai_link->name);
227401d7584cSLiam Girdwood 		ret = -EINVAL;
227501d7584cSLiam Girdwood 		goto out;
227601d7584cSLiam Girdwood 	}
227701d7584cSLiam Girdwood 
2278acbf2774SRanjani Sridharan 	if (ret < 0) {
2279acbf2774SRanjani Sridharan 		dev_err(fe->dev, "ASoC: trigger FE cmd: %d failed: %d\n",
2280acbf2774SRanjani Sridharan 			cmd, ret);
2281acbf2774SRanjani Sridharan 		goto out;
2282acbf2774SRanjani Sridharan 	}
2283acbf2774SRanjani Sridharan 
228401d7584cSLiam Girdwood 	switch (cmd) {
228501d7584cSLiam Girdwood 	case SNDRV_PCM_TRIGGER_START:
228601d7584cSLiam Girdwood 	case SNDRV_PCM_TRIGGER_RESUME:
228701d7584cSLiam Girdwood 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
228801d7584cSLiam Girdwood 		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
228901d7584cSLiam Girdwood 		break;
229001d7584cSLiam Girdwood 	case SNDRV_PCM_TRIGGER_STOP:
229101d7584cSLiam Girdwood 	case SNDRV_PCM_TRIGGER_SUSPEND:
229201d7584cSLiam Girdwood 		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
229301d7584cSLiam Girdwood 		break;
22949f169b9fSPatrick Lai 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
22959f169b9fSPatrick Lai 		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
22969f169b9fSPatrick Lai 		break;
229701d7584cSLiam Girdwood 	}
229801d7584cSLiam Girdwood 
229901d7584cSLiam Girdwood out:
230001d7584cSLiam Girdwood 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
230101d7584cSLiam Girdwood 	return ret;
230201d7584cSLiam Girdwood }
230301d7584cSLiam Girdwood 
2304ea9d0d77STakashi Iwai static int dpcm_fe_dai_trigger(struct snd_pcm_substream *substream, int cmd)
2305ea9d0d77STakashi Iwai {
23060ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
2307ea9d0d77STakashi Iwai 	int stream = substream->stream;
2308ea9d0d77STakashi Iwai 
2309ea9d0d77STakashi Iwai 	/* if FE's runtime_update is already set, we're in race;
2310ea9d0d77STakashi Iwai 	 * process this trigger later at exit
2311ea9d0d77STakashi Iwai 	 */
2312ea9d0d77STakashi Iwai 	if (fe->dpcm[stream].runtime_update != SND_SOC_DPCM_UPDATE_NO) {
2313ea9d0d77STakashi Iwai 		fe->dpcm[stream].trigger_pending = cmd + 1;
2314ea9d0d77STakashi Iwai 		return 0; /* delayed, assuming it's successful */
2315ea9d0d77STakashi Iwai 	}
2316ea9d0d77STakashi Iwai 
2317ea9d0d77STakashi Iwai 	/* we're alone, let's trigger */
2318ea9d0d77STakashi Iwai 	return dpcm_fe_dai_do_trigger(substream, cmd);
2319ea9d0d77STakashi Iwai }
2320ea9d0d77STakashi Iwai 
232123607025SLiam Girdwood int dpcm_be_dai_prepare(struct snd_soc_pcm_runtime *fe, int stream)
232201d7584cSLiam Girdwood {
232301d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
232401d7584cSLiam Girdwood 	int ret = 0;
232501d7584cSLiam Girdwood 
23268d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
232701d7584cSLiam Girdwood 
232801d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be = dpcm->be;
232901d7584cSLiam Girdwood 		struct snd_pcm_substream *be_substream =
233001d7584cSLiam Girdwood 			snd_soc_dpcm_get_substream(be, stream);
233101d7584cSLiam Girdwood 
233201d7584cSLiam Girdwood 		/* is this op for this BE ? */
233301d7584cSLiam Girdwood 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
233401d7584cSLiam Girdwood 			continue;
233501d7584cSLiam Girdwood 
233601d7584cSLiam Girdwood 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
233795f444dcSKoro Chen 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
23385087a8f1SLibin Yang 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND) &&
23395087a8f1SLibin Yang 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
234001d7584cSLiam Girdwood 			continue;
234101d7584cSLiam Girdwood 
2342103d84a3SLiam Girdwood 		dev_dbg(be->dev, "ASoC: prepare BE %s\n",
234394d215ccS彭东林 			be->dai_link->name);
234401d7584cSLiam Girdwood 
234501d7584cSLiam Girdwood 		ret = soc_pcm_prepare(be_substream);
234601d7584cSLiam Girdwood 		if (ret < 0) {
2347103d84a3SLiam Girdwood 			dev_err(be->dev, "ASoC: backend prepare failed %d\n",
234801d7584cSLiam Girdwood 				ret);
234901d7584cSLiam Girdwood 			break;
235001d7584cSLiam Girdwood 		}
235101d7584cSLiam Girdwood 
235201d7584cSLiam Girdwood 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
235301d7584cSLiam Girdwood 	}
235401d7584cSLiam Girdwood 	return ret;
235501d7584cSLiam Girdwood }
235601d7584cSLiam Girdwood 
235745c0a188SMark Brown static int dpcm_fe_dai_prepare(struct snd_pcm_substream *substream)
235801d7584cSLiam Girdwood {
23590ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
236001d7584cSLiam Girdwood 	int stream = substream->stream, ret = 0;
236101d7584cSLiam Girdwood 
236201d7584cSLiam Girdwood 	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
236301d7584cSLiam Girdwood 
2364103d84a3SLiam Girdwood 	dev_dbg(fe->dev, "ASoC: prepare FE %s\n", fe->dai_link->name);
236501d7584cSLiam Girdwood 
2366ea9d0d77STakashi Iwai 	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
236701d7584cSLiam Girdwood 
236801d7584cSLiam Girdwood 	/* there is no point preparing this FE if there are no BEs */
236901d7584cSLiam Girdwood 	if (list_empty(&fe->dpcm[stream].be_clients)) {
2370103d84a3SLiam Girdwood 		dev_err(fe->dev, "ASoC: no backend DAIs enabled for %s\n",
237101d7584cSLiam Girdwood 				fe->dai_link->name);
237201d7584cSLiam Girdwood 		ret = -EINVAL;
237301d7584cSLiam Girdwood 		goto out;
237401d7584cSLiam Girdwood 	}
237501d7584cSLiam Girdwood 
237625c2f515SKuninori Morimoto 	ret = dpcm_be_dai_prepare(fe, stream);
237701d7584cSLiam Girdwood 	if (ret < 0)
237801d7584cSLiam Girdwood 		goto out;
237901d7584cSLiam Girdwood 
238001d7584cSLiam Girdwood 	/* call prepare on the frontend */
238101d7584cSLiam Girdwood 	ret = soc_pcm_prepare(substream);
238201d7584cSLiam Girdwood 	if (ret < 0) {
2383103d84a3SLiam Girdwood 		dev_err(fe->dev,"ASoC: prepare FE %s failed\n",
238401d7584cSLiam Girdwood 			fe->dai_link->name);
238501d7584cSLiam Girdwood 		goto out;
238601d7584cSLiam Girdwood 	}
238701d7584cSLiam Girdwood 
238801d7584cSLiam Girdwood 	/* run the stream event for each BE */
238901d7584cSLiam Girdwood 	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START);
239001d7584cSLiam Girdwood 	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
239101d7584cSLiam Girdwood 
239201d7584cSLiam Girdwood out:
2393ea9d0d77STakashi Iwai 	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
239401d7584cSLiam Girdwood 	mutex_unlock(&fe->card->mutex);
239501d7584cSLiam Girdwood 
239601d7584cSLiam Girdwood 	return ret;
239701d7584cSLiam Girdwood }
239801d7584cSLiam Girdwood 
2399618dae11SLiam Girdwood static int dpcm_run_update_shutdown(struct snd_soc_pcm_runtime *fe, int stream)
2400618dae11SLiam Girdwood {
240107bf84aaSLiam Girdwood 	struct snd_pcm_substream *substream =
240207bf84aaSLiam Girdwood 		snd_soc_dpcm_get_substream(fe, stream);
240307bf84aaSLiam Girdwood 	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2404618dae11SLiam Girdwood 	int err;
240501d7584cSLiam Girdwood 
2406103d84a3SLiam Girdwood 	dev_dbg(fe->dev, "ASoC: runtime %s close on FE %s\n",
2407618dae11SLiam Girdwood 			stream ? "capture" : "playback", fe->dai_link->name);
2408618dae11SLiam Girdwood 
240907bf84aaSLiam Girdwood 	if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) {
241007bf84aaSLiam Girdwood 		/* call bespoke trigger - FE takes care of all BE triggers */
2411103d84a3SLiam Girdwood 		dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd stop\n",
241207bf84aaSLiam Girdwood 				fe->dai_link->name);
241307bf84aaSLiam Girdwood 
241430819358SKuninori Morimoto 		err = snd_soc_pcm_dai_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_STOP);
241507bf84aaSLiam Girdwood 		if (err < 0)
2416103d84a3SLiam Girdwood 			dev_err(fe->dev,"ASoC: trigger FE failed %d\n", err);
241707bf84aaSLiam Girdwood 	} else {
2418103d84a3SLiam Girdwood 		dev_dbg(fe->dev, "ASoC: trigger FE %s cmd stop\n",
241907bf84aaSLiam Girdwood 			fe->dai_link->name);
242007bf84aaSLiam Girdwood 
2421618dae11SLiam Girdwood 		err = dpcm_be_dai_trigger(fe, stream, SNDRV_PCM_TRIGGER_STOP);
2422618dae11SLiam Girdwood 		if (err < 0)
2423103d84a3SLiam Girdwood 			dev_err(fe->dev,"ASoC: trigger FE failed %d\n", err);
242407bf84aaSLiam Girdwood 	}
2425618dae11SLiam Girdwood 
2426618dae11SLiam Girdwood 	err = dpcm_be_dai_hw_free(fe, stream);
2427618dae11SLiam Girdwood 	if (err < 0)
2428103d84a3SLiam Girdwood 		dev_err(fe->dev,"ASoC: hw_free FE failed %d\n", err);
2429618dae11SLiam Girdwood 
2430618dae11SLiam Girdwood 	err = dpcm_be_dai_shutdown(fe, stream);
2431618dae11SLiam Girdwood 	if (err < 0)
2432103d84a3SLiam Girdwood 		dev_err(fe->dev,"ASoC: shutdown FE failed %d\n", err);
2433618dae11SLiam Girdwood 
2434618dae11SLiam Girdwood 	/* run the stream event for each BE */
2435618dae11SLiam Girdwood 	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_NOP);
2436618dae11SLiam Girdwood 
2437618dae11SLiam Girdwood 	return 0;
2438618dae11SLiam Girdwood }
2439618dae11SLiam Girdwood 
2440618dae11SLiam Girdwood static int dpcm_run_update_startup(struct snd_soc_pcm_runtime *fe, int stream)
2441618dae11SLiam Girdwood {
244207bf84aaSLiam Girdwood 	struct snd_pcm_substream *substream =
244307bf84aaSLiam Girdwood 		snd_soc_dpcm_get_substream(fe, stream);
2444618dae11SLiam Girdwood 	struct snd_soc_dpcm *dpcm;
244507bf84aaSLiam Girdwood 	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2446618dae11SLiam Girdwood 	int ret;
2447a9764869SKaiChieh Chuang 	unsigned long flags;
2448618dae11SLiam Girdwood 
2449103d84a3SLiam Girdwood 	dev_dbg(fe->dev, "ASoC: runtime %s open on FE %s\n",
2450618dae11SLiam Girdwood 			stream ? "capture" : "playback", fe->dai_link->name);
2451618dae11SLiam Girdwood 
2452618dae11SLiam Girdwood 	/* Only start the BE if the FE is ready */
2453618dae11SLiam Girdwood 	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_FREE ||
2454618dae11SLiam Girdwood 		fe->dpcm[stream].state == SND_SOC_DPCM_STATE_CLOSE)
2455618dae11SLiam Girdwood 		return -EINVAL;
2456618dae11SLiam Girdwood 
2457618dae11SLiam Girdwood 	/* startup must always be called for new BEs */
2458618dae11SLiam Girdwood 	ret = dpcm_be_dai_startup(fe, stream);
2459fffc0ca2SDan Carpenter 	if (ret < 0)
2460618dae11SLiam Girdwood 		goto disconnect;
2461618dae11SLiam Girdwood 
2462618dae11SLiam Girdwood 	/* keep going if FE state is > open */
2463618dae11SLiam Girdwood 	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_OPEN)
2464618dae11SLiam Girdwood 		return 0;
2465618dae11SLiam Girdwood 
2466618dae11SLiam Girdwood 	ret = dpcm_be_dai_hw_params(fe, stream);
2467fffc0ca2SDan Carpenter 	if (ret < 0)
2468618dae11SLiam Girdwood 		goto close;
2469618dae11SLiam Girdwood 
2470618dae11SLiam Girdwood 	/* keep going if FE state is > hw_params */
2471618dae11SLiam Girdwood 	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_PARAMS)
2472618dae11SLiam Girdwood 		return 0;
2473618dae11SLiam Girdwood 
2474618dae11SLiam Girdwood 
2475618dae11SLiam Girdwood 	ret = dpcm_be_dai_prepare(fe, stream);
2476fffc0ca2SDan Carpenter 	if (ret < 0)
2477618dae11SLiam Girdwood 		goto hw_free;
2478618dae11SLiam Girdwood 
2479618dae11SLiam Girdwood 	/* run the stream event for each BE */
2480618dae11SLiam Girdwood 	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_NOP);
2481618dae11SLiam Girdwood 
2482618dae11SLiam Girdwood 	/* keep going if FE state is > prepare */
2483618dae11SLiam Girdwood 	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_PREPARE ||
2484618dae11SLiam Girdwood 		fe->dpcm[stream].state == SND_SOC_DPCM_STATE_STOP)
2485618dae11SLiam Girdwood 		return 0;
2486618dae11SLiam Girdwood 
248707bf84aaSLiam Girdwood 	if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) {
248807bf84aaSLiam Girdwood 		/* call trigger on the frontend - FE takes care of all BE triggers */
2489103d84a3SLiam Girdwood 		dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd start\n",
249007bf84aaSLiam Girdwood 				fe->dai_link->name);
249107bf84aaSLiam Girdwood 
249230819358SKuninori Morimoto 		ret = snd_soc_pcm_dai_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_START);
249307bf84aaSLiam Girdwood 		if (ret < 0) {
2494103d84a3SLiam Girdwood 			dev_err(fe->dev,"ASoC: bespoke trigger FE failed %d\n", ret);
249507bf84aaSLiam Girdwood 			goto hw_free;
249607bf84aaSLiam Girdwood 		}
249707bf84aaSLiam Girdwood 	} else {
2498103d84a3SLiam Girdwood 		dev_dbg(fe->dev, "ASoC: trigger FE %s cmd start\n",
2499618dae11SLiam Girdwood 			fe->dai_link->name);
2500618dae11SLiam Girdwood 
2501618dae11SLiam Girdwood 		ret = dpcm_be_dai_trigger(fe, stream,
2502618dae11SLiam Girdwood 					SNDRV_PCM_TRIGGER_START);
2503618dae11SLiam Girdwood 		if (ret < 0) {
2504103d84a3SLiam Girdwood 			dev_err(fe->dev,"ASoC: trigger FE failed %d\n", ret);
2505618dae11SLiam Girdwood 			goto hw_free;
2506618dae11SLiam Girdwood 		}
250707bf84aaSLiam Girdwood 	}
2508618dae11SLiam Girdwood 
2509618dae11SLiam Girdwood 	return 0;
2510618dae11SLiam Girdwood 
2511618dae11SLiam Girdwood hw_free:
2512618dae11SLiam Girdwood 	dpcm_be_dai_hw_free(fe, stream);
2513618dae11SLiam Girdwood close:
2514618dae11SLiam Girdwood 	dpcm_be_dai_shutdown(fe, stream);
2515618dae11SLiam Girdwood disconnect:
251668f8043eS朱灿灿 	/* disconnect any closed BEs */
2517a9764869SKaiChieh Chuang 	spin_lock_irqsave(&fe->card->dpcm_lock, flags);
25188d6258a4SKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm) {
2519618dae11SLiam Girdwood 		struct snd_soc_pcm_runtime *be = dpcm->be;
252068f8043eS朱灿灿 		if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_CLOSE)
2521618dae11SLiam Girdwood 			dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
2522618dae11SLiam Girdwood 	}
2523a9764869SKaiChieh Chuang 	spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
2524618dae11SLiam Girdwood 
2525618dae11SLiam Girdwood 	return ret;
2526618dae11SLiam Girdwood }
2527618dae11SLiam Girdwood 
2528de15d7ffSJerome Brunet static int soc_dpcm_fe_runtime_update(struct snd_soc_pcm_runtime *fe, int new)
2529618dae11SLiam Girdwood {
2530618dae11SLiam Girdwood 	struct snd_soc_dapm_widget_list *list;
25317083f877SKuninori Morimoto 	int stream;
2532de15d7ffSJerome Brunet 	int count, paths;
2533580dff36SKuninori Morimoto 	int ret;
2534618dae11SLiam Girdwood 
253596bf62f0SPierre-Louis Bossart 	if (!fe->dai_link->dynamic)
253696bf62f0SPierre-Louis Bossart 		return 0;
253796bf62f0SPierre-Louis Bossart 
25386e1276a5SBard Liao 	if (fe->num_cpus > 1) {
25396e1276a5SBard Liao 		dev_err(fe->dev,
25406e1276a5SBard Liao 			"%s doesn't support Multi CPU yet\n", __func__);
25416e1276a5SBard Liao 		return -EINVAL;
25426e1276a5SBard Liao 	}
25436e1276a5SBard Liao 
2544618dae11SLiam Girdwood 	/* only check active links */
2545b3dea624SKuninori Morimoto 	if (!snd_soc_dai_active(asoc_rtd_to_cpu(fe, 0)))
2546de15d7ffSJerome Brunet 		return 0;
2547618dae11SLiam Girdwood 
2548618dae11SLiam Girdwood 	/* DAPM sync will call this to update DSP paths */
2549de15d7ffSJerome Brunet 	dev_dbg(fe->dev, "ASoC: DPCM %s runtime update for FE %s\n",
2550de15d7ffSJerome Brunet 		new ? "new" : "old", fe->dai_link->name);
2551618dae11SLiam Girdwood 
25527083f877SKuninori Morimoto 	for_each_pcm_streams(stream) {
2553075207d2SQiao Zhou 
25547083f877SKuninori Morimoto 		/* skip if FE doesn't have playback/capture capability */
2555c2233a26SKuninori Morimoto 		if (!snd_soc_dai_stream_valid(asoc_rtd_to_cpu(fe, 0),   stream) ||
2556c2233a26SKuninori Morimoto 		    !snd_soc_dai_stream_valid(asoc_rtd_to_codec(fe, 0), stream))
25577083f877SKuninori Morimoto 			continue;
2558618dae11SLiam Girdwood 
25597083f877SKuninori Morimoto 		/* skip if FE isn't currently playing/capturing */
2560b3dea624SKuninori Morimoto 		if (!snd_soc_dai_stream_active(asoc_rtd_to_cpu(fe, 0), stream) ||
2561b3dea624SKuninori Morimoto 		    !snd_soc_dai_stream_active(asoc_rtd_to_codec(fe, 0), stream))
25627083f877SKuninori Morimoto 			continue;
25637083f877SKuninori Morimoto 
25647083f877SKuninori Morimoto 		paths = dpcm_path_get(fe, stream, &list);
2565618dae11SLiam Girdwood 		if (paths < 0) {
2566103d84a3SLiam Girdwood 			dev_warn(fe->dev, "ASoC: %s no valid %s path\n",
25677083f877SKuninori Morimoto 				 fe->dai_link->name,
25687083f877SKuninori Morimoto 				 stream == SNDRV_PCM_STREAM_PLAYBACK ?
25697083f877SKuninori Morimoto 				 "playback" : "capture");
2570618dae11SLiam Girdwood 			return paths;
2571618dae11SLiam Girdwood 		}
2572618dae11SLiam Girdwood 
25737083f877SKuninori Morimoto 		/* update any playback/capture paths */
25747083f877SKuninori Morimoto 		count = dpcm_process_paths(fe, stream, &list, new);
2575de15d7ffSJerome Brunet 		if (count) {
2576580dff36SKuninori Morimoto 			dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_BE);
2577de15d7ffSJerome Brunet 			if (new)
2578580dff36SKuninori Morimoto 				ret = dpcm_run_update_startup(fe, stream);
2579de15d7ffSJerome Brunet 			else
2580580dff36SKuninori Morimoto 				ret = dpcm_run_update_shutdown(fe, stream);
2581580dff36SKuninori Morimoto 			if (ret < 0)
2582580dff36SKuninori Morimoto 				dev_err(fe->dev, "ASoC: failed to shutdown some BEs\n");
2583580dff36SKuninori Morimoto 			dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
2584de15d7ffSJerome Brunet 
25857083f877SKuninori Morimoto 			dpcm_clear_pending_state(fe, stream);
25867083f877SKuninori Morimoto 			dpcm_be_disconnect(fe, stream);
2587618dae11SLiam Girdwood 		}
2588618dae11SLiam Girdwood 
25897ed9de76SQiao Zhou 		dpcm_path_put(&list);
2590618dae11SLiam Girdwood 	}
2591618dae11SLiam Girdwood 
2592de15d7ffSJerome Brunet 	return 0;
2593618dae11SLiam Girdwood }
2594618dae11SLiam Girdwood 
2595de15d7ffSJerome Brunet /* Called by DAPM mixer/mux changes to update audio routing between PCMs and
2596de15d7ffSJerome Brunet  * any DAI links.
2597de15d7ffSJerome Brunet  */
2598f17a1478SGuennadi Liakhovetski int snd_soc_dpcm_runtime_update(struct snd_soc_card *card)
2599de15d7ffSJerome Brunet {
2600de15d7ffSJerome Brunet 	struct snd_soc_pcm_runtime *fe;
2601de15d7ffSJerome Brunet 	int ret = 0;
2602de15d7ffSJerome Brunet 
2603de15d7ffSJerome Brunet 	mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
2604de15d7ffSJerome Brunet 	/* shutdown all old paths first */
2605bcb1fd1fSKuninori Morimoto 	for_each_card_rtds(card, fe) {
2606de15d7ffSJerome Brunet 		ret = soc_dpcm_fe_runtime_update(fe, 0);
2607de15d7ffSJerome Brunet 		if (ret)
2608de15d7ffSJerome Brunet 			goto out;
2609de15d7ffSJerome Brunet 	}
2610de15d7ffSJerome Brunet 
2611de15d7ffSJerome Brunet 	/* bring new paths up */
2612bcb1fd1fSKuninori Morimoto 	for_each_card_rtds(card, fe) {
2613de15d7ffSJerome Brunet 		ret = soc_dpcm_fe_runtime_update(fe, 1);
2614de15d7ffSJerome Brunet 		if (ret)
2615de15d7ffSJerome Brunet 			goto out;
2616de15d7ffSJerome Brunet 	}
2617de15d7ffSJerome Brunet 
2618de15d7ffSJerome Brunet out:
2619618dae11SLiam Girdwood 	mutex_unlock(&card->mutex);
2620de15d7ffSJerome Brunet 	return ret;
2621618dae11SLiam Girdwood }
2622f17a1478SGuennadi Liakhovetski EXPORT_SYMBOL_GPL(snd_soc_dpcm_runtime_update);
262301d7584cSLiam Girdwood 
2624265694b6SKuninori Morimoto static void dpcm_fe_dai_cleanup(struct snd_pcm_substream *fe_substream)
262501d7584cSLiam Girdwood {
26260ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
262701d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
2628265694b6SKuninori Morimoto 	int stream = fe_substream->stream;
262930fca26fSKuninori Morimoto 
263030fca26fSKuninori Morimoto 	/* mark FE's links ready to prune */
263130fca26fSKuninori Morimoto 	for_each_dpcm_be(fe, stream, dpcm)
263230fca26fSKuninori Morimoto 		dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
263330fca26fSKuninori Morimoto 
263430fca26fSKuninori Morimoto 	dpcm_be_disconnect(fe, stream);
263530fca26fSKuninori Morimoto 
263630fca26fSKuninori Morimoto 	fe->dpcm[stream].runtime = NULL;
2637265694b6SKuninori Morimoto }
2638265694b6SKuninori Morimoto 
2639265694b6SKuninori Morimoto static int dpcm_fe_dai_close(struct snd_pcm_substream *fe_substream)
2640265694b6SKuninori Morimoto {
26410ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
2642265694b6SKuninori Morimoto 	int ret;
2643265694b6SKuninori Morimoto 
2644265694b6SKuninori Morimoto 	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
2645265694b6SKuninori Morimoto 	ret = dpcm_fe_dai_shutdown(fe_substream);
2646265694b6SKuninori Morimoto 
2647265694b6SKuninori Morimoto 	dpcm_fe_dai_cleanup(fe_substream);
2648265694b6SKuninori Morimoto 
264930fca26fSKuninori Morimoto 	mutex_unlock(&fe->card->mutex);
265030fca26fSKuninori Morimoto 	return ret;
265130fca26fSKuninori Morimoto }
265230fca26fSKuninori Morimoto 
265301d7584cSLiam Girdwood static int dpcm_fe_dai_open(struct snd_pcm_substream *fe_substream)
265401d7584cSLiam Girdwood {
26550ceef681SKuninori Morimoto 	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
265601d7584cSLiam Girdwood 	struct snd_soc_dapm_widget_list *list;
265701d7584cSLiam Girdwood 	int ret;
265801d7584cSLiam Girdwood 	int stream = fe_substream->stream;
265901d7584cSLiam Girdwood 
266001d7584cSLiam Girdwood 	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
266101d7584cSLiam Girdwood 	fe->dpcm[stream].runtime = fe_substream->runtime;
266201d7584cSLiam Girdwood 
26638f70e515SQiao Zhou 	ret = dpcm_path_get(fe, stream, &list);
26648f70e515SQiao Zhou 	if (ret < 0) {
2665cae06eb9SKuninori Morimoto 		goto open_end;
26668f70e515SQiao Zhou 	} else if (ret == 0) {
2667103d84a3SLiam Girdwood 		dev_dbg(fe->dev, "ASoC: %s no valid %s route\n",
266801d7584cSLiam Girdwood 			fe->dai_link->name, stream ? "capture" : "playback");
266901d7584cSLiam Girdwood 	}
267001d7584cSLiam Girdwood 
267101d7584cSLiam Girdwood 	/* calculate valid and active FE <-> BE dpcms */
267201d7584cSLiam Girdwood 	dpcm_process_paths(fe, stream, &list, 1);
267301d7584cSLiam Girdwood 
267401d7584cSLiam Girdwood 	ret = dpcm_fe_dai_startup(fe_substream);
2675265694b6SKuninori Morimoto 	if (ret < 0)
2676265694b6SKuninori Morimoto 		dpcm_fe_dai_cleanup(fe_substream);
267701d7584cSLiam Girdwood 
267801d7584cSLiam Girdwood 	dpcm_clear_pending_state(fe, stream);
267901d7584cSLiam Girdwood 	dpcm_path_put(&list);
2680cae06eb9SKuninori Morimoto open_end:
268101d7584cSLiam Girdwood 	mutex_unlock(&fe->card->mutex);
268201d7584cSLiam Girdwood 	return ret;
268301d7584cSLiam Girdwood }
268401d7584cSLiam Girdwood 
2685ddee627cSLiam Girdwood /* create a new pcm */
2686ddee627cSLiam Girdwood int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
2687ddee627cSLiam Girdwood {
26882e5894d7SBenoit Cousson 	struct snd_soc_dai *codec_dai;
268919bdcc7aSShreyas NC 	struct snd_soc_dai *cpu_dai;
26902b544dd7SKuninori Morimoto 	struct snd_soc_component *component;
2691ddee627cSLiam Girdwood 	struct snd_pcm *pcm;
2692ddee627cSLiam Girdwood 	char new_name[64];
2693ddee627cSLiam Girdwood 	int ret = 0, playback = 0, capture = 0;
2694b73287f0SPierre-Louis Bossart 	int stream;
26952e5894d7SBenoit Cousson 	int i;
2696ddee627cSLiam Girdwood 
2697b73287f0SPierre-Louis Bossart 	if (rtd->dai_link->dynamic && rtd->num_cpus > 1) {
26989b5db059SStephan Gerhold 		dev_err(rtd->dev,
2699b73287f0SPierre-Louis Bossart 			"DPCM doesn't support Multi CPU for Front-Ends yet\n");
27009b5db059SStephan Gerhold 		return -EINVAL;
27019b5db059SStephan Gerhold 	}
27029b5db059SStephan Gerhold 
2703b73287f0SPierre-Louis Bossart 	if (rtd->dai_link->dynamic || rtd->dai_link->no_pcm) {
2704b73287f0SPierre-Louis Bossart 		if (rtd->dai_link->dpcm_playback) {
2705b73287f0SPierre-Louis Bossart 			stream = SNDRV_PCM_STREAM_PLAYBACK;
2706b73287f0SPierre-Louis Bossart 
27074f872154SPierre-Louis Bossart 			for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
27084f872154SPierre-Louis Bossart 				if (snd_soc_dai_stream_valid(cpu_dai, stream)) {
27094f872154SPierre-Louis Bossart 					playback = 1;
27104f872154SPierre-Louis Bossart 					break;
27114f872154SPierre-Louis Bossart 				}
27124f872154SPierre-Louis Bossart 			}
27134f872154SPierre-Louis Bossart 
27144f872154SPierre-Louis Bossart 			if (!playback) {
2715b73287f0SPierre-Louis Bossart 				dev_err(rtd->card->dev,
27164f872154SPierre-Louis Bossart 					"No CPU DAIs support playback for stream %s\n",
2717b73287f0SPierre-Louis Bossart 					rtd->dai_link->stream_name);
2718b73287f0SPierre-Louis Bossart 				return -EINVAL;
2719b73287f0SPierre-Louis Bossart 			}
2720b73287f0SPierre-Louis Bossart 		}
2721b73287f0SPierre-Louis Bossart 		if (rtd->dai_link->dpcm_capture) {
2722b73287f0SPierre-Louis Bossart 			stream = SNDRV_PCM_STREAM_CAPTURE;
2723b73287f0SPierre-Louis Bossart 
27244f872154SPierre-Louis Bossart 			for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
27254f872154SPierre-Louis Bossart 				if (snd_soc_dai_stream_valid(cpu_dai, stream)) {
27264f872154SPierre-Louis Bossart 					capture = 1;
27274f872154SPierre-Louis Bossart 					break;
27284f872154SPierre-Louis Bossart 				}
27294f872154SPierre-Louis Bossart 			}
27304f872154SPierre-Louis Bossart 
27314f872154SPierre-Louis Bossart 			if (!capture) {
2732b73287f0SPierre-Louis Bossart 				dev_err(rtd->card->dev,
27334f872154SPierre-Louis Bossart 					"No CPU DAIs support capture for stream %s\n",
2734b73287f0SPierre-Louis Bossart 					rtd->dai_link->stream_name);
2735b73287f0SPierre-Louis Bossart 				return -EINVAL;
2736b73287f0SPierre-Louis Bossart 			}
2737b73287f0SPierre-Louis Bossart 		}
273801d7584cSLiam Girdwood 	} else {
2739a342031cSJerome Brunet 		/* Adapt stream for codec2codec links */
2740a4877a6fSStephan Gerhold 		int cpu_capture = rtd->dai_link->params ?
2741a4877a6fSStephan Gerhold 			SNDRV_PCM_STREAM_PLAYBACK : SNDRV_PCM_STREAM_CAPTURE;
2742a4877a6fSStephan Gerhold 		int cpu_playback = rtd->dai_link->params ?
2743a4877a6fSStephan Gerhold 			SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2744a342031cSJerome Brunet 
2745a4be4187SKuninori Morimoto 		for_each_rtd_codec_dais(rtd, i, codec_dai) {
274619bdcc7aSShreyas NC 			if (rtd->num_cpus == 1) {
2747c2233a26SKuninori Morimoto 				cpu_dai = asoc_rtd_to_cpu(rtd, 0);
274819bdcc7aSShreyas NC 			} else if (rtd->num_cpus == rtd->num_codecs) {
2749c2233a26SKuninori Morimoto 				cpu_dai = asoc_rtd_to_cpu(rtd, i);
275019bdcc7aSShreyas NC 			} else {
275119bdcc7aSShreyas NC 				dev_err(rtd->card->dev,
275219bdcc7aSShreyas NC 					"N cpus to M codecs link is not supported yet\n");
275319bdcc7aSShreyas NC 				return -EINVAL;
275419bdcc7aSShreyas NC 			}
275519bdcc7aSShreyas NC 
2756467fece8SKuninori Morimoto 			if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_PLAYBACK) &&
2757a4877a6fSStephan Gerhold 			    snd_soc_dai_stream_valid(cpu_dai,   cpu_playback))
2758ddee627cSLiam Girdwood 				playback = 1;
2759467fece8SKuninori Morimoto 			if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_CAPTURE) &&
2760a4877a6fSStephan Gerhold 			    snd_soc_dai_stream_valid(cpu_dai,   cpu_capture))
2761ddee627cSLiam Girdwood 				capture = 1;
276201d7584cSLiam Girdwood 		}
27632e5894d7SBenoit Cousson 	}
27642e5894d7SBenoit Cousson 
2765d6bead02SFabio Estevam 	if (rtd->dai_link->playback_only) {
2766d6bead02SFabio Estevam 		playback = 1;
2767d6bead02SFabio Estevam 		capture = 0;
2768d6bead02SFabio Estevam 	}
2769d6bead02SFabio Estevam 
2770d6bead02SFabio Estevam 	if (rtd->dai_link->capture_only) {
2771d6bead02SFabio Estevam 		playback = 0;
2772d6bead02SFabio Estevam 		capture = 1;
2773d6bead02SFabio Estevam 	}
2774d6bead02SFabio Estevam 
277501d7584cSLiam Girdwood 	/* create the PCM */
2776a342031cSJerome Brunet 	if (rtd->dai_link->params) {
2777a342031cSJerome Brunet 		snprintf(new_name, sizeof(new_name), "codec2codec(%s)",
2778a342031cSJerome Brunet 			 rtd->dai_link->stream_name);
2779a342031cSJerome Brunet 
2780a342031cSJerome Brunet 		ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
2781a342031cSJerome Brunet 					   playback, capture, &pcm);
2782a342031cSJerome Brunet 	} else if (rtd->dai_link->no_pcm) {
278301d7584cSLiam Girdwood 		snprintf(new_name, sizeof(new_name), "(%s)",
278401d7584cSLiam Girdwood 			rtd->dai_link->stream_name);
278501d7584cSLiam Girdwood 
278601d7584cSLiam Girdwood 		ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
278701d7584cSLiam Girdwood 				playback, capture, &pcm);
278801d7584cSLiam Girdwood 	} else {
278901d7584cSLiam Girdwood 		if (rtd->dai_link->dynamic)
279001d7584cSLiam Girdwood 			snprintf(new_name, sizeof(new_name), "%s (*)",
279101d7584cSLiam Girdwood 				rtd->dai_link->stream_name);
279201d7584cSLiam Girdwood 		else
279301d7584cSLiam Girdwood 			snprintf(new_name, sizeof(new_name), "%s %s-%d",
27942e5894d7SBenoit Cousson 				rtd->dai_link->stream_name,
27952e5894d7SBenoit Cousson 				(rtd->num_codecs > 1) ?
2796c2233a26SKuninori Morimoto 				"multicodec" : asoc_rtd_to_codec(rtd, 0)->name, num);
279701d7584cSLiam Girdwood 
279801d7584cSLiam Girdwood 		ret = snd_pcm_new(rtd->card->snd_card, new_name, num, playback,
279901d7584cSLiam Girdwood 			capture, &pcm);
280001d7584cSLiam Girdwood 	}
2801ddee627cSLiam Girdwood 	if (ret < 0) {
2802799827a4SPierre-Louis Bossart 		dev_err(rtd->card->dev, "ASoC: can't create pcm %s for dailink %s: %d\n",
2803799827a4SPierre-Louis Bossart 			new_name, rtd->dai_link->name, ret);
2804ddee627cSLiam Girdwood 		return ret;
2805ddee627cSLiam Girdwood 	}
2806103d84a3SLiam Girdwood 	dev_dbg(rtd->card->dev, "ASoC: registered pcm #%d %s\n",num, new_name);
2807ddee627cSLiam Girdwood 
2808ddee627cSLiam Girdwood 	/* DAPM dai link stream work */
2809a342031cSJerome Brunet 	if (rtd->dai_link->params)
28104bf2e385SCurtis Malainey 		rtd->close_delayed_work_func = codec2codec_close_delayed_work;
2811a342031cSJerome Brunet 	else
281283f94a2eSKuninori Morimoto 		rtd->close_delayed_work_func = snd_soc_close_delayed_work;
2813ddee627cSLiam Girdwood 
281448c7699fSVinod Koul 	pcm->nonatomic = rtd->dai_link->nonatomic;
2815ddee627cSLiam Girdwood 	rtd->pcm = pcm;
2816ddee627cSLiam Girdwood 	pcm->private_data = rtd;
281701d7584cSLiam Girdwood 
2818a342031cSJerome Brunet 	if (rtd->dai_link->no_pcm || rtd->dai_link->params) {
281901d7584cSLiam Girdwood 		if (playback)
282001d7584cSLiam Girdwood 			pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
282101d7584cSLiam Girdwood 		if (capture)
282201d7584cSLiam Girdwood 			pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
282301d7584cSLiam Girdwood 		goto out;
282401d7584cSLiam Girdwood 	}
282501d7584cSLiam Girdwood 
282601d7584cSLiam Girdwood 	/* ASoC PCM operations */
282701d7584cSLiam Girdwood 	if (rtd->dai_link->dynamic) {
282801d7584cSLiam Girdwood 		rtd->ops.open		= dpcm_fe_dai_open;
282901d7584cSLiam Girdwood 		rtd->ops.hw_params	= dpcm_fe_dai_hw_params;
283001d7584cSLiam Girdwood 		rtd->ops.prepare	= dpcm_fe_dai_prepare;
283101d7584cSLiam Girdwood 		rtd->ops.trigger	= dpcm_fe_dai_trigger;
283201d7584cSLiam Girdwood 		rtd->ops.hw_free	= dpcm_fe_dai_hw_free;
283301d7584cSLiam Girdwood 		rtd->ops.close		= dpcm_fe_dai_close;
283401d7584cSLiam Girdwood 		rtd->ops.pointer	= soc_pcm_pointer;
283501d7584cSLiam Girdwood 	} else {
283601d7584cSLiam Girdwood 		rtd->ops.open		= soc_pcm_open;
283701d7584cSLiam Girdwood 		rtd->ops.hw_params	= soc_pcm_hw_params;
283801d7584cSLiam Girdwood 		rtd->ops.prepare	= soc_pcm_prepare;
283901d7584cSLiam Girdwood 		rtd->ops.trigger	= soc_pcm_trigger;
284001d7584cSLiam Girdwood 		rtd->ops.hw_free	= soc_pcm_hw_free;
284101d7584cSLiam Girdwood 		rtd->ops.close		= soc_pcm_close;
284201d7584cSLiam Girdwood 		rtd->ops.pointer	= soc_pcm_pointer;
284301d7584cSLiam Girdwood 	}
284401d7584cSLiam Girdwood 
2845613fb500SKuninori Morimoto 	for_each_rtd_components(rtd, i, component) {
28462b544dd7SKuninori Morimoto 		const struct snd_soc_component_driver *drv = component->driver;
2847b8135864SKuninori Morimoto 
28483b1c952cSTakashi Iwai 		if (drv->ioctl)
28493b1c952cSTakashi Iwai 			rtd->ops.ioctl		= snd_soc_pcm_component_ioctl;
28501e5ddb6bSTakashi Iwai 		if (drv->sync_stop)
28511e5ddb6bSTakashi Iwai 			rtd->ops.sync_stop	= snd_soc_pcm_component_sync_stop;
2852e9067bb5SKuninori Morimoto 		if (drv->copy_user)
285382d81f5cSKuninori Morimoto 			rtd->ops.copy_user	= snd_soc_pcm_component_copy_user;
2854e9067bb5SKuninori Morimoto 		if (drv->page)
28559c712e4fSKuninori Morimoto 			rtd->ops.page		= snd_soc_pcm_component_page;
2856e9067bb5SKuninori Morimoto 		if (drv->mmap)
2857205875e1SKuninori Morimoto 			rtd->ops.mmap		= snd_soc_pcm_component_mmap;
2858b8135864SKuninori Morimoto 	}
2859b8135864SKuninori Morimoto 
2860ddee627cSLiam Girdwood 	if (playback)
286101d7584cSLiam Girdwood 		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &rtd->ops);
2862ddee627cSLiam Girdwood 
2863ddee627cSLiam Girdwood 	if (capture)
286401d7584cSLiam Girdwood 		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &rtd->ops);
2865ddee627cSLiam Girdwood 
2866b2b2afbbSKuninori Morimoto 	ret = snd_soc_pcm_component_new(rtd);
2867ddee627cSLiam Girdwood 	if (ret < 0) {
2868799827a4SPierre-Louis Bossart 		dev_err(rtd->dev, "ASoC: pcm %s constructor failed for dailink %s: %d\n",
2869799827a4SPierre-Louis Bossart 			new_name, rtd->dai_link->name, ret);
2870ddee627cSLiam Girdwood 		return ret;
2871ddee627cSLiam Girdwood 	}
2872c641e5b2SJohan Hovold 
28733d21ef0bSTakashi Iwai 	pcm->no_device_suspend = true;
287401d7584cSLiam Girdwood out:
28751d5cd525SPierre-Louis Bossart 	dev_dbg(rtd->card->dev, "%s <-> %s mapping ok\n",
2876c2233a26SKuninori Morimoto 		(rtd->num_codecs > 1) ? "multicodec" : asoc_rtd_to_codec(rtd, 0)->name,
2877c2233a26SKuninori Morimoto 		(rtd->num_cpus > 1)   ? "multicpu"   : asoc_rtd_to_cpu(rtd, 0)->name);
2878ddee627cSLiam Girdwood 	return ret;
2879ddee627cSLiam Girdwood }
288001d7584cSLiam Girdwood 
288101d7584cSLiam Girdwood /* is the current PCM operation for this FE ? */
288201d7584cSLiam Girdwood int snd_soc_dpcm_fe_can_update(struct snd_soc_pcm_runtime *fe, int stream)
288301d7584cSLiam Girdwood {
288401d7584cSLiam Girdwood 	if (fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE)
288501d7584cSLiam Girdwood 		return 1;
288601d7584cSLiam Girdwood 	return 0;
288701d7584cSLiam Girdwood }
288801d7584cSLiam Girdwood EXPORT_SYMBOL_GPL(snd_soc_dpcm_fe_can_update);
288901d7584cSLiam Girdwood 
289001d7584cSLiam Girdwood /* is the current PCM operation for this BE ? */
289101d7584cSLiam Girdwood int snd_soc_dpcm_be_can_update(struct snd_soc_pcm_runtime *fe,
289201d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be, int stream)
289301d7584cSLiam Girdwood {
289401d7584cSLiam Girdwood 	if ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE) ||
289501d7584cSLiam Girdwood 	   ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_BE) &&
289601d7584cSLiam Girdwood 		  be->dpcm[stream].runtime_update))
289701d7584cSLiam Girdwood 		return 1;
289801d7584cSLiam Girdwood 	return 0;
289901d7584cSLiam Girdwood }
290001d7584cSLiam Girdwood EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_can_update);
290101d7584cSLiam Girdwood 
290201d7584cSLiam Girdwood /* get the substream for this BE */
290301d7584cSLiam Girdwood struct snd_pcm_substream *
290401d7584cSLiam Girdwood 	snd_soc_dpcm_get_substream(struct snd_soc_pcm_runtime *be, int stream)
290501d7584cSLiam Girdwood {
290601d7584cSLiam Girdwood 	return be->pcm->streams[stream].substream;
290701d7584cSLiam Girdwood }
290801d7584cSLiam Girdwood EXPORT_SYMBOL_GPL(snd_soc_dpcm_get_substream);
290901d7584cSLiam Girdwood 
2910085d22beSKuninori Morimoto static int snd_soc_dpcm_check_state(struct snd_soc_pcm_runtime *fe,
2911085d22beSKuninori Morimoto 				    struct snd_soc_pcm_runtime *be,
2912085d22beSKuninori Morimoto 				    int stream,
2913085d22beSKuninori Morimoto 				    const enum snd_soc_dpcm_state *states,
2914085d22beSKuninori Morimoto 				    int num_states)
291501d7584cSLiam Girdwood {
291601d7584cSLiam Girdwood 	struct snd_soc_dpcm *dpcm;
291701d7584cSLiam Girdwood 	int state;
2918a9764869SKaiChieh Chuang 	int ret = 1;
2919a9764869SKaiChieh Chuang 	unsigned long flags;
2920085d22beSKuninori Morimoto 	int i;
292101d7584cSLiam Girdwood 
2922a9764869SKaiChieh Chuang 	spin_lock_irqsave(&fe->card->dpcm_lock, flags);
2923d2e24d64SKuninori Morimoto 	for_each_dpcm_fe(be, stream, dpcm) {
292401d7584cSLiam Girdwood 
292501d7584cSLiam Girdwood 		if (dpcm->fe == fe)
292601d7584cSLiam Girdwood 			continue;
292701d7584cSLiam Girdwood 
292801d7584cSLiam Girdwood 		state = dpcm->fe->dpcm[stream].state;
2929085d22beSKuninori Morimoto 		for (i = 0; i < num_states; i++) {
2930085d22beSKuninori Morimoto 			if (state == states[i]) {
2931a9764869SKaiChieh Chuang 				ret = 0;
2932a9764869SKaiChieh Chuang 				break;
293301d7584cSLiam Girdwood 			}
2934a9764869SKaiChieh Chuang 		}
2935085d22beSKuninori Morimoto 	}
2936a9764869SKaiChieh Chuang 	spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
293701d7584cSLiam Girdwood 
2938085d22beSKuninori Morimoto 	/* it's safe to do this BE DAI */
2939a9764869SKaiChieh Chuang 	return ret;
294001d7584cSLiam Girdwood }
2941085d22beSKuninori Morimoto 
2942085d22beSKuninori Morimoto /*
2943085d22beSKuninori Morimoto  * We can only hw_free, stop, pause or suspend a BE DAI if any of it's FE
2944085d22beSKuninori Morimoto  * are not running, paused or suspended for the specified stream direction.
2945085d22beSKuninori Morimoto  */
2946085d22beSKuninori Morimoto int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime *fe,
2947085d22beSKuninori Morimoto 		struct snd_soc_pcm_runtime *be, int stream)
2948085d22beSKuninori Morimoto {
2949085d22beSKuninori Morimoto 	const enum snd_soc_dpcm_state state[] = {
2950085d22beSKuninori Morimoto 		SND_SOC_DPCM_STATE_START,
2951085d22beSKuninori Morimoto 		SND_SOC_DPCM_STATE_PAUSED,
2952085d22beSKuninori Morimoto 		SND_SOC_DPCM_STATE_SUSPEND,
2953085d22beSKuninori Morimoto 	};
2954085d22beSKuninori Morimoto 
2955085d22beSKuninori Morimoto 	return snd_soc_dpcm_check_state(fe, be, stream, state, ARRAY_SIZE(state));
2956085d22beSKuninori Morimoto }
295701d7584cSLiam Girdwood EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop);
295801d7584cSLiam Girdwood 
295901d7584cSLiam Girdwood /*
296001d7584cSLiam Girdwood  * We can only change hw params a BE DAI if any of it's FE are not prepared,
296101d7584cSLiam Girdwood  * running, paused or suspended for the specified stream direction.
296201d7584cSLiam Girdwood  */
296301d7584cSLiam Girdwood int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime *fe,
296401d7584cSLiam Girdwood 		struct snd_soc_pcm_runtime *be, int stream)
296501d7584cSLiam Girdwood {
2966085d22beSKuninori Morimoto 	const enum snd_soc_dpcm_state state[] = {
2967085d22beSKuninori Morimoto 		SND_SOC_DPCM_STATE_START,
2968085d22beSKuninori Morimoto 		SND_SOC_DPCM_STATE_PAUSED,
2969085d22beSKuninori Morimoto 		SND_SOC_DPCM_STATE_SUSPEND,
2970085d22beSKuninori Morimoto 		SND_SOC_DPCM_STATE_PREPARE,
2971085d22beSKuninori Morimoto 	};
297201d7584cSLiam Girdwood 
2973085d22beSKuninori Morimoto 	return snd_soc_dpcm_check_state(fe, be, stream, state, ARRAY_SIZE(state));
297401d7584cSLiam Girdwood }
297501d7584cSLiam Girdwood EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params);
2976