xref: /openbmc/linux/sound/soc/soc-pcm.c (revision a2fb4d78)
1 /*
2  * soc-pcm.c  --  ALSA SoC PCM
3  *
4  * Copyright 2005 Wolfson Microelectronics PLC.
5  * Copyright 2005 Openedhand Ltd.
6  * Copyright (C) 2010 Slimlogic Ltd.
7  * Copyright (C) 2010 Texas Instruments Inc.
8  *
9  * Authors: Liam Girdwood <lrg@ti.com>
10  *          Mark Brown <broonie@opensource.wolfsonmicro.com>
11  *
12  *  This program is free software; you can redistribute  it and/or modify it
13  *  under  the terms of  the GNU General  Public License as published by the
14  *  Free Software Foundation;  either version 2 of the  License, or (at your
15  *  option) any later version.
16  *
17  */
18 
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/delay.h>
22 #include <linux/pinctrl/consumer.h>
23 #include <linux/pm_runtime.h>
24 #include <linux/slab.h>
25 #include <linux/workqueue.h>
26 #include <linux/export.h>
27 #include <linux/debugfs.h>
28 #include <sound/core.h>
29 #include <sound/pcm.h>
30 #include <sound/pcm_params.h>
31 #include <sound/soc.h>
32 #include <sound/soc-dpcm.h>
33 #include <sound/initval.h>
34 
35 #define DPCM_MAX_BE_USERS	8
36 
37 /**
38  * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
39  * @substream: the pcm substream
40  * @hw: the hardware parameters
41  *
42  * Sets the substream runtime hardware parameters.
43  */
44 int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
45 	const struct snd_pcm_hardware *hw)
46 {
47 	struct snd_pcm_runtime *runtime = substream->runtime;
48 	runtime->hw.info = hw->info;
49 	runtime->hw.formats = hw->formats;
50 	runtime->hw.period_bytes_min = hw->period_bytes_min;
51 	runtime->hw.period_bytes_max = hw->period_bytes_max;
52 	runtime->hw.periods_min = hw->periods_min;
53 	runtime->hw.periods_max = hw->periods_max;
54 	runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
55 	runtime->hw.fifo_size = hw->fifo_size;
56 	return 0;
57 }
58 EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
59 
60 /* DPCM stream event, send event to FE and all active BEs. */
61 int dpcm_dapm_stream_event(struct snd_soc_pcm_runtime *fe, int dir,
62 	int event)
63 {
64 	struct snd_soc_dpcm *dpcm;
65 
66 	list_for_each_entry(dpcm, &fe->dpcm[dir].be_clients, list_be) {
67 
68 		struct snd_soc_pcm_runtime *be = dpcm->be;
69 
70 		dev_dbg(be->dev, "ASoC: BE %s event %d dir %d\n",
71 				be->dai_link->name, event, dir);
72 
73 		snd_soc_dapm_stream_event(be, dir, event);
74 	}
75 
76 	snd_soc_dapm_stream_event(fe, dir, event);
77 
78 	return 0;
79 }
80 
81 static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream,
82 					struct snd_soc_dai *soc_dai)
83 {
84 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
85 	int ret;
86 
87 	if (soc_dai->rate && (soc_dai->driver->symmetric_rates ||
88 				rtd->dai_link->symmetric_rates)) {
89 		dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %dHz rate\n",
90 				soc_dai->rate);
91 
92 		ret = snd_pcm_hw_constraint_minmax(substream->runtime,
93 						SNDRV_PCM_HW_PARAM_RATE,
94 						soc_dai->rate, soc_dai->rate);
95 		if (ret < 0) {
96 			dev_err(soc_dai->dev,
97 				"ASoC: Unable to apply rate constraint: %d\n",
98 				ret);
99 			return ret;
100 		}
101 	}
102 
103 	if (soc_dai->channels && (soc_dai->driver->symmetric_channels ||
104 				rtd->dai_link->symmetric_channels)) {
105 		dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %d channel(s)\n",
106 				soc_dai->channels);
107 
108 		ret = snd_pcm_hw_constraint_minmax(substream->runtime,
109 						SNDRV_PCM_HW_PARAM_CHANNELS,
110 						soc_dai->channels,
111 						soc_dai->channels);
112 		if (ret < 0) {
113 			dev_err(soc_dai->dev,
114 				"ASoC: Unable to apply channel symmetry constraint: %d\n",
115 				ret);
116 			return ret;
117 		}
118 	}
119 
120 	if (soc_dai->sample_bits && (soc_dai->driver->symmetric_samplebits ||
121 				rtd->dai_link->symmetric_samplebits)) {
122 		dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %d sample bits\n",
123 				soc_dai->sample_bits);
124 
125 		ret = snd_pcm_hw_constraint_minmax(substream->runtime,
126 						SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
127 						soc_dai->sample_bits,
128 						soc_dai->sample_bits);
129 		if (ret < 0) {
130 			dev_err(soc_dai->dev,
131 				"ASoC: Unable to apply sample bits symmetry constraint: %d\n",
132 				ret);
133 			return ret;
134 		}
135 	}
136 
137 	return 0;
138 }
139 
140 static int soc_pcm_params_symmetry(struct snd_pcm_substream *substream,
141 				struct snd_pcm_hw_params *params)
142 {
143 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
144 	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
145 	struct snd_soc_dai *codec_dai = rtd->codec_dai;
146 	unsigned int rate, channels, sample_bits, symmetry;
147 
148 	rate = params_rate(params);
149 	channels = params_channels(params);
150 	sample_bits = snd_pcm_format_physical_width(params_format(params));
151 
152 	/* reject unmatched parameters when applying symmetry */
153 	symmetry = cpu_dai->driver->symmetric_rates ||
154 		codec_dai->driver->symmetric_rates ||
155 		rtd->dai_link->symmetric_rates;
156 	if (symmetry && cpu_dai->rate && cpu_dai->rate != rate) {
157 		dev_err(rtd->dev, "ASoC: unmatched rate symmetry: %d - %d\n",
158 				cpu_dai->rate, rate);
159 		return -EINVAL;
160 	}
161 
162 	symmetry = cpu_dai->driver->symmetric_channels ||
163 		codec_dai->driver->symmetric_channels ||
164 		rtd->dai_link->symmetric_channels;
165 	if (symmetry && cpu_dai->channels && cpu_dai->channels != channels) {
166 		dev_err(rtd->dev, "ASoC: unmatched channel symmetry: %d - %d\n",
167 				cpu_dai->channels, channels);
168 		return -EINVAL;
169 	}
170 
171 	symmetry = cpu_dai->driver->symmetric_samplebits ||
172 		codec_dai->driver->symmetric_samplebits ||
173 		rtd->dai_link->symmetric_samplebits;
174 	if (symmetry && cpu_dai->sample_bits && cpu_dai->sample_bits != sample_bits) {
175 		dev_err(rtd->dev, "ASoC: unmatched sample bits symmetry: %d - %d\n",
176 				cpu_dai->sample_bits, sample_bits);
177 		return -EINVAL;
178 	}
179 
180 	return 0;
181 }
182 
183 static bool soc_pcm_has_symmetry(struct snd_pcm_substream *substream)
184 {
185 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
186 	struct snd_soc_dai_driver *cpu_driver = rtd->cpu_dai->driver;
187 	struct snd_soc_dai_driver *codec_driver = rtd->codec_dai->driver;
188 	struct snd_soc_dai_link *link = rtd->dai_link;
189 
190 	return cpu_driver->symmetric_rates || codec_driver->symmetric_rates ||
191 		link->symmetric_rates || cpu_driver->symmetric_channels ||
192 		codec_driver->symmetric_channels || link->symmetric_channels ||
193 		cpu_driver->symmetric_samplebits ||
194 		codec_driver->symmetric_samplebits ||
195 		link->symmetric_samplebits;
196 }
197 
198 /*
199  * List of sample sizes that might go over the bus for parameter
200  * application.  There ought to be a wildcard sample size for things
201  * like the DAC/ADC resolution to use but there isn't right now.
202  */
203 static int sample_sizes[] = {
204 	24, 32,
205 };
206 
207 static void soc_pcm_apply_msb(struct snd_pcm_substream *substream,
208 			      struct snd_soc_dai *dai)
209 {
210 	int ret, i, bits;
211 
212 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
213 		bits = dai->driver->playback.sig_bits;
214 	else
215 		bits = dai->driver->capture.sig_bits;
216 
217 	if (!bits)
218 		return;
219 
220 	for (i = 0; i < ARRAY_SIZE(sample_sizes); i++) {
221 		if (bits >= sample_sizes[i])
222 			continue;
223 
224 		ret = snd_pcm_hw_constraint_msbits(substream->runtime, 0,
225 						   sample_sizes[i], bits);
226 		if (ret != 0)
227 			dev_warn(dai->dev,
228 				 "ASoC: Failed to set MSB %d/%d: %d\n",
229 				 bits, sample_sizes[i], ret);
230 	}
231 }
232 
233 static void soc_pcm_init_runtime_hw(struct snd_pcm_runtime *runtime,
234 	struct snd_soc_pcm_stream *codec_stream,
235 	struct snd_soc_pcm_stream *cpu_stream)
236 {
237 	struct snd_pcm_hardware *hw = &runtime->hw;
238 
239 	hw->channels_min = max(codec_stream->channels_min,
240 		cpu_stream->channels_min);
241 	hw->channels_max = min(codec_stream->channels_max,
242 		cpu_stream->channels_max);
243 	if (hw->formats)
244 		hw->formats &= codec_stream->formats & cpu_stream->formats;
245 	else
246 		hw->formats = codec_stream->formats & cpu_stream->formats;
247 	hw->rates = snd_pcm_rate_mask_intersect(codec_stream->rates,
248 		cpu_stream->rates);
249 
250 	hw->rate_min = 0;
251 	hw->rate_max = UINT_MAX;
252 
253 	snd_pcm_limit_hw_rates(runtime);
254 
255 	hw->rate_min = max(hw->rate_min, cpu_stream->rate_min);
256 	hw->rate_min = max(hw->rate_min, codec_stream->rate_min);
257 	hw->rate_max = min_not_zero(hw->rate_max, cpu_stream->rate_max);
258 	hw->rate_max = min_not_zero(hw->rate_max, codec_stream->rate_max);
259 }
260 
261 /*
262  * Called by ALSA when a PCM substream is opened, the runtime->hw record is
263  * then initialized and any private data can be allocated. This also calls
264  * startup for the cpu DAI, platform, machine and codec DAI.
265  */
266 static int soc_pcm_open(struct snd_pcm_substream *substream)
267 {
268 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
269 	struct snd_pcm_runtime *runtime = substream->runtime;
270 	struct snd_soc_platform *platform = rtd->platform;
271 	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
272 	struct snd_soc_dai *codec_dai = rtd->codec_dai;
273 	struct snd_soc_dai_driver *cpu_dai_drv = cpu_dai->driver;
274 	struct snd_soc_dai_driver *codec_dai_drv = codec_dai->driver;
275 	int ret = 0;
276 
277 	pinctrl_pm_select_default_state(cpu_dai->dev);
278 	pinctrl_pm_select_default_state(codec_dai->dev);
279 	pm_runtime_get_sync(cpu_dai->dev);
280 	pm_runtime_get_sync(codec_dai->dev);
281 	pm_runtime_get_sync(platform->dev);
282 
283 	mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
284 
285 	/* startup the audio subsystem */
286 	if (cpu_dai->driver->ops && cpu_dai->driver->ops->startup) {
287 		ret = cpu_dai->driver->ops->startup(substream, cpu_dai);
288 		if (ret < 0) {
289 			dev_err(cpu_dai->dev, "ASoC: can't open interface"
290 				" %s: %d\n", cpu_dai->name, ret);
291 			goto out;
292 		}
293 	}
294 
295 	if (platform->driver->ops && platform->driver->ops->open) {
296 		ret = platform->driver->ops->open(substream);
297 		if (ret < 0) {
298 			dev_err(platform->dev, "ASoC: can't open platform"
299 				" %s: %d\n", platform->name, ret);
300 			goto platform_err;
301 		}
302 	}
303 
304 	if (codec_dai->driver->ops && codec_dai->driver->ops->startup) {
305 		ret = codec_dai->driver->ops->startup(substream, codec_dai);
306 		if (ret < 0) {
307 			dev_err(codec_dai->dev, "ASoC: can't open codec"
308 				" %s: %d\n", codec_dai->name, ret);
309 			goto codec_dai_err;
310 		}
311 	}
312 
313 	if (rtd->dai_link->ops && rtd->dai_link->ops->startup) {
314 		ret = rtd->dai_link->ops->startup(substream);
315 		if (ret < 0) {
316 			pr_err("ASoC: %s startup failed: %d\n",
317 			       rtd->dai_link->name, ret);
318 			goto machine_err;
319 		}
320 	}
321 
322 	/* Dynamic PCM DAI links compat checks use dynamic capabilities */
323 	if (rtd->dai_link->dynamic || rtd->dai_link->no_pcm)
324 		goto dynamic;
325 
326 	/* Check that the codec and cpu DAIs are compatible */
327 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
328 		soc_pcm_init_runtime_hw(runtime, &codec_dai_drv->playback,
329 			&cpu_dai_drv->playback);
330 	} else {
331 		soc_pcm_init_runtime_hw(runtime, &codec_dai_drv->capture,
332 			&cpu_dai_drv->capture);
333 	}
334 
335 	if (soc_pcm_has_symmetry(substream))
336 		runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX;
337 
338 	ret = -EINVAL;
339 	if (!runtime->hw.rates) {
340 		printk(KERN_ERR "ASoC: %s <-> %s No matching rates\n",
341 			codec_dai->name, cpu_dai->name);
342 		goto config_err;
343 	}
344 	if (!runtime->hw.formats) {
345 		printk(KERN_ERR "ASoC: %s <-> %s No matching formats\n",
346 			codec_dai->name, cpu_dai->name);
347 		goto config_err;
348 	}
349 	if (!runtime->hw.channels_min || !runtime->hw.channels_max ||
350 	    runtime->hw.channels_min > runtime->hw.channels_max) {
351 		printk(KERN_ERR "ASoC: %s <-> %s No matching channels\n",
352 				codec_dai->name, cpu_dai->name);
353 		goto config_err;
354 	}
355 
356 	soc_pcm_apply_msb(substream, codec_dai);
357 	soc_pcm_apply_msb(substream, cpu_dai);
358 
359 	/* Symmetry only applies if we've already got an active stream. */
360 	if (cpu_dai->active) {
361 		ret = soc_pcm_apply_symmetry(substream, cpu_dai);
362 		if (ret != 0)
363 			goto config_err;
364 	}
365 
366 	if (codec_dai->active) {
367 		ret = soc_pcm_apply_symmetry(substream, codec_dai);
368 		if (ret != 0)
369 			goto config_err;
370 	}
371 
372 	pr_debug("ASoC: %s <-> %s info:\n",
373 			codec_dai->name, cpu_dai->name);
374 	pr_debug("ASoC: rate mask 0x%x\n", runtime->hw.rates);
375 	pr_debug("ASoC: min ch %d max ch %d\n", runtime->hw.channels_min,
376 		 runtime->hw.channels_max);
377 	pr_debug("ASoC: min rate %d max rate %d\n", runtime->hw.rate_min,
378 		 runtime->hw.rate_max);
379 
380 dynamic:
381 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
382 		cpu_dai->playback_active++;
383 		codec_dai->playback_active++;
384 	} else {
385 		cpu_dai->capture_active++;
386 		codec_dai->capture_active++;
387 	}
388 	cpu_dai->active++;
389 	codec_dai->active++;
390 	rtd->codec->active++;
391 	mutex_unlock(&rtd->pcm_mutex);
392 	return 0;
393 
394 config_err:
395 	if (rtd->dai_link->ops && rtd->dai_link->ops->shutdown)
396 		rtd->dai_link->ops->shutdown(substream);
397 
398 machine_err:
399 	if (codec_dai->driver->ops->shutdown)
400 		codec_dai->driver->ops->shutdown(substream, codec_dai);
401 
402 codec_dai_err:
403 	if (platform->driver->ops && platform->driver->ops->close)
404 		platform->driver->ops->close(substream);
405 
406 platform_err:
407 	if (cpu_dai->driver->ops->shutdown)
408 		cpu_dai->driver->ops->shutdown(substream, cpu_dai);
409 out:
410 	mutex_unlock(&rtd->pcm_mutex);
411 
412 	pm_runtime_put(platform->dev);
413 	pm_runtime_put(codec_dai->dev);
414 	pm_runtime_put(cpu_dai->dev);
415 	if (!codec_dai->active)
416 		pinctrl_pm_select_sleep_state(codec_dai->dev);
417 	if (!cpu_dai->active)
418 		pinctrl_pm_select_sleep_state(cpu_dai->dev);
419 
420 	return ret;
421 }
422 
423 /*
424  * Power down the audio subsystem pmdown_time msecs after close is called.
425  * This is to ensure there are no pops or clicks in between any music tracks
426  * due to DAPM power cycling.
427  */
428 static void close_delayed_work(struct work_struct *work)
429 {
430 	struct snd_soc_pcm_runtime *rtd =
431 			container_of(work, struct snd_soc_pcm_runtime, delayed_work.work);
432 	struct snd_soc_dai *codec_dai = rtd->codec_dai;
433 
434 	mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
435 
436 	dev_dbg(rtd->dev, "ASoC: pop wq checking: %s status: %s waiting: %s\n",
437 		 codec_dai->driver->playback.stream_name,
438 		 codec_dai->playback_active ? "active" : "inactive",
439 		 rtd->pop_wait ? "yes" : "no");
440 
441 	/* are we waiting on this codec DAI stream */
442 	if (rtd->pop_wait == 1) {
443 		rtd->pop_wait = 0;
444 		snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_PLAYBACK,
445 					  SND_SOC_DAPM_STREAM_STOP);
446 	}
447 
448 	mutex_unlock(&rtd->pcm_mutex);
449 }
450 
451 /*
452  * Called by ALSA when a PCM substream is closed. Private data can be
453  * freed here. The cpu DAI, codec DAI, machine and platform are also
454  * shutdown.
455  */
456 static int soc_pcm_close(struct snd_pcm_substream *substream)
457 {
458 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
459 	struct snd_soc_platform *platform = rtd->platform;
460 	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
461 	struct snd_soc_dai *codec_dai = rtd->codec_dai;
462 	struct snd_soc_codec *codec = rtd->codec;
463 
464 	mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
465 
466 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
467 		cpu_dai->playback_active--;
468 		codec_dai->playback_active--;
469 	} else {
470 		cpu_dai->capture_active--;
471 		codec_dai->capture_active--;
472 	}
473 
474 	cpu_dai->active--;
475 	codec_dai->active--;
476 	codec->active--;
477 
478 	/* clear the corresponding DAIs rate when inactive */
479 	if (!cpu_dai->active)
480 		cpu_dai->rate = 0;
481 
482 	if (!codec_dai->active)
483 		codec_dai->rate = 0;
484 
485 	if (cpu_dai->driver->ops->shutdown)
486 		cpu_dai->driver->ops->shutdown(substream, cpu_dai);
487 
488 	if (codec_dai->driver->ops->shutdown)
489 		codec_dai->driver->ops->shutdown(substream, codec_dai);
490 
491 	if (rtd->dai_link->ops && rtd->dai_link->ops->shutdown)
492 		rtd->dai_link->ops->shutdown(substream);
493 
494 	if (platform->driver->ops && platform->driver->ops->close)
495 		platform->driver->ops->close(substream);
496 	cpu_dai->runtime = NULL;
497 
498 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
499 		if (!rtd->pmdown_time || codec->ignore_pmdown_time ||
500 		    rtd->dai_link->ignore_pmdown_time) {
501 			/* powered down playback stream now */
502 			snd_soc_dapm_stream_event(rtd,
503 						  SNDRV_PCM_STREAM_PLAYBACK,
504 						  SND_SOC_DAPM_STREAM_STOP);
505 		} else {
506 			/* start delayed pop wq here for playback streams */
507 			rtd->pop_wait = 1;
508 			queue_delayed_work(system_power_efficient_wq,
509 					   &rtd->delayed_work,
510 					   msecs_to_jiffies(rtd->pmdown_time));
511 		}
512 	} else {
513 		/* capture streams can be powered down now */
514 		snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE,
515 					  SND_SOC_DAPM_STREAM_STOP);
516 	}
517 
518 	mutex_unlock(&rtd->pcm_mutex);
519 
520 	pm_runtime_put(platform->dev);
521 	pm_runtime_put(codec_dai->dev);
522 	pm_runtime_put(cpu_dai->dev);
523 	if (!codec_dai->active)
524 		pinctrl_pm_select_sleep_state(codec_dai->dev);
525 	if (!cpu_dai->active)
526 		pinctrl_pm_select_sleep_state(cpu_dai->dev);
527 
528 	return 0;
529 }
530 
531 /*
532  * Called by ALSA when the PCM substream is prepared, can set format, sample
533  * rate, etc.  This function is non atomic and can be called multiple times,
534  * it can refer to the runtime info.
535  */
536 static int soc_pcm_prepare(struct snd_pcm_substream *substream)
537 {
538 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
539 	struct snd_soc_platform *platform = rtd->platform;
540 	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
541 	struct snd_soc_dai *codec_dai = rtd->codec_dai;
542 	int ret = 0;
543 
544 	mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
545 
546 	if (rtd->dai_link->ops && rtd->dai_link->ops->prepare) {
547 		ret = rtd->dai_link->ops->prepare(substream);
548 		if (ret < 0) {
549 			dev_err(rtd->card->dev, "ASoC: machine prepare error:"
550 				" %d\n", ret);
551 			goto out;
552 		}
553 	}
554 
555 	if (platform->driver->ops && platform->driver->ops->prepare) {
556 		ret = platform->driver->ops->prepare(substream);
557 		if (ret < 0) {
558 			dev_err(platform->dev, "ASoC: platform prepare error:"
559 				" %d\n", ret);
560 			goto out;
561 		}
562 	}
563 
564 	if (codec_dai->driver->ops && codec_dai->driver->ops->prepare) {
565 		ret = codec_dai->driver->ops->prepare(substream, codec_dai);
566 		if (ret < 0) {
567 			dev_err(codec_dai->dev, "ASoC: DAI prepare error: %d\n",
568 				ret);
569 			goto out;
570 		}
571 	}
572 
573 	if (cpu_dai->driver->ops && cpu_dai->driver->ops->prepare) {
574 		ret = cpu_dai->driver->ops->prepare(substream, cpu_dai);
575 		if (ret < 0) {
576 			dev_err(cpu_dai->dev, "ASoC: DAI prepare error: %d\n",
577 				ret);
578 			goto out;
579 		}
580 	}
581 
582 	/* cancel any delayed stream shutdown that is pending */
583 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
584 	    rtd->pop_wait) {
585 		rtd->pop_wait = 0;
586 		cancel_delayed_work(&rtd->delayed_work);
587 	}
588 
589 	snd_soc_dapm_stream_event(rtd, substream->stream,
590 			SND_SOC_DAPM_STREAM_START);
591 
592 	snd_soc_dai_digital_mute(codec_dai, 0, substream->stream);
593 
594 out:
595 	mutex_unlock(&rtd->pcm_mutex);
596 	return ret;
597 }
598 
599 /*
600  * Called by ALSA when the hardware params are set by application. This
601  * function can also be called multiple times and can allocate buffers
602  * (using snd_pcm_lib_* ). It's non-atomic.
603  */
604 static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
605 				struct snd_pcm_hw_params *params)
606 {
607 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
608 	struct snd_soc_platform *platform = rtd->platform;
609 	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
610 	struct snd_soc_dai *codec_dai = rtd->codec_dai;
611 	int ret = 0;
612 
613 	mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
614 
615 	ret = soc_pcm_params_symmetry(substream, params);
616 	if (ret)
617 		goto out;
618 
619 	if (rtd->dai_link->ops && rtd->dai_link->ops->hw_params) {
620 		ret = rtd->dai_link->ops->hw_params(substream, params);
621 		if (ret < 0) {
622 			dev_err(rtd->card->dev, "ASoC: machine hw_params"
623 				" failed: %d\n", ret);
624 			goto out;
625 		}
626 	}
627 
628 	if (codec_dai->driver->ops && codec_dai->driver->ops->hw_params) {
629 		ret = codec_dai->driver->ops->hw_params(substream, params, codec_dai);
630 		if (ret < 0) {
631 			dev_err(codec_dai->dev, "ASoC: can't set %s hw params:"
632 				" %d\n", codec_dai->name, ret);
633 			goto codec_err;
634 		}
635 	}
636 
637 	if (cpu_dai->driver->ops && cpu_dai->driver->ops->hw_params) {
638 		ret = cpu_dai->driver->ops->hw_params(substream, params, cpu_dai);
639 		if (ret < 0) {
640 			dev_err(cpu_dai->dev, "ASoC: %s hw params failed: %d\n",
641 				cpu_dai->name, ret);
642 			goto interface_err;
643 		}
644 	}
645 
646 	if (platform->driver->ops && platform->driver->ops->hw_params) {
647 		ret = platform->driver->ops->hw_params(substream, params);
648 		if (ret < 0) {
649 			dev_err(platform->dev, "ASoC: %s hw params failed: %d\n",
650 			       platform->name, ret);
651 			goto platform_err;
652 		}
653 	}
654 
655 	/* store the parameters for each DAIs */
656 	cpu_dai->rate = params_rate(params);
657 	cpu_dai->channels = params_channels(params);
658 	cpu_dai->sample_bits =
659 		snd_pcm_format_physical_width(params_format(params));
660 
661 	codec_dai->rate = params_rate(params);
662 	codec_dai->channels = params_channels(params);
663 	codec_dai->sample_bits =
664 		snd_pcm_format_physical_width(params_format(params));
665 
666 out:
667 	mutex_unlock(&rtd->pcm_mutex);
668 	return ret;
669 
670 platform_err:
671 	if (cpu_dai->driver->ops && cpu_dai->driver->ops->hw_free)
672 		cpu_dai->driver->ops->hw_free(substream, cpu_dai);
673 
674 interface_err:
675 	if (codec_dai->driver->ops && codec_dai->driver->ops->hw_free)
676 		codec_dai->driver->ops->hw_free(substream, codec_dai);
677 
678 codec_err:
679 	if (rtd->dai_link->ops && rtd->dai_link->ops->hw_free)
680 		rtd->dai_link->ops->hw_free(substream);
681 
682 	mutex_unlock(&rtd->pcm_mutex);
683 	return ret;
684 }
685 
686 /*
687  * Frees resources allocated by hw_params, can be called multiple times
688  */
689 static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
690 {
691 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
692 	struct snd_soc_platform *platform = rtd->platform;
693 	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
694 	struct snd_soc_dai *codec_dai = rtd->codec_dai;
695 	bool playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
696 
697 	mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
698 
699 	/* clear the corresponding DAIs parameters when going to be inactive */
700 	if (cpu_dai->active == 1) {
701 		cpu_dai->rate = 0;
702 		cpu_dai->channels = 0;
703 		cpu_dai->sample_bits = 0;
704 	}
705 
706 	if (codec_dai->active == 1) {
707 		codec_dai->rate = 0;
708 		codec_dai->channels = 0;
709 		codec_dai->sample_bits = 0;
710 	}
711 
712 	/* apply codec digital mute */
713 	if ((playback && codec_dai->playback_active == 1) ||
714 	    (!playback && codec_dai->capture_active == 1))
715 		snd_soc_dai_digital_mute(codec_dai, 1, substream->stream);
716 
717 	/* free any machine hw params */
718 	if (rtd->dai_link->ops && rtd->dai_link->ops->hw_free)
719 		rtd->dai_link->ops->hw_free(substream);
720 
721 	/* free any DMA resources */
722 	if (platform->driver->ops && platform->driver->ops->hw_free)
723 		platform->driver->ops->hw_free(substream);
724 
725 	/* now free hw params for the DAIs  */
726 	if (codec_dai->driver->ops && codec_dai->driver->ops->hw_free)
727 		codec_dai->driver->ops->hw_free(substream, codec_dai);
728 
729 	if (cpu_dai->driver->ops && cpu_dai->driver->ops->hw_free)
730 		cpu_dai->driver->ops->hw_free(substream, cpu_dai);
731 
732 	mutex_unlock(&rtd->pcm_mutex);
733 	return 0;
734 }
735 
736 static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
737 {
738 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
739 	struct snd_soc_platform *platform = rtd->platform;
740 	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
741 	struct snd_soc_dai *codec_dai = rtd->codec_dai;
742 	int ret;
743 
744 	if (codec_dai->driver->ops && codec_dai->driver->ops->trigger) {
745 		ret = codec_dai->driver->ops->trigger(substream, cmd, codec_dai);
746 		if (ret < 0)
747 			return ret;
748 	}
749 
750 	if (platform->driver->ops && platform->driver->ops->trigger) {
751 		ret = platform->driver->ops->trigger(substream, cmd);
752 		if (ret < 0)
753 			return ret;
754 	}
755 
756 	if (cpu_dai->driver->ops && cpu_dai->driver->ops->trigger) {
757 		ret = cpu_dai->driver->ops->trigger(substream, cmd, cpu_dai);
758 		if (ret < 0)
759 			return ret;
760 	}
761 	return 0;
762 }
763 
764 static int soc_pcm_bespoke_trigger(struct snd_pcm_substream *substream,
765 				   int cmd)
766 {
767 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
768 	struct snd_soc_platform *platform = rtd->platform;
769 	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
770 	struct snd_soc_dai *codec_dai = rtd->codec_dai;
771 	int ret;
772 
773 	if (codec_dai->driver->ops &&
774 	    codec_dai->driver->ops->bespoke_trigger) {
775 		ret = codec_dai->driver->ops->bespoke_trigger(substream, cmd, codec_dai);
776 		if (ret < 0)
777 			return ret;
778 	}
779 
780 	if (platform->driver->bespoke_trigger) {
781 		ret = platform->driver->bespoke_trigger(substream, cmd);
782 		if (ret < 0)
783 			return ret;
784 	}
785 
786 	if (cpu_dai->driver->ops && cpu_dai->driver->ops->bespoke_trigger) {
787 		ret = cpu_dai->driver->ops->bespoke_trigger(substream, cmd, cpu_dai);
788 		if (ret < 0)
789 			return ret;
790 	}
791 	return 0;
792 }
793 /*
794  * soc level wrapper for pointer callback
795  * If cpu_dai, codec_dai, platform driver has the delay callback, than
796  * the runtime->delay will be updated accordingly.
797  */
798 static snd_pcm_uframes_t soc_pcm_pointer(struct snd_pcm_substream *substream)
799 {
800 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
801 	struct snd_soc_platform *platform = rtd->platform;
802 	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
803 	struct snd_soc_dai *codec_dai = rtd->codec_dai;
804 	struct snd_pcm_runtime *runtime = substream->runtime;
805 	snd_pcm_uframes_t offset = 0;
806 	snd_pcm_sframes_t delay = 0;
807 
808 	if (platform->driver->ops && platform->driver->ops->pointer)
809 		offset = platform->driver->ops->pointer(substream);
810 
811 	if (cpu_dai->driver->ops && cpu_dai->driver->ops->delay)
812 		delay += cpu_dai->driver->ops->delay(substream, cpu_dai);
813 
814 	if (codec_dai->driver->ops && codec_dai->driver->ops->delay)
815 		delay += codec_dai->driver->ops->delay(substream, codec_dai);
816 
817 	if (platform->driver->delay)
818 		delay += platform->driver->delay(substream, codec_dai);
819 
820 	runtime->delay = delay;
821 
822 	return offset;
823 }
824 
825 /* connect a FE and BE */
826 static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe,
827 		struct snd_soc_pcm_runtime *be, int stream)
828 {
829 	struct snd_soc_dpcm *dpcm;
830 
831 	/* only add new dpcms */
832 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
833 		if (dpcm->be == be && dpcm->fe == fe)
834 			return 0;
835 	}
836 
837 	dpcm = kzalloc(sizeof(struct snd_soc_dpcm), GFP_KERNEL);
838 	if (!dpcm)
839 		return -ENOMEM;
840 
841 	dpcm->be = be;
842 	dpcm->fe = fe;
843 	be->dpcm[stream].runtime = fe->dpcm[stream].runtime;
844 	dpcm->state = SND_SOC_DPCM_LINK_STATE_NEW;
845 	list_add(&dpcm->list_be, &fe->dpcm[stream].be_clients);
846 	list_add(&dpcm->list_fe, &be->dpcm[stream].fe_clients);
847 
848 	dev_dbg(fe->dev, "connected new DPCM %s path %s %s %s\n",
849 			stream ? "capture" : "playback",  fe->dai_link->name,
850 			stream ? "<-" : "->", be->dai_link->name);
851 
852 #ifdef CONFIG_DEBUG_FS
853 	dpcm->debugfs_state = debugfs_create_u32(be->dai_link->name, 0644,
854 			fe->debugfs_dpcm_root, &dpcm->state);
855 #endif
856 	return 1;
857 }
858 
859 /* reparent a BE onto another FE */
860 static void dpcm_be_reparent(struct snd_soc_pcm_runtime *fe,
861 			struct snd_soc_pcm_runtime *be, int stream)
862 {
863 	struct snd_soc_dpcm *dpcm;
864 	struct snd_pcm_substream *fe_substream, *be_substream;
865 
866 	/* reparent if BE is connected to other FEs */
867 	if (!be->dpcm[stream].users)
868 		return;
869 
870 	be_substream = snd_soc_dpcm_get_substream(be, stream);
871 
872 	list_for_each_entry(dpcm, &be->dpcm[stream].fe_clients, list_fe) {
873 		if (dpcm->fe == fe)
874 			continue;
875 
876 		dev_dbg(fe->dev, "reparent %s path %s %s %s\n",
877 			stream ? "capture" : "playback",
878 			dpcm->fe->dai_link->name,
879 			stream ? "<-" : "->", dpcm->be->dai_link->name);
880 
881 		fe_substream = snd_soc_dpcm_get_substream(dpcm->fe, stream);
882 		be_substream->runtime = fe_substream->runtime;
883 		break;
884 	}
885 }
886 
887 /* disconnect a BE and FE */
888 void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream)
889 {
890 	struct snd_soc_dpcm *dpcm, *d;
891 
892 	list_for_each_entry_safe(dpcm, d, &fe->dpcm[stream].be_clients, list_be) {
893 		dev_dbg(fe->dev, "ASoC: BE %s disconnect check for %s\n",
894 				stream ? "capture" : "playback",
895 				dpcm->be->dai_link->name);
896 
897 		if (dpcm->state != SND_SOC_DPCM_LINK_STATE_FREE)
898 			continue;
899 
900 		dev_dbg(fe->dev, "freed DSP %s path %s %s %s\n",
901 			stream ? "capture" : "playback", fe->dai_link->name,
902 			stream ? "<-" : "->", dpcm->be->dai_link->name);
903 
904 		/* BEs still alive need new FE */
905 		dpcm_be_reparent(fe, dpcm->be, stream);
906 
907 #ifdef CONFIG_DEBUG_FS
908 		debugfs_remove(dpcm->debugfs_state);
909 #endif
910 		list_del(&dpcm->list_be);
911 		list_del(&dpcm->list_fe);
912 		kfree(dpcm);
913 	}
914 }
915 
916 /* get BE for DAI widget and stream */
917 static struct snd_soc_pcm_runtime *dpcm_get_be(struct snd_soc_card *card,
918 		struct snd_soc_dapm_widget *widget, int stream)
919 {
920 	struct snd_soc_pcm_runtime *be;
921 	int i;
922 
923 	if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
924 		for (i = 0; i < card->num_links; i++) {
925 			be = &card->rtd[i];
926 
927 			if (!be->dai_link->no_pcm)
928 				continue;
929 
930 			if (be->cpu_dai->playback_widget == widget ||
931 				be->codec_dai->playback_widget == widget)
932 				return be;
933 		}
934 	} else {
935 
936 		for (i = 0; i < card->num_links; i++) {
937 			be = &card->rtd[i];
938 
939 			if (!be->dai_link->no_pcm)
940 				continue;
941 
942 			if (be->cpu_dai->capture_widget == widget ||
943 				be->codec_dai->capture_widget == widget)
944 				return be;
945 		}
946 	}
947 
948 	dev_err(card->dev, "ASoC: can't get %s BE for %s\n",
949 		stream ? "capture" : "playback", widget->name);
950 	return NULL;
951 }
952 
953 static inline struct snd_soc_dapm_widget *
954 	rtd_get_cpu_widget(struct snd_soc_pcm_runtime *rtd, int stream)
955 {
956 	if (stream == SNDRV_PCM_STREAM_PLAYBACK)
957 		return rtd->cpu_dai->playback_widget;
958 	else
959 		return rtd->cpu_dai->capture_widget;
960 }
961 
962 static inline struct snd_soc_dapm_widget *
963 	rtd_get_codec_widget(struct snd_soc_pcm_runtime *rtd, int stream)
964 {
965 	if (stream == SNDRV_PCM_STREAM_PLAYBACK)
966 		return rtd->codec_dai->playback_widget;
967 	else
968 		return rtd->codec_dai->capture_widget;
969 }
970 
971 static int widget_in_list(struct snd_soc_dapm_widget_list *list,
972 		struct snd_soc_dapm_widget *widget)
973 {
974 	int i;
975 
976 	for (i = 0; i < list->num_widgets; i++) {
977 		if (widget == list->widgets[i])
978 			return 1;
979 	}
980 
981 	return 0;
982 }
983 
984 int dpcm_path_get(struct snd_soc_pcm_runtime *fe,
985 	int stream, struct snd_soc_dapm_widget_list **list_)
986 {
987 	struct snd_soc_dai *cpu_dai = fe->cpu_dai;
988 	struct snd_soc_dapm_widget_list *list;
989 	int paths;
990 
991 	list = kzalloc(sizeof(struct snd_soc_dapm_widget_list) +
992 			sizeof(struct snd_soc_dapm_widget *), GFP_KERNEL);
993 	if (list == NULL)
994 		return -ENOMEM;
995 
996 	/* get number of valid DAI paths and their widgets */
997 	paths = snd_soc_dapm_dai_get_connected_widgets(cpu_dai, stream, &list);
998 
999 	dev_dbg(fe->dev, "ASoC: found %d audio %s paths\n", paths,
1000 			stream ? "capture" : "playback");
1001 
1002 	*list_ = list;
1003 	return paths;
1004 }
1005 
1006 static int dpcm_prune_paths(struct snd_soc_pcm_runtime *fe, int stream,
1007 	struct snd_soc_dapm_widget_list **list_)
1008 {
1009 	struct snd_soc_dpcm *dpcm;
1010 	struct snd_soc_dapm_widget_list *list = *list_;
1011 	struct snd_soc_dapm_widget *widget;
1012 	int prune = 0;
1013 
1014 	/* Destroy any old FE <--> BE connections */
1015 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
1016 
1017 		/* is there a valid CPU DAI widget for this BE */
1018 		widget = rtd_get_cpu_widget(dpcm->be, stream);
1019 
1020 		/* prune the BE if it's no longer in our active list */
1021 		if (widget && widget_in_list(list, widget))
1022 			continue;
1023 
1024 		/* is there a valid CODEC DAI widget for this BE */
1025 		widget = rtd_get_codec_widget(dpcm->be, stream);
1026 
1027 		/* prune the BE if it's no longer in our active list */
1028 		if (widget && widget_in_list(list, widget))
1029 			continue;
1030 
1031 		dev_dbg(fe->dev, "ASoC: pruning %s BE %s for %s\n",
1032 			stream ? "capture" : "playback",
1033 			dpcm->be->dai_link->name, fe->dai_link->name);
1034 		dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
1035 		dpcm->be->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_BE;
1036 		prune++;
1037 	}
1038 
1039 	dev_dbg(fe->dev, "ASoC: found %d old BE paths for pruning\n", prune);
1040 	return prune;
1041 }
1042 
1043 static int dpcm_add_paths(struct snd_soc_pcm_runtime *fe, int stream,
1044 	struct snd_soc_dapm_widget_list **list_)
1045 {
1046 	struct snd_soc_card *card = fe->card;
1047 	struct snd_soc_dapm_widget_list *list = *list_;
1048 	struct snd_soc_pcm_runtime *be;
1049 	int i, new = 0, err;
1050 
1051 	/* Create any new FE <--> BE connections */
1052 	for (i = 0; i < list->num_widgets; i++) {
1053 
1054 		switch (list->widgets[i]->id) {
1055 		case snd_soc_dapm_dai_in:
1056 		case snd_soc_dapm_dai_out:
1057 			break;
1058 		default:
1059 			continue;
1060 		}
1061 
1062 		/* is there a valid BE rtd for this widget */
1063 		be = dpcm_get_be(card, list->widgets[i], stream);
1064 		if (!be) {
1065 			dev_err(fe->dev, "ASoC: no BE found for %s\n",
1066 					list->widgets[i]->name);
1067 			continue;
1068 		}
1069 
1070 		/* make sure BE is a real BE */
1071 		if (!be->dai_link->no_pcm)
1072 			continue;
1073 
1074 		/* don't connect if FE is not running */
1075 		if (!fe->dpcm[stream].runtime && !fe->fe_compr)
1076 			continue;
1077 
1078 		/* newly connected FE and BE */
1079 		err = dpcm_be_connect(fe, be, stream);
1080 		if (err < 0) {
1081 			dev_err(fe->dev, "ASoC: can't connect %s\n",
1082 				list->widgets[i]->name);
1083 			break;
1084 		} else if (err == 0) /* already connected */
1085 			continue;
1086 
1087 		/* new */
1088 		be->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_BE;
1089 		new++;
1090 	}
1091 
1092 	dev_dbg(fe->dev, "ASoC: found %d new BE paths\n", new);
1093 	return new;
1094 }
1095 
1096 /*
1097  * Find the corresponding BE DAIs that source or sink audio to this
1098  * FE substream.
1099  */
1100 int dpcm_process_paths(struct snd_soc_pcm_runtime *fe,
1101 	int stream, struct snd_soc_dapm_widget_list **list, int new)
1102 {
1103 	if (new)
1104 		return dpcm_add_paths(fe, stream, list);
1105 	else
1106 		return dpcm_prune_paths(fe, stream, list);
1107 }
1108 
1109 void dpcm_clear_pending_state(struct snd_soc_pcm_runtime *fe, int stream)
1110 {
1111 	struct snd_soc_dpcm *dpcm;
1112 
1113 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
1114 		dpcm->be->dpcm[stream].runtime_update =
1115 						SND_SOC_DPCM_UPDATE_NO;
1116 }
1117 
1118 static void dpcm_be_dai_startup_unwind(struct snd_soc_pcm_runtime *fe,
1119 	int stream)
1120 {
1121 	struct snd_soc_dpcm *dpcm;
1122 
1123 	/* disable any enabled and non active backends */
1124 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
1125 
1126 		struct snd_soc_pcm_runtime *be = dpcm->be;
1127 		struct snd_pcm_substream *be_substream =
1128 			snd_soc_dpcm_get_substream(be, stream);
1129 
1130 		if (be->dpcm[stream].users == 0)
1131 			dev_err(be->dev, "ASoC: no users %s at close - state %d\n",
1132 				stream ? "capture" : "playback",
1133 				be->dpcm[stream].state);
1134 
1135 		if (--be->dpcm[stream].users != 0)
1136 			continue;
1137 
1138 		if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN)
1139 			continue;
1140 
1141 		soc_pcm_close(be_substream);
1142 		be_substream->runtime = NULL;
1143 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1144 	}
1145 }
1146 
1147 int dpcm_be_dai_startup(struct snd_soc_pcm_runtime *fe, int stream)
1148 {
1149 	struct snd_soc_dpcm *dpcm;
1150 	int err, count = 0;
1151 
1152 	/* only startup BE DAIs that are either sinks or sources to this FE DAI */
1153 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
1154 
1155 		struct snd_soc_pcm_runtime *be = dpcm->be;
1156 		struct snd_pcm_substream *be_substream =
1157 			snd_soc_dpcm_get_substream(be, stream);
1158 
1159 		if (!be_substream) {
1160 			dev_err(be->dev, "ASoC: no backend %s stream\n",
1161 				stream ? "capture" : "playback");
1162 			continue;
1163 		}
1164 
1165 		/* is this op for this BE ? */
1166 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1167 			continue;
1168 
1169 		/* first time the dpcm is open ? */
1170 		if (be->dpcm[stream].users == DPCM_MAX_BE_USERS)
1171 			dev_err(be->dev, "ASoC: too many users %s at open %d\n",
1172 				stream ? "capture" : "playback",
1173 				be->dpcm[stream].state);
1174 
1175 		if (be->dpcm[stream].users++ != 0)
1176 			continue;
1177 
1178 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_NEW) &&
1179 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_CLOSE))
1180 			continue;
1181 
1182 		dev_dbg(be->dev, "ASoC: open %s BE %s\n",
1183 			stream ? "capture" : "playback", be->dai_link->name);
1184 
1185 		be_substream->runtime = be->dpcm[stream].runtime;
1186 		err = soc_pcm_open(be_substream);
1187 		if (err < 0) {
1188 			dev_err(be->dev, "ASoC: BE open failed %d\n", err);
1189 			be->dpcm[stream].users--;
1190 			if (be->dpcm[stream].users < 0)
1191 				dev_err(be->dev, "ASoC: no users %s at unwind %d\n",
1192 					stream ? "capture" : "playback",
1193 					be->dpcm[stream].state);
1194 
1195 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1196 			goto unwind;
1197 		}
1198 
1199 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
1200 		count++;
1201 	}
1202 
1203 	return count;
1204 
1205 unwind:
1206 	/* disable any enabled and non active backends */
1207 	list_for_each_entry_continue_reverse(dpcm, &fe->dpcm[stream].be_clients, list_be) {
1208 		struct snd_soc_pcm_runtime *be = dpcm->be;
1209 		struct snd_pcm_substream *be_substream =
1210 			snd_soc_dpcm_get_substream(be, stream);
1211 
1212 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1213 			continue;
1214 
1215 		if (be->dpcm[stream].users == 0)
1216 			dev_err(be->dev, "ASoC: no users %s at close %d\n",
1217 				stream ? "capture" : "playback",
1218 				be->dpcm[stream].state);
1219 
1220 		if (--be->dpcm[stream].users != 0)
1221 			continue;
1222 
1223 		if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN)
1224 			continue;
1225 
1226 		soc_pcm_close(be_substream);
1227 		be_substream->runtime = NULL;
1228 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1229 	}
1230 
1231 	return err;
1232 }
1233 
1234 static void dpcm_init_runtime_hw(struct snd_pcm_runtime *runtime,
1235 	struct snd_soc_pcm_stream *stream)
1236 {
1237 	runtime->hw.rate_min = stream->rate_min;
1238 	runtime->hw.rate_max = stream->rate_max;
1239 	runtime->hw.channels_min = stream->channels_min;
1240 	runtime->hw.channels_max = stream->channels_max;
1241 	if (runtime->hw.formats)
1242 		runtime->hw.formats &= stream->formats;
1243 	else
1244 		runtime->hw.formats = stream->formats;
1245 	runtime->hw.rates = stream->rates;
1246 }
1247 
1248 static void dpcm_set_fe_runtime(struct snd_pcm_substream *substream)
1249 {
1250 	struct snd_pcm_runtime *runtime = substream->runtime;
1251 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
1252 	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1253 	struct snd_soc_dai_driver *cpu_dai_drv = cpu_dai->driver;
1254 
1255 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1256 		dpcm_init_runtime_hw(runtime, &cpu_dai_drv->playback);
1257 	else
1258 		dpcm_init_runtime_hw(runtime, &cpu_dai_drv->capture);
1259 }
1260 
1261 static int dpcm_fe_dai_startup(struct snd_pcm_substream *fe_substream)
1262 {
1263 	struct snd_soc_pcm_runtime *fe = fe_substream->private_data;
1264 	struct snd_pcm_runtime *runtime = fe_substream->runtime;
1265 	int stream = fe_substream->stream, ret = 0;
1266 
1267 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
1268 
1269 	ret = dpcm_be_dai_startup(fe, fe_substream->stream);
1270 	if (ret < 0) {
1271 		dev_err(fe->dev,"ASoC: failed to start some BEs %d\n", ret);
1272 		goto be_err;
1273 	}
1274 
1275 	dev_dbg(fe->dev, "ASoC: open FE %s\n", fe->dai_link->name);
1276 
1277 	/* start the DAI frontend */
1278 	ret = soc_pcm_open(fe_substream);
1279 	if (ret < 0) {
1280 		dev_err(fe->dev,"ASoC: failed to start FE %d\n", ret);
1281 		goto unwind;
1282 	}
1283 
1284 	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
1285 
1286 	dpcm_set_fe_runtime(fe_substream);
1287 	snd_pcm_limit_hw_rates(runtime);
1288 
1289 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
1290 	return 0;
1291 
1292 unwind:
1293 	dpcm_be_dai_startup_unwind(fe, fe_substream->stream);
1294 be_err:
1295 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
1296 	return ret;
1297 }
1298 
1299 int dpcm_be_dai_shutdown(struct snd_soc_pcm_runtime *fe, int stream)
1300 {
1301 	struct snd_soc_dpcm *dpcm;
1302 
1303 	/* only shutdown BEs that are either sinks or sources to this FE DAI */
1304 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
1305 
1306 		struct snd_soc_pcm_runtime *be = dpcm->be;
1307 		struct snd_pcm_substream *be_substream =
1308 			snd_soc_dpcm_get_substream(be, stream);
1309 
1310 		/* is this op for this BE ? */
1311 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1312 			continue;
1313 
1314 		if (be->dpcm[stream].users == 0)
1315 			dev_err(be->dev, "ASoC: no users %s at close - state %d\n",
1316 				stream ? "capture" : "playback",
1317 				be->dpcm[stream].state);
1318 
1319 		if (--be->dpcm[stream].users != 0)
1320 			continue;
1321 
1322 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
1323 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN))
1324 			continue;
1325 
1326 		dev_dbg(be->dev, "ASoC: close BE %s\n",
1327 			dpcm->fe->dai_link->name);
1328 
1329 		soc_pcm_close(be_substream);
1330 		be_substream->runtime = NULL;
1331 
1332 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1333 	}
1334 	return 0;
1335 }
1336 
1337 static int dpcm_fe_dai_shutdown(struct snd_pcm_substream *substream)
1338 {
1339 	struct snd_soc_pcm_runtime *fe = substream->private_data;
1340 	int stream = substream->stream;
1341 
1342 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
1343 
1344 	/* shutdown the BEs */
1345 	dpcm_be_dai_shutdown(fe, substream->stream);
1346 
1347 	dev_dbg(fe->dev, "ASoC: close FE %s\n", fe->dai_link->name);
1348 
1349 	/* now shutdown the frontend */
1350 	soc_pcm_close(substream);
1351 
1352 	/* run the stream event for each BE */
1353 	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
1354 
1355 	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1356 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
1357 	return 0;
1358 }
1359 
1360 int dpcm_be_dai_hw_free(struct snd_soc_pcm_runtime *fe, int stream)
1361 {
1362 	struct snd_soc_dpcm *dpcm;
1363 
1364 	/* only hw_params backends that are either sinks or sources
1365 	 * to this frontend DAI */
1366 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
1367 
1368 		struct snd_soc_pcm_runtime *be = dpcm->be;
1369 		struct snd_pcm_substream *be_substream =
1370 			snd_soc_dpcm_get_substream(be, stream);
1371 
1372 		/* is this op for this BE ? */
1373 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1374 			continue;
1375 
1376 		/* only free hw when no longer used - check all FEs */
1377 		if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
1378 				continue;
1379 
1380 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
1381 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
1382 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
1383 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED) &&
1384 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP))
1385 			continue;
1386 
1387 		dev_dbg(be->dev, "ASoC: hw_free BE %s\n",
1388 			dpcm->fe->dai_link->name);
1389 
1390 		soc_pcm_hw_free(be_substream);
1391 
1392 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
1393 	}
1394 
1395 	return 0;
1396 }
1397 
1398 static int dpcm_fe_dai_hw_free(struct snd_pcm_substream *substream)
1399 {
1400 	struct snd_soc_pcm_runtime *fe = substream->private_data;
1401 	int err, stream = substream->stream;
1402 
1403 	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
1404 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
1405 
1406 	dev_dbg(fe->dev, "ASoC: hw_free FE %s\n", fe->dai_link->name);
1407 
1408 	/* call hw_free on the frontend */
1409 	err = soc_pcm_hw_free(substream);
1410 	if (err < 0)
1411 		dev_err(fe->dev,"ASoC: hw_free FE %s failed\n",
1412 			fe->dai_link->name);
1413 
1414 	/* only hw_params backends that are either sinks or sources
1415 	 * to this frontend DAI */
1416 	err = dpcm_be_dai_hw_free(fe, stream);
1417 
1418 	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
1419 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
1420 
1421 	mutex_unlock(&fe->card->mutex);
1422 	return 0;
1423 }
1424 
1425 int dpcm_be_dai_hw_params(struct snd_soc_pcm_runtime *fe, int stream)
1426 {
1427 	struct snd_soc_dpcm *dpcm;
1428 	int ret;
1429 
1430 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
1431 
1432 		struct snd_soc_pcm_runtime *be = dpcm->be;
1433 		struct snd_pcm_substream *be_substream =
1434 			snd_soc_dpcm_get_substream(be, stream);
1435 
1436 		/* is this op for this BE ? */
1437 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1438 			continue;
1439 
1440 		/* only allow hw_params() if no connected FEs are running */
1441 		if (!snd_soc_dpcm_can_be_params(fe, be, stream))
1442 			continue;
1443 
1444 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
1445 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
1446 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE))
1447 			continue;
1448 
1449 		dev_dbg(be->dev, "ASoC: hw_params BE %s\n",
1450 			dpcm->fe->dai_link->name);
1451 
1452 		/* copy params for each dpcm */
1453 		memcpy(&dpcm->hw_params, &fe->dpcm[stream].hw_params,
1454 				sizeof(struct snd_pcm_hw_params));
1455 
1456 		/* perform any hw_params fixups */
1457 		if (be->dai_link->be_hw_params_fixup) {
1458 			ret = be->dai_link->be_hw_params_fixup(be,
1459 					&dpcm->hw_params);
1460 			if (ret < 0) {
1461 				dev_err(be->dev,
1462 					"ASoC: hw_params BE fixup failed %d\n",
1463 					ret);
1464 				goto unwind;
1465 			}
1466 		}
1467 
1468 		ret = soc_pcm_hw_params(be_substream, &dpcm->hw_params);
1469 		if (ret < 0) {
1470 			dev_err(dpcm->be->dev,
1471 				"ASoC: hw_params BE failed %d\n", ret);
1472 			goto unwind;
1473 		}
1474 
1475 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
1476 	}
1477 	return 0;
1478 
1479 unwind:
1480 	/* disable any enabled and non active backends */
1481 	list_for_each_entry_continue_reverse(dpcm, &fe->dpcm[stream].be_clients, list_be) {
1482 		struct snd_soc_pcm_runtime *be = dpcm->be;
1483 		struct snd_pcm_substream *be_substream =
1484 			snd_soc_dpcm_get_substream(be, stream);
1485 
1486 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1487 			continue;
1488 
1489 		/* only allow hw_free() if no connected FEs are running */
1490 		if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
1491 			continue;
1492 
1493 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
1494 		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
1495 		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
1496 		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP))
1497 			continue;
1498 
1499 		soc_pcm_hw_free(be_substream);
1500 	}
1501 
1502 	return ret;
1503 }
1504 
1505 static int dpcm_fe_dai_hw_params(struct snd_pcm_substream *substream,
1506 				 struct snd_pcm_hw_params *params)
1507 {
1508 	struct snd_soc_pcm_runtime *fe = substream->private_data;
1509 	int ret, stream = substream->stream;
1510 
1511 	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
1512 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
1513 
1514 	memcpy(&fe->dpcm[substream->stream].hw_params, params,
1515 			sizeof(struct snd_pcm_hw_params));
1516 	ret = dpcm_be_dai_hw_params(fe, substream->stream);
1517 	if (ret < 0) {
1518 		dev_err(fe->dev,"ASoC: hw_params BE failed %d\n", ret);
1519 		goto out;
1520 	}
1521 
1522 	dev_dbg(fe->dev, "ASoC: hw_params FE %s rate %d chan %x fmt %d\n",
1523 			fe->dai_link->name, params_rate(params),
1524 			params_channels(params), params_format(params));
1525 
1526 	/* call hw_params on the frontend */
1527 	ret = soc_pcm_hw_params(substream, params);
1528 	if (ret < 0) {
1529 		dev_err(fe->dev,"ASoC: hw_params FE failed %d\n", ret);
1530 		dpcm_be_dai_hw_free(fe, stream);
1531 	 } else
1532 		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
1533 
1534 out:
1535 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
1536 	mutex_unlock(&fe->card->mutex);
1537 	return ret;
1538 }
1539 
1540 static int dpcm_do_trigger(struct snd_soc_dpcm *dpcm,
1541 		struct snd_pcm_substream *substream, int cmd)
1542 {
1543 	int ret;
1544 
1545 	dev_dbg(dpcm->be->dev, "ASoC: trigger BE %s cmd %d\n",
1546 			dpcm->fe->dai_link->name, cmd);
1547 
1548 	ret = soc_pcm_trigger(substream, cmd);
1549 	if (ret < 0)
1550 		dev_err(dpcm->be->dev,"ASoC: trigger BE failed %d\n", ret);
1551 
1552 	return ret;
1553 }
1554 
1555 int dpcm_be_dai_trigger(struct snd_soc_pcm_runtime *fe, int stream,
1556 			       int cmd)
1557 {
1558 	struct snd_soc_dpcm *dpcm;
1559 	int ret = 0;
1560 
1561 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
1562 
1563 		struct snd_soc_pcm_runtime *be = dpcm->be;
1564 		struct snd_pcm_substream *be_substream =
1565 			snd_soc_dpcm_get_substream(be, stream);
1566 
1567 		/* is this op for this BE ? */
1568 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1569 			continue;
1570 
1571 		switch (cmd) {
1572 		case SNDRV_PCM_TRIGGER_START:
1573 			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
1574 			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP))
1575 				continue;
1576 
1577 			ret = dpcm_do_trigger(dpcm, be_substream, cmd);
1578 			if (ret)
1579 				return ret;
1580 
1581 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
1582 			break;
1583 		case SNDRV_PCM_TRIGGER_RESUME:
1584 			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
1585 				continue;
1586 
1587 			ret = dpcm_do_trigger(dpcm, be_substream, cmd);
1588 			if (ret)
1589 				return ret;
1590 
1591 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
1592 			break;
1593 		case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1594 			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
1595 				continue;
1596 
1597 			ret = dpcm_do_trigger(dpcm, be_substream, cmd);
1598 			if (ret)
1599 				return ret;
1600 
1601 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
1602 			break;
1603 		case SNDRV_PCM_TRIGGER_STOP:
1604 			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
1605 				continue;
1606 
1607 			if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
1608 				continue;
1609 
1610 			ret = dpcm_do_trigger(dpcm, be_substream, cmd);
1611 			if (ret)
1612 				return ret;
1613 
1614 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
1615 			break;
1616 		case SNDRV_PCM_TRIGGER_SUSPEND:
1617 			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP)
1618 				continue;
1619 
1620 			if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
1621 				continue;
1622 
1623 			ret = dpcm_do_trigger(dpcm, be_substream, cmd);
1624 			if (ret)
1625 				return ret;
1626 
1627 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_SUSPEND;
1628 			break;
1629 		case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1630 			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
1631 				continue;
1632 
1633 			if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
1634 				continue;
1635 
1636 			ret = dpcm_do_trigger(dpcm, be_substream, cmd);
1637 			if (ret)
1638 				return ret;
1639 
1640 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
1641 			break;
1642 		}
1643 	}
1644 
1645 	return ret;
1646 }
1647 EXPORT_SYMBOL_GPL(dpcm_be_dai_trigger);
1648 
1649 static int dpcm_fe_dai_trigger(struct snd_pcm_substream *substream, int cmd)
1650 {
1651 	struct snd_soc_pcm_runtime *fe = substream->private_data;
1652 	int stream = substream->stream, ret;
1653 	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
1654 
1655 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
1656 
1657 	switch (trigger) {
1658 	case SND_SOC_DPCM_TRIGGER_PRE:
1659 		/* call trigger on the frontend before the backend. */
1660 
1661 		dev_dbg(fe->dev, "ASoC: pre trigger FE %s cmd %d\n",
1662 				fe->dai_link->name, cmd);
1663 
1664 		ret = soc_pcm_trigger(substream, cmd);
1665 		if (ret < 0) {
1666 			dev_err(fe->dev,"ASoC: trigger FE failed %d\n", ret);
1667 			goto out;
1668 		}
1669 
1670 		ret = dpcm_be_dai_trigger(fe, substream->stream, cmd);
1671 		break;
1672 	case SND_SOC_DPCM_TRIGGER_POST:
1673 		/* call trigger on the frontend after the backend. */
1674 
1675 		ret = dpcm_be_dai_trigger(fe, substream->stream, cmd);
1676 		if (ret < 0) {
1677 			dev_err(fe->dev,"ASoC: trigger FE failed %d\n", ret);
1678 			goto out;
1679 		}
1680 
1681 		dev_dbg(fe->dev, "ASoC: post trigger FE %s cmd %d\n",
1682 				fe->dai_link->name, cmd);
1683 
1684 		ret = soc_pcm_trigger(substream, cmd);
1685 		break;
1686 	case SND_SOC_DPCM_TRIGGER_BESPOKE:
1687 		/* bespoke trigger() - handles both FE and BEs */
1688 
1689 		dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd %d\n",
1690 				fe->dai_link->name, cmd);
1691 
1692 		ret = soc_pcm_bespoke_trigger(substream, cmd);
1693 		if (ret < 0) {
1694 			dev_err(fe->dev,"ASoC: trigger FE failed %d\n", ret);
1695 			goto out;
1696 		}
1697 		break;
1698 	default:
1699 		dev_err(fe->dev, "ASoC: invalid trigger cmd %d for %s\n", cmd,
1700 				fe->dai_link->name);
1701 		ret = -EINVAL;
1702 		goto out;
1703 	}
1704 
1705 	switch (cmd) {
1706 	case SNDRV_PCM_TRIGGER_START:
1707 	case SNDRV_PCM_TRIGGER_RESUME:
1708 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1709 		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
1710 		break;
1711 	case SNDRV_PCM_TRIGGER_STOP:
1712 	case SNDRV_PCM_TRIGGER_SUSPEND:
1713 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1714 		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
1715 		break;
1716 	}
1717 
1718 out:
1719 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
1720 	return ret;
1721 }
1722 
1723 int dpcm_be_dai_prepare(struct snd_soc_pcm_runtime *fe, int stream)
1724 {
1725 	struct snd_soc_dpcm *dpcm;
1726 	int ret = 0;
1727 
1728 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
1729 
1730 		struct snd_soc_pcm_runtime *be = dpcm->be;
1731 		struct snd_pcm_substream *be_substream =
1732 			snd_soc_dpcm_get_substream(be, stream);
1733 
1734 		/* is this op for this BE ? */
1735 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1736 			continue;
1737 
1738 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
1739 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP))
1740 			continue;
1741 
1742 		dev_dbg(be->dev, "ASoC: prepare BE %s\n",
1743 			dpcm->fe->dai_link->name);
1744 
1745 		ret = soc_pcm_prepare(be_substream);
1746 		if (ret < 0) {
1747 			dev_err(be->dev, "ASoC: backend prepare failed %d\n",
1748 				ret);
1749 			break;
1750 		}
1751 
1752 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
1753 	}
1754 	return ret;
1755 }
1756 
1757 static int dpcm_fe_dai_prepare(struct snd_pcm_substream *substream)
1758 {
1759 	struct snd_soc_pcm_runtime *fe = substream->private_data;
1760 	int stream = substream->stream, ret = 0;
1761 
1762 	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
1763 
1764 	dev_dbg(fe->dev, "ASoC: prepare FE %s\n", fe->dai_link->name);
1765 
1766 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
1767 
1768 	/* there is no point preparing this FE if there are no BEs */
1769 	if (list_empty(&fe->dpcm[stream].be_clients)) {
1770 		dev_err(fe->dev, "ASoC: no backend DAIs enabled for %s\n",
1771 				fe->dai_link->name);
1772 		ret = -EINVAL;
1773 		goto out;
1774 	}
1775 
1776 	ret = dpcm_be_dai_prepare(fe, substream->stream);
1777 	if (ret < 0)
1778 		goto out;
1779 
1780 	/* call prepare on the frontend */
1781 	ret = soc_pcm_prepare(substream);
1782 	if (ret < 0) {
1783 		dev_err(fe->dev,"ASoC: prepare FE %s failed\n",
1784 			fe->dai_link->name);
1785 		goto out;
1786 	}
1787 
1788 	/* run the stream event for each BE */
1789 	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START);
1790 	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
1791 
1792 out:
1793 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
1794 	mutex_unlock(&fe->card->mutex);
1795 
1796 	return ret;
1797 }
1798 
1799 static int soc_pcm_ioctl(struct snd_pcm_substream *substream,
1800 		     unsigned int cmd, void *arg)
1801 {
1802 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
1803 	struct snd_soc_platform *platform = rtd->platform;
1804 
1805 	if (platform->driver->ops && platform->driver->ops->ioctl)
1806 		return platform->driver->ops->ioctl(substream, cmd, arg);
1807 	return snd_pcm_lib_ioctl(substream, cmd, arg);
1808 }
1809 
1810 static int dpcm_run_update_shutdown(struct snd_soc_pcm_runtime *fe, int stream)
1811 {
1812 	struct snd_pcm_substream *substream =
1813 		snd_soc_dpcm_get_substream(fe, stream);
1814 	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
1815 	int err;
1816 
1817 	dev_dbg(fe->dev, "ASoC: runtime %s close on FE %s\n",
1818 			stream ? "capture" : "playback", fe->dai_link->name);
1819 
1820 	if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) {
1821 		/* call bespoke trigger - FE takes care of all BE triggers */
1822 		dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd stop\n",
1823 				fe->dai_link->name);
1824 
1825 		err = soc_pcm_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_STOP);
1826 		if (err < 0)
1827 			dev_err(fe->dev,"ASoC: trigger FE failed %d\n", err);
1828 	} else {
1829 		dev_dbg(fe->dev, "ASoC: trigger FE %s cmd stop\n",
1830 			fe->dai_link->name);
1831 
1832 		err = dpcm_be_dai_trigger(fe, stream, SNDRV_PCM_TRIGGER_STOP);
1833 		if (err < 0)
1834 			dev_err(fe->dev,"ASoC: trigger FE failed %d\n", err);
1835 	}
1836 
1837 	err = dpcm_be_dai_hw_free(fe, stream);
1838 	if (err < 0)
1839 		dev_err(fe->dev,"ASoC: hw_free FE failed %d\n", err);
1840 
1841 	err = dpcm_be_dai_shutdown(fe, stream);
1842 	if (err < 0)
1843 		dev_err(fe->dev,"ASoC: shutdown FE failed %d\n", err);
1844 
1845 	/* run the stream event for each BE */
1846 	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_NOP);
1847 
1848 	return 0;
1849 }
1850 
1851 static int dpcm_run_update_startup(struct snd_soc_pcm_runtime *fe, int stream)
1852 {
1853 	struct snd_pcm_substream *substream =
1854 		snd_soc_dpcm_get_substream(fe, stream);
1855 	struct snd_soc_dpcm *dpcm;
1856 	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
1857 	int ret;
1858 
1859 	dev_dbg(fe->dev, "ASoC: runtime %s open on FE %s\n",
1860 			stream ? "capture" : "playback", fe->dai_link->name);
1861 
1862 	/* Only start the BE if the FE is ready */
1863 	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_FREE ||
1864 		fe->dpcm[stream].state == SND_SOC_DPCM_STATE_CLOSE)
1865 		return -EINVAL;
1866 
1867 	/* startup must always be called for new BEs */
1868 	ret = dpcm_be_dai_startup(fe, stream);
1869 	if (ret < 0)
1870 		goto disconnect;
1871 
1872 	/* keep going if FE state is > open */
1873 	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_OPEN)
1874 		return 0;
1875 
1876 	ret = dpcm_be_dai_hw_params(fe, stream);
1877 	if (ret < 0)
1878 		goto close;
1879 
1880 	/* keep going if FE state is > hw_params */
1881 	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_PARAMS)
1882 		return 0;
1883 
1884 
1885 	ret = dpcm_be_dai_prepare(fe, stream);
1886 	if (ret < 0)
1887 		goto hw_free;
1888 
1889 	/* run the stream event for each BE */
1890 	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_NOP);
1891 
1892 	/* keep going if FE state is > prepare */
1893 	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_PREPARE ||
1894 		fe->dpcm[stream].state == SND_SOC_DPCM_STATE_STOP)
1895 		return 0;
1896 
1897 	if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) {
1898 		/* call trigger on the frontend - FE takes care of all BE triggers */
1899 		dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd start\n",
1900 				fe->dai_link->name);
1901 
1902 		ret = soc_pcm_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_START);
1903 		if (ret < 0) {
1904 			dev_err(fe->dev,"ASoC: bespoke trigger FE failed %d\n", ret);
1905 			goto hw_free;
1906 		}
1907 	} else {
1908 		dev_dbg(fe->dev, "ASoC: trigger FE %s cmd start\n",
1909 			fe->dai_link->name);
1910 
1911 		ret = dpcm_be_dai_trigger(fe, stream,
1912 					SNDRV_PCM_TRIGGER_START);
1913 		if (ret < 0) {
1914 			dev_err(fe->dev,"ASoC: trigger FE failed %d\n", ret);
1915 			goto hw_free;
1916 		}
1917 	}
1918 
1919 	return 0;
1920 
1921 hw_free:
1922 	dpcm_be_dai_hw_free(fe, stream);
1923 close:
1924 	dpcm_be_dai_shutdown(fe, stream);
1925 disconnect:
1926 	/* disconnect any non started BEs */
1927 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
1928 		struct snd_soc_pcm_runtime *be = dpcm->be;
1929 		if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
1930 				dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
1931 	}
1932 
1933 	return ret;
1934 }
1935 
1936 static int dpcm_run_new_update(struct snd_soc_pcm_runtime *fe, int stream)
1937 {
1938 	int ret;
1939 
1940 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_BE;
1941 	ret = dpcm_run_update_startup(fe, stream);
1942 	if (ret < 0)
1943 		dev_err(fe->dev, "ASoC: failed to startup some BEs\n");
1944 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
1945 
1946 	return ret;
1947 }
1948 
1949 static int dpcm_run_old_update(struct snd_soc_pcm_runtime *fe, int stream)
1950 {
1951 	int ret;
1952 
1953 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_BE;
1954 	ret = dpcm_run_update_shutdown(fe, stream);
1955 	if (ret < 0)
1956 		dev_err(fe->dev, "ASoC: failed to shutdown some BEs\n");
1957 	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
1958 
1959 	return ret;
1960 }
1961 
1962 /* Called by DAPM mixer/mux changes to update audio routing between PCMs and
1963  * any DAI links.
1964  */
1965 int soc_dpcm_runtime_update(struct snd_soc_card *card)
1966 {
1967 	int i, old, new, paths;
1968 
1969 	mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
1970 	for (i = 0; i < card->num_rtd; i++) {
1971 		struct snd_soc_dapm_widget_list *list;
1972 		struct snd_soc_pcm_runtime *fe = &card->rtd[i];
1973 
1974 		/* make sure link is FE */
1975 		if (!fe->dai_link->dynamic)
1976 			continue;
1977 
1978 		/* only check active links */
1979 		if (!fe->cpu_dai->active)
1980 			continue;
1981 
1982 		/* DAPM sync will call this to update DSP paths */
1983 		dev_dbg(fe->dev, "ASoC: DPCM runtime update for FE %s\n",
1984 			fe->dai_link->name);
1985 
1986 		/* skip if FE doesn't have playback capability */
1987 		if (!fe->cpu_dai->driver->playback.channels_min)
1988 			goto capture;
1989 
1990 		paths = dpcm_path_get(fe, SNDRV_PCM_STREAM_PLAYBACK, &list);
1991 		if (paths < 0) {
1992 			dpcm_path_put(&list);
1993 			dev_warn(fe->dev, "ASoC: %s no valid %s path\n",
1994 					fe->dai_link->name,  "playback");
1995 			mutex_unlock(&card->mutex);
1996 			return paths;
1997 		}
1998 
1999 		/* update any new playback paths */
2000 		new = dpcm_process_paths(fe, SNDRV_PCM_STREAM_PLAYBACK, &list, 1);
2001 		if (new) {
2002 			dpcm_run_new_update(fe, SNDRV_PCM_STREAM_PLAYBACK);
2003 			dpcm_clear_pending_state(fe, SNDRV_PCM_STREAM_PLAYBACK);
2004 			dpcm_be_disconnect(fe, SNDRV_PCM_STREAM_PLAYBACK);
2005 		}
2006 
2007 		/* update any old playback paths */
2008 		old = dpcm_process_paths(fe, SNDRV_PCM_STREAM_PLAYBACK, &list, 0);
2009 		if (old) {
2010 			dpcm_run_old_update(fe, SNDRV_PCM_STREAM_PLAYBACK);
2011 			dpcm_clear_pending_state(fe, SNDRV_PCM_STREAM_PLAYBACK);
2012 			dpcm_be_disconnect(fe, SNDRV_PCM_STREAM_PLAYBACK);
2013 		}
2014 
2015 capture:
2016 		/* skip if FE doesn't have capture capability */
2017 		if (!fe->cpu_dai->driver->capture.channels_min)
2018 			continue;
2019 
2020 		paths = dpcm_path_get(fe, SNDRV_PCM_STREAM_CAPTURE, &list);
2021 		if (paths < 0) {
2022 			dpcm_path_put(&list);
2023 			dev_warn(fe->dev, "ASoC: %s no valid %s path\n",
2024 					fe->dai_link->name,  "capture");
2025 			mutex_unlock(&card->mutex);
2026 			return paths;
2027 		}
2028 
2029 		/* update any new capture paths */
2030 		new = dpcm_process_paths(fe, SNDRV_PCM_STREAM_CAPTURE, &list, 1);
2031 		if (new) {
2032 			dpcm_run_new_update(fe, SNDRV_PCM_STREAM_CAPTURE);
2033 			dpcm_clear_pending_state(fe, SNDRV_PCM_STREAM_CAPTURE);
2034 			dpcm_be_disconnect(fe, SNDRV_PCM_STREAM_CAPTURE);
2035 		}
2036 
2037 		/* update any old capture paths */
2038 		old = dpcm_process_paths(fe, SNDRV_PCM_STREAM_CAPTURE, &list, 0);
2039 		if (old) {
2040 			dpcm_run_old_update(fe, SNDRV_PCM_STREAM_CAPTURE);
2041 			dpcm_clear_pending_state(fe, SNDRV_PCM_STREAM_CAPTURE);
2042 			dpcm_be_disconnect(fe, SNDRV_PCM_STREAM_CAPTURE);
2043 		}
2044 
2045 		dpcm_path_put(&list);
2046 	}
2047 
2048 	mutex_unlock(&card->mutex);
2049 	return 0;
2050 }
2051 int soc_dpcm_be_digital_mute(struct snd_soc_pcm_runtime *fe, int mute)
2052 {
2053 	struct snd_soc_dpcm *dpcm;
2054 	struct list_head *clients =
2055 		&fe->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients;
2056 
2057 	list_for_each_entry(dpcm, clients, list_be) {
2058 
2059 		struct snd_soc_pcm_runtime *be = dpcm->be;
2060 		struct snd_soc_dai *dai = be->codec_dai;
2061 		struct snd_soc_dai_driver *drv = dai->driver;
2062 
2063 		if (be->dai_link->ignore_suspend)
2064 			continue;
2065 
2066 		dev_dbg(be->dev, "ASoC: BE digital mute %s\n", be->dai_link->name);
2067 
2068 		if (drv->ops && drv->ops->digital_mute && dai->playback_active)
2069 			drv->ops->digital_mute(dai, mute);
2070 	}
2071 
2072 	return 0;
2073 }
2074 
2075 static int dpcm_fe_dai_open(struct snd_pcm_substream *fe_substream)
2076 {
2077 	struct snd_soc_pcm_runtime *fe = fe_substream->private_data;
2078 	struct snd_soc_dpcm *dpcm;
2079 	struct snd_soc_dapm_widget_list *list;
2080 	int ret;
2081 	int stream = fe_substream->stream;
2082 
2083 	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
2084 	fe->dpcm[stream].runtime = fe_substream->runtime;
2085 
2086 	if (dpcm_path_get(fe, stream, &list) <= 0) {
2087 		dpcm_path_put(&list);
2088 		dev_dbg(fe->dev, "ASoC: %s no valid %s route\n",
2089 			fe->dai_link->name, stream ? "capture" : "playback");
2090 	}
2091 
2092 	/* calculate valid and active FE <-> BE dpcms */
2093 	dpcm_process_paths(fe, stream, &list, 1);
2094 
2095 	ret = dpcm_fe_dai_startup(fe_substream);
2096 	if (ret < 0) {
2097 		/* clean up all links */
2098 		list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
2099 			dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
2100 
2101 		dpcm_be_disconnect(fe, stream);
2102 		fe->dpcm[stream].runtime = NULL;
2103 	}
2104 
2105 	dpcm_clear_pending_state(fe, stream);
2106 	dpcm_path_put(&list);
2107 	mutex_unlock(&fe->card->mutex);
2108 	return ret;
2109 }
2110 
2111 static int dpcm_fe_dai_close(struct snd_pcm_substream *fe_substream)
2112 {
2113 	struct snd_soc_pcm_runtime *fe = fe_substream->private_data;
2114 	struct snd_soc_dpcm *dpcm;
2115 	int stream = fe_substream->stream, ret;
2116 
2117 	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
2118 	ret = dpcm_fe_dai_shutdown(fe_substream);
2119 
2120 	/* mark FE's links ready to prune */
2121 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)
2122 		dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
2123 
2124 	dpcm_be_disconnect(fe, stream);
2125 
2126 	fe->dpcm[stream].runtime = NULL;
2127 	mutex_unlock(&fe->card->mutex);
2128 	return ret;
2129 }
2130 
2131 /* create a new pcm */
2132 int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
2133 {
2134 	struct snd_soc_platform *platform = rtd->platform;
2135 	struct snd_soc_dai *codec_dai = rtd->codec_dai;
2136 	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2137 	struct snd_pcm *pcm;
2138 	char new_name[64];
2139 	int ret = 0, playback = 0, capture = 0;
2140 
2141 	if (rtd->dai_link->dynamic || rtd->dai_link->no_pcm) {
2142 		playback = rtd->dai_link->dpcm_playback;
2143 		capture = rtd->dai_link->dpcm_capture;
2144 	} else {
2145 		if (codec_dai->driver->playback.channels_min &&
2146 		    cpu_dai->driver->playback.channels_min)
2147 			playback = 1;
2148 		if (codec_dai->driver->capture.channels_min &&
2149 		    cpu_dai->driver->capture.channels_min)
2150 			capture = 1;
2151 	}
2152 
2153 	if (rtd->dai_link->playback_only) {
2154 		playback = 1;
2155 		capture = 0;
2156 	}
2157 
2158 	if (rtd->dai_link->capture_only) {
2159 		playback = 0;
2160 		capture = 1;
2161 	}
2162 
2163 	/* create the PCM */
2164 	if (rtd->dai_link->no_pcm) {
2165 		snprintf(new_name, sizeof(new_name), "(%s)",
2166 			rtd->dai_link->stream_name);
2167 
2168 		ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
2169 				playback, capture, &pcm);
2170 	} else {
2171 		if (rtd->dai_link->dynamic)
2172 			snprintf(new_name, sizeof(new_name), "%s (*)",
2173 				rtd->dai_link->stream_name);
2174 		else
2175 			snprintf(new_name, sizeof(new_name), "%s %s-%d",
2176 				rtd->dai_link->stream_name, codec_dai->name, num);
2177 
2178 		ret = snd_pcm_new(rtd->card->snd_card, new_name, num, playback,
2179 			capture, &pcm);
2180 	}
2181 	if (ret < 0) {
2182 		dev_err(rtd->card->dev, "ASoC: can't create pcm for %s\n",
2183 			rtd->dai_link->name);
2184 		return ret;
2185 	}
2186 	dev_dbg(rtd->card->dev, "ASoC: registered pcm #%d %s\n",num, new_name);
2187 
2188 	/* DAPM dai link stream work */
2189 	INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
2190 
2191 	rtd->pcm = pcm;
2192 	pcm->private_data = rtd;
2193 
2194 	if (rtd->dai_link->no_pcm) {
2195 		if (playback)
2196 			pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
2197 		if (capture)
2198 			pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
2199 		goto out;
2200 	}
2201 
2202 	/* ASoC PCM operations */
2203 	if (rtd->dai_link->dynamic) {
2204 		rtd->ops.open		= dpcm_fe_dai_open;
2205 		rtd->ops.hw_params	= dpcm_fe_dai_hw_params;
2206 		rtd->ops.prepare	= dpcm_fe_dai_prepare;
2207 		rtd->ops.trigger	= dpcm_fe_dai_trigger;
2208 		rtd->ops.hw_free	= dpcm_fe_dai_hw_free;
2209 		rtd->ops.close		= dpcm_fe_dai_close;
2210 		rtd->ops.pointer	= soc_pcm_pointer;
2211 		rtd->ops.ioctl		= soc_pcm_ioctl;
2212 	} else {
2213 		rtd->ops.open		= soc_pcm_open;
2214 		rtd->ops.hw_params	= soc_pcm_hw_params;
2215 		rtd->ops.prepare	= soc_pcm_prepare;
2216 		rtd->ops.trigger	= soc_pcm_trigger;
2217 		rtd->ops.hw_free	= soc_pcm_hw_free;
2218 		rtd->ops.close		= soc_pcm_close;
2219 		rtd->ops.pointer	= soc_pcm_pointer;
2220 		rtd->ops.ioctl		= soc_pcm_ioctl;
2221 	}
2222 
2223 	if (platform->driver->ops) {
2224 		rtd->ops.ack		= platform->driver->ops->ack;
2225 		rtd->ops.copy		= platform->driver->ops->copy;
2226 		rtd->ops.silence	= platform->driver->ops->silence;
2227 		rtd->ops.page		= platform->driver->ops->page;
2228 		rtd->ops.mmap		= platform->driver->ops->mmap;
2229 	}
2230 
2231 	if (playback)
2232 		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &rtd->ops);
2233 
2234 	if (capture)
2235 		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &rtd->ops);
2236 
2237 	if (platform->driver->pcm_new) {
2238 		ret = platform->driver->pcm_new(rtd);
2239 		if (ret < 0) {
2240 			dev_err(platform->dev,
2241 				"ASoC: pcm constructor failed: %d\n",
2242 				ret);
2243 			return ret;
2244 		}
2245 	}
2246 
2247 	pcm->private_free = platform->driver->pcm_free;
2248 out:
2249 	dev_info(rtd->card->dev, "%s <-> %s mapping ok\n", codec_dai->name,
2250 		cpu_dai->name);
2251 	return ret;
2252 }
2253 
2254 /* is the current PCM operation for this FE ? */
2255 int snd_soc_dpcm_fe_can_update(struct snd_soc_pcm_runtime *fe, int stream)
2256 {
2257 	if (fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE)
2258 		return 1;
2259 	return 0;
2260 }
2261 EXPORT_SYMBOL_GPL(snd_soc_dpcm_fe_can_update);
2262 
2263 /* is the current PCM operation for this BE ? */
2264 int snd_soc_dpcm_be_can_update(struct snd_soc_pcm_runtime *fe,
2265 		struct snd_soc_pcm_runtime *be, int stream)
2266 {
2267 	if ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE) ||
2268 	   ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_BE) &&
2269 		  be->dpcm[stream].runtime_update))
2270 		return 1;
2271 	return 0;
2272 }
2273 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_can_update);
2274 
2275 /* get the substream for this BE */
2276 struct snd_pcm_substream *
2277 	snd_soc_dpcm_get_substream(struct snd_soc_pcm_runtime *be, int stream)
2278 {
2279 	return be->pcm->streams[stream].substream;
2280 }
2281 EXPORT_SYMBOL_GPL(snd_soc_dpcm_get_substream);
2282 
2283 /* get the BE runtime state */
2284 enum snd_soc_dpcm_state
2285 	snd_soc_dpcm_be_get_state(struct snd_soc_pcm_runtime *be, int stream)
2286 {
2287 	return be->dpcm[stream].state;
2288 }
2289 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_get_state);
2290 
2291 /* set the BE runtime state */
2292 void snd_soc_dpcm_be_set_state(struct snd_soc_pcm_runtime *be,
2293 		int stream, enum snd_soc_dpcm_state state)
2294 {
2295 	be->dpcm[stream].state = state;
2296 }
2297 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_set_state);
2298 
2299 /*
2300  * We can only hw_free, stop, pause or suspend a BE DAI if any of it's FE
2301  * are not running, paused or suspended for the specified stream direction.
2302  */
2303 int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime *fe,
2304 		struct snd_soc_pcm_runtime *be, int stream)
2305 {
2306 	struct snd_soc_dpcm *dpcm;
2307 	int state;
2308 
2309 	list_for_each_entry(dpcm, &be->dpcm[stream].fe_clients, list_fe) {
2310 
2311 		if (dpcm->fe == fe)
2312 			continue;
2313 
2314 		state = dpcm->fe->dpcm[stream].state;
2315 		if (state == SND_SOC_DPCM_STATE_START ||
2316 			state == SND_SOC_DPCM_STATE_PAUSED ||
2317 			state == SND_SOC_DPCM_STATE_SUSPEND)
2318 			return 0;
2319 	}
2320 
2321 	/* it's safe to free/stop this BE DAI */
2322 	return 1;
2323 }
2324 EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop);
2325 
2326 /*
2327  * We can only change hw params a BE DAI if any of it's FE are not prepared,
2328  * running, paused or suspended for the specified stream direction.
2329  */
2330 int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime *fe,
2331 		struct snd_soc_pcm_runtime *be, int stream)
2332 {
2333 	struct snd_soc_dpcm *dpcm;
2334 	int state;
2335 
2336 	list_for_each_entry(dpcm, &be->dpcm[stream].fe_clients, list_fe) {
2337 
2338 		if (dpcm->fe == fe)
2339 			continue;
2340 
2341 		state = dpcm->fe->dpcm[stream].state;
2342 		if (state == SND_SOC_DPCM_STATE_START ||
2343 			state == SND_SOC_DPCM_STATE_PAUSED ||
2344 			state == SND_SOC_DPCM_STATE_SUSPEND ||
2345 			state == SND_SOC_DPCM_STATE_PREPARE)
2346 			return 0;
2347 	}
2348 
2349 	/* it's safe to change hw_params */
2350 	return 1;
2351 }
2352 EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params);
2353 
2354 int snd_soc_platform_trigger(struct snd_pcm_substream *substream,
2355 		int cmd, struct snd_soc_platform *platform)
2356 {
2357 	if (platform->driver->ops && platform->driver->ops->trigger)
2358 		return platform->driver->ops->trigger(substream, cmd);
2359 	return 0;
2360 }
2361 EXPORT_SYMBOL_GPL(snd_soc_platform_trigger);
2362 
2363 #ifdef CONFIG_DEBUG_FS
2364 static char *dpcm_state_string(enum snd_soc_dpcm_state state)
2365 {
2366 	switch (state) {
2367 	case SND_SOC_DPCM_STATE_NEW:
2368 		return "new";
2369 	case SND_SOC_DPCM_STATE_OPEN:
2370 		return "open";
2371 	case SND_SOC_DPCM_STATE_HW_PARAMS:
2372 		return "hw_params";
2373 	case SND_SOC_DPCM_STATE_PREPARE:
2374 		return "prepare";
2375 	case SND_SOC_DPCM_STATE_START:
2376 		return "start";
2377 	case SND_SOC_DPCM_STATE_STOP:
2378 		return "stop";
2379 	case SND_SOC_DPCM_STATE_SUSPEND:
2380 		return "suspend";
2381 	case SND_SOC_DPCM_STATE_PAUSED:
2382 		return "paused";
2383 	case SND_SOC_DPCM_STATE_HW_FREE:
2384 		return "hw_free";
2385 	case SND_SOC_DPCM_STATE_CLOSE:
2386 		return "close";
2387 	}
2388 
2389 	return "unknown";
2390 }
2391 
2392 static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe,
2393 				int stream, char *buf, size_t size)
2394 {
2395 	struct snd_pcm_hw_params *params = &fe->dpcm[stream].hw_params;
2396 	struct snd_soc_dpcm *dpcm;
2397 	ssize_t offset = 0;
2398 
2399 	/* FE state */
2400 	offset += snprintf(buf + offset, size - offset,
2401 			"[%s - %s]\n", fe->dai_link->name,
2402 			stream ? "Capture" : "Playback");
2403 
2404 	offset += snprintf(buf + offset, size - offset, "State: %s\n",
2405 	                dpcm_state_string(fe->dpcm[stream].state));
2406 
2407 	if ((fe->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
2408 	    (fe->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
2409 		offset += snprintf(buf + offset, size - offset,
2410 				"Hardware Params: "
2411 				"Format = %s, Channels = %d, Rate = %d\n",
2412 				snd_pcm_format_name(params_format(params)),
2413 				params_channels(params),
2414 				params_rate(params));
2415 
2416 	/* BEs state */
2417 	offset += snprintf(buf + offset, size - offset, "Backends:\n");
2418 
2419 	if (list_empty(&fe->dpcm[stream].be_clients)) {
2420 		offset += snprintf(buf + offset, size - offset,
2421 				" No active DSP links\n");
2422 		goto out;
2423 	}
2424 
2425 	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
2426 		struct snd_soc_pcm_runtime *be = dpcm->be;
2427 		params = &dpcm->hw_params;
2428 
2429 		offset += snprintf(buf + offset, size - offset,
2430 				"- %s\n", be->dai_link->name);
2431 
2432 		offset += snprintf(buf + offset, size - offset,
2433 				"   State: %s\n",
2434 				dpcm_state_string(be->dpcm[stream].state));
2435 
2436 		if ((be->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
2437 		    (be->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
2438 			offset += snprintf(buf + offset, size - offset,
2439 				"   Hardware Params: "
2440 				"Format = %s, Channels = %d, Rate = %d\n",
2441 				snd_pcm_format_name(params_format(params)),
2442 				params_channels(params),
2443 				params_rate(params));
2444 	}
2445 
2446 out:
2447 	return offset;
2448 }
2449 
2450 static ssize_t dpcm_state_read_file(struct file *file, char __user *user_buf,
2451 				size_t count, loff_t *ppos)
2452 {
2453 	struct snd_soc_pcm_runtime *fe = file->private_data;
2454 	ssize_t out_count = PAGE_SIZE, offset = 0, ret = 0;
2455 	char *buf;
2456 
2457 	buf = kmalloc(out_count, GFP_KERNEL);
2458 	if (!buf)
2459 		return -ENOMEM;
2460 
2461 	if (fe->cpu_dai->driver->playback.channels_min)
2462 		offset += dpcm_show_state(fe, SNDRV_PCM_STREAM_PLAYBACK,
2463 					buf + offset, out_count - offset);
2464 
2465 	if (fe->cpu_dai->driver->capture.channels_min)
2466 		offset += dpcm_show_state(fe, SNDRV_PCM_STREAM_CAPTURE,
2467 					buf + offset, out_count - offset);
2468 
2469 	ret = simple_read_from_buffer(user_buf, count, ppos, buf, offset);
2470 
2471 	kfree(buf);
2472 	return ret;
2473 }
2474 
2475 static const struct file_operations dpcm_state_fops = {
2476 	.open = simple_open,
2477 	.read = dpcm_state_read_file,
2478 	.llseek = default_llseek,
2479 };
2480 
2481 int soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd)
2482 {
2483 	if (!rtd->dai_link)
2484 		return 0;
2485 
2486 	rtd->debugfs_dpcm_root = debugfs_create_dir(rtd->dai_link->name,
2487 			rtd->card->debugfs_card_root);
2488 	if (!rtd->debugfs_dpcm_root) {
2489 		dev_dbg(rtd->dev,
2490 			 "ASoC: Failed to create dpcm debugfs directory %s\n",
2491 			 rtd->dai_link->name);
2492 		return -EINVAL;
2493 	}
2494 
2495 	rtd->debugfs_dpcm_state = debugfs_create_file("state", 0444,
2496 						rtd->debugfs_dpcm_root,
2497 						rtd, &dpcm_state_fops);
2498 
2499 	return 0;
2500 }
2501 #endif
2502