2 * soc-pcm.c -- ALSA SoC PCM
4 * Copyright 2005 Wolfson Microelectronics PLC.
5 * Copyright 2005 Openedhand Ltd.
6 * Copyright (C) 2010 Slimlogic Ltd.
7 * Copyright (C) 2010 Texas Instruments Inc.
9 * Authors: Liam Girdwood <lrg@ti.com>
10 * Mark Brown <broonie@opensource.wolfsonmicro.com>
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.
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/delay.h>
22 #include <linux/pm_runtime.h>
23 #include <linux/slab.h>
24 #include <linux/workqueue.h>
25 #include <linux/export.h>
26 #include <linux/debugfs.h>
27 #include <sound/core.h>
28 #include <sound/pcm.h>
29 #include <sound/pcm_params.h>
30 #include <sound/soc.h>
31 #include <sound/soc-dpcm.h>
32 #include <sound/initval.h>
34 #define DPCM_MAX_BE_USERS 8
36 /* DPCM stream event, send event to FE and all active BEs. */
37 static int dpcm_dapm_stream_event(struct snd_soc_pcm_runtime
*fe
, int dir
,
40 struct snd_soc_dpcm
*dpcm
;
42 list_for_each_entry(dpcm
, &fe
->dpcm
[dir
].be_clients
, list_be
) {
44 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
46 dev_dbg(be
->dev
, "ASoC: BE %s event %d dir %d\n",
47 be
->dai_link
->name
, event
, dir
);
49 snd_soc_dapm_stream_event(be
, dir
, event
);
52 snd_soc_dapm_stream_event(fe
, dir
, event
);
57 static int soc_pcm_apply_symmetry(struct snd_pcm_substream
*substream
,
58 struct snd_soc_dai
*soc_dai
)
60 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
63 if (!soc_dai
->driver
->symmetric_rates
&&
64 !rtd
->dai_link
->symmetric_rates
)
67 /* This can happen if multiple streams are starting simultaneously -
68 * the second can need to get its constraints before the first has
69 * picked a rate. Complain and allow the application to carry on.
72 dev_warn(soc_dai
->dev
,
73 "ASoC: Not enforcing symmetric_rates due to race\n");
77 dev_dbg(soc_dai
->dev
, "ASoC: Symmetry forces %dHz rate\n", soc_dai
->rate
);
79 ret
= snd_pcm_hw_constraint_minmax(substream
->runtime
,
80 SNDRV_PCM_HW_PARAM_RATE
,
81 soc_dai
->rate
, soc_dai
->rate
);
84 "ASoC: Unable to apply rate symmetry constraint: %d\n",
93 * List of sample sizes that might go over the bus for parameter
94 * application. There ought to be a wildcard sample size for things
95 * like the DAC/ADC resolution to use but there isn't right now.
97 static int sample_sizes
[] = {
101 static void soc_pcm_apply_msb(struct snd_pcm_substream
*substream
,
102 struct snd_soc_dai
*dai
)
106 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
107 bits
= dai
->driver
->playback
.sig_bits
;
109 bits
= dai
->driver
->capture
.sig_bits
;
114 for (i
= 0; i
< ARRAY_SIZE(sample_sizes
); i
++) {
115 if (bits
>= sample_sizes
[i
])
118 ret
= snd_pcm_hw_constraint_msbits(substream
->runtime
, 0,
119 sample_sizes
[i
], bits
);
122 "ASoC: Failed to set MSB %d/%d: %d\n",
123 bits
, sample_sizes
[i
], ret
);
128 * Called by ALSA when a PCM substream is opened, the runtime->hw record is
129 * then initialized and any private data can be allocated. This also calls
130 * startup for the cpu DAI, platform, machine and codec DAI.
132 static int soc_pcm_open(struct snd_pcm_substream
*substream
)
134 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
135 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
136 struct snd_soc_platform
*platform
= rtd
->platform
;
137 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
138 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
139 struct snd_soc_dai_driver
*cpu_dai_drv
= cpu_dai
->driver
;
140 struct snd_soc_dai_driver
*codec_dai_drv
= codec_dai
->driver
;
143 pm_runtime_get_sync(cpu_dai
->dev
);
144 pm_runtime_get_sync(codec_dai
->dev
);
145 pm_runtime_get_sync(platform
->dev
);
147 mutex_lock_nested(&rtd
->pcm_mutex
, rtd
->pcm_subclass
);
149 /* startup the audio subsystem */
150 if (cpu_dai
->driver
->ops
->startup
) {
151 ret
= cpu_dai
->driver
->ops
->startup(substream
, cpu_dai
);
153 dev_err(cpu_dai
->dev
, "ASoC: can't open interface"
154 " %s: %d\n", cpu_dai
->name
, ret
);
159 if (platform
->driver
->ops
&& platform
->driver
->ops
->open
) {
160 ret
= platform
->driver
->ops
->open(substream
);
162 dev_err(platform
->dev
, "ASoC: can't open platform"
163 " %s: %d\n", platform
->name
, ret
);
168 if (codec_dai
->driver
->ops
->startup
) {
169 ret
= codec_dai
->driver
->ops
->startup(substream
, codec_dai
);
171 dev_err(codec_dai
->dev
, "ASoC: can't open codec"
172 " %s: %d\n", codec_dai
->name
, ret
);
177 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->startup
) {
178 ret
= rtd
->dai_link
->ops
->startup(substream
);
180 pr_err("ASoC: %s startup failed: %d\n",
181 rtd
->dai_link
->name
, ret
);
186 /* Dynamic PCM DAI links compat checks use dynamic capabilities */
187 if (rtd
->dai_link
->dynamic
|| rtd
->dai_link
->no_pcm
)
190 /* Check that the codec and cpu DAIs are compatible */
191 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
192 runtime
->hw
.rate_min
=
193 max(codec_dai_drv
->playback
.rate_min
,
194 cpu_dai_drv
->playback
.rate_min
);
195 runtime
->hw
.rate_max
=
196 min(codec_dai_drv
->playback
.rate_max
,
197 cpu_dai_drv
->playback
.rate_max
);
198 runtime
->hw
.channels_min
=
199 max(codec_dai_drv
->playback
.channels_min
,
200 cpu_dai_drv
->playback
.channels_min
);
201 runtime
->hw
.channels_max
=
202 min(codec_dai_drv
->playback
.channels_max
,
203 cpu_dai_drv
->playback
.channels_max
);
204 runtime
->hw
.formats
=
205 codec_dai_drv
->playback
.formats
& cpu_dai_drv
->playback
.formats
;
207 codec_dai_drv
->playback
.rates
& cpu_dai_drv
->playback
.rates
;
208 if (codec_dai_drv
->playback
.rates
209 & (SNDRV_PCM_RATE_KNOT
| SNDRV_PCM_RATE_CONTINUOUS
))
210 runtime
->hw
.rates
|= cpu_dai_drv
->playback
.rates
;
211 if (cpu_dai_drv
->playback
.rates
212 & (SNDRV_PCM_RATE_KNOT
| SNDRV_PCM_RATE_CONTINUOUS
))
213 runtime
->hw
.rates
|= codec_dai_drv
->playback
.rates
;
215 runtime
->hw
.rate_min
=
216 max(codec_dai_drv
->capture
.rate_min
,
217 cpu_dai_drv
->capture
.rate_min
);
218 runtime
->hw
.rate_max
=
219 min(codec_dai_drv
->capture
.rate_max
,
220 cpu_dai_drv
->capture
.rate_max
);
221 runtime
->hw
.channels_min
=
222 max(codec_dai_drv
->capture
.channels_min
,
223 cpu_dai_drv
->capture
.channels_min
);
224 runtime
->hw
.channels_max
=
225 min(codec_dai_drv
->capture
.channels_max
,
226 cpu_dai_drv
->capture
.channels_max
);
227 runtime
->hw
.formats
=
228 codec_dai_drv
->capture
.formats
& cpu_dai_drv
->capture
.formats
;
230 codec_dai_drv
->capture
.rates
& cpu_dai_drv
->capture
.rates
;
231 if (codec_dai_drv
->capture
.rates
232 & (SNDRV_PCM_RATE_KNOT
| SNDRV_PCM_RATE_CONTINUOUS
))
233 runtime
->hw
.rates
|= cpu_dai_drv
->capture
.rates
;
234 if (cpu_dai_drv
->capture
.rates
235 & (SNDRV_PCM_RATE_KNOT
| SNDRV_PCM_RATE_CONTINUOUS
))
236 runtime
->hw
.rates
|= codec_dai_drv
->capture
.rates
;
240 snd_pcm_limit_hw_rates(runtime
);
241 if (!runtime
->hw
.rates
) {
242 printk(KERN_ERR
"ASoC: %s <-> %s No matching rates\n",
243 codec_dai
->name
, cpu_dai
->name
);
246 if (!runtime
->hw
.formats
) {
247 printk(KERN_ERR
"ASoC: %s <-> %s No matching formats\n",
248 codec_dai
->name
, cpu_dai
->name
);
251 if (!runtime
->hw
.channels_min
|| !runtime
->hw
.channels_max
||
252 runtime
->hw
.channels_min
> runtime
->hw
.channels_max
) {
253 printk(KERN_ERR
"ASoC: %s <-> %s No matching channels\n",
254 codec_dai
->name
, cpu_dai
->name
);
258 soc_pcm_apply_msb(substream
, codec_dai
);
259 soc_pcm_apply_msb(substream
, cpu_dai
);
261 /* Symmetry only applies if we've already got an active stream. */
262 if (cpu_dai
->active
) {
263 ret
= soc_pcm_apply_symmetry(substream
, cpu_dai
);
268 if (codec_dai
->active
) {
269 ret
= soc_pcm_apply_symmetry(substream
, codec_dai
);
274 pr_debug("ASoC: %s <-> %s info:\n",
275 codec_dai
->name
, cpu_dai
->name
);
276 pr_debug("ASoC: rate mask 0x%x\n", runtime
->hw
.rates
);
277 pr_debug("ASoC: min ch %d max ch %d\n", runtime
->hw
.channels_min
,
278 runtime
->hw
.channels_max
);
279 pr_debug("ASoC: min rate %d max rate %d\n", runtime
->hw
.rate_min
,
280 runtime
->hw
.rate_max
);
283 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
284 cpu_dai
->playback_active
++;
285 codec_dai
->playback_active
++;
287 cpu_dai
->capture_active
++;
288 codec_dai
->capture_active
++;
292 rtd
->codec
->active
++;
293 mutex_unlock(&rtd
->pcm_mutex
);
297 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->shutdown
)
298 rtd
->dai_link
->ops
->shutdown(substream
);
301 if (codec_dai
->driver
->ops
->shutdown
)
302 codec_dai
->driver
->ops
->shutdown(substream
, codec_dai
);
305 if (platform
->driver
->ops
&& platform
->driver
->ops
->close
)
306 platform
->driver
->ops
->close(substream
);
309 if (cpu_dai
->driver
->ops
->shutdown
)
310 cpu_dai
->driver
->ops
->shutdown(substream
, cpu_dai
);
312 mutex_unlock(&rtd
->pcm_mutex
);
314 pm_runtime_put(platform
->dev
);
315 pm_runtime_put(codec_dai
->dev
);
316 pm_runtime_put(cpu_dai
->dev
);
322 * Power down the audio subsystem pmdown_time msecs after close is called.
323 * This is to ensure there are no pops or clicks in between any music tracks
324 * due to DAPM power cycling.
326 static void close_delayed_work(struct work_struct
*work
)
328 struct snd_soc_pcm_runtime
*rtd
=
329 container_of(work
, struct snd_soc_pcm_runtime
, delayed_work
.work
);
330 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
332 mutex_lock_nested(&rtd
->pcm_mutex
, rtd
->pcm_subclass
);
334 dev_dbg(rtd
->dev
, "ASoC: pop wq checking: %s status: %s waiting: %s\n",
335 codec_dai
->driver
->playback
.stream_name
,
336 codec_dai
->playback_active
? "active" : "inactive",
337 rtd
->pop_wait
? "yes" : "no");
339 /* are we waiting on this codec DAI stream */
340 if (rtd
->pop_wait
== 1) {
342 snd_soc_dapm_stream_event(rtd
, SNDRV_PCM_STREAM_PLAYBACK
,
343 SND_SOC_DAPM_STREAM_STOP
);
346 mutex_unlock(&rtd
->pcm_mutex
);
350 * Called by ALSA when a PCM substream is closed. Private data can be
351 * freed here. The cpu DAI, codec DAI, machine and platform are also
354 static int soc_pcm_close(struct snd_pcm_substream
*substream
)
356 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
357 struct snd_soc_platform
*platform
= rtd
->platform
;
358 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
359 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
360 struct snd_soc_codec
*codec
= rtd
->codec
;
362 mutex_lock_nested(&rtd
->pcm_mutex
, rtd
->pcm_subclass
);
364 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
365 cpu_dai
->playback_active
--;
366 codec_dai
->playback_active
--;
368 cpu_dai
->capture_active
--;
369 codec_dai
->capture_active
--;
376 /* clear the corresponding DAIs rate when inactive */
377 if (!cpu_dai
->active
)
380 if (!codec_dai
->active
)
383 /* Muting the DAC suppresses artifacts caused during digital
384 * shutdown, for example from stopping clocks.
386 snd_soc_dai_digital_mute(codec_dai
, 1, substream
->stream
);
388 if (cpu_dai
->driver
->ops
->shutdown
)
389 cpu_dai
->driver
->ops
->shutdown(substream
, cpu_dai
);
391 if (codec_dai
->driver
->ops
->shutdown
)
392 codec_dai
->driver
->ops
->shutdown(substream
, codec_dai
);
394 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->shutdown
)
395 rtd
->dai_link
->ops
->shutdown(substream
);
397 if (platform
->driver
->ops
&& platform
->driver
->ops
->close
)
398 platform
->driver
->ops
->close(substream
);
399 cpu_dai
->runtime
= NULL
;
401 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
402 if (!rtd
->pmdown_time
|| codec
->ignore_pmdown_time
||
403 rtd
->dai_link
->ignore_pmdown_time
) {
404 /* powered down playback stream now */
405 snd_soc_dapm_stream_event(rtd
,
406 SNDRV_PCM_STREAM_PLAYBACK
,
407 SND_SOC_DAPM_STREAM_STOP
);
409 /* start delayed pop wq here for playback streams */
411 schedule_delayed_work(&rtd
->delayed_work
,
412 msecs_to_jiffies(rtd
->pmdown_time
));
415 /* capture streams can be powered down now */
416 snd_soc_dapm_stream_event(rtd
, SNDRV_PCM_STREAM_CAPTURE
,
417 SND_SOC_DAPM_STREAM_STOP
);
420 mutex_unlock(&rtd
->pcm_mutex
);
422 pm_runtime_put(platform
->dev
);
423 pm_runtime_put(codec_dai
->dev
);
424 pm_runtime_put(cpu_dai
->dev
);
430 * Called by ALSA when the PCM substream is prepared, can set format, sample
431 * rate, etc. This function is non atomic and can be called multiple times,
432 * it can refer to the runtime info.
434 static int soc_pcm_prepare(struct snd_pcm_substream
*substream
)
436 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
437 struct snd_soc_platform
*platform
= rtd
->platform
;
438 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
439 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
442 mutex_lock_nested(&rtd
->pcm_mutex
, rtd
->pcm_subclass
);
444 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->prepare
) {
445 ret
= rtd
->dai_link
->ops
->prepare(substream
);
447 dev_err(rtd
->card
->dev
, "ASoC: machine prepare error:"
453 if (platform
->driver
->ops
&& platform
->driver
->ops
->prepare
) {
454 ret
= platform
->driver
->ops
->prepare(substream
);
456 dev_err(platform
->dev
, "ASoC: platform prepare error:"
462 if (codec_dai
->driver
->ops
->prepare
) {
463 ret
= codec_dai
->driver
->ops
->prepare(substream
, codec_dai
);
465 dev_err(codec_dai
->dev
, "ASoC: DAI prepare error: %d\n",
471 if (cpu_dai
->driver
->ops
->prepare
) {
472 ret
= cpu_dai
->driver
->ops
->prepare(substream
, cpu_dai
);
474 dev_err(cpu_dai
->dev
, "ASoC: DAI prepare error: %d\n",
480 /* cancel any delayed stream shutdown that is pending */
481 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
&&
484 cancel_delayed_work(&rtd
->delayed_work
);
487 snd_soc_dapm_stream_event(rtd
, substream
->stream
,
488 SND_SOC_DAPM_STREAM_START
);
490 snd_soc_dai_digital_mute(codec_dai
, 0, substream
->stream
);
493 mutex_unlock(&rtd
->pcm_mutex
);
498 * Called by ALSA when the hardware params are set by application. This
499 * function can also be called multiple times and can allocate buffers
500 * (using snd_pcm_lib_* ). It's non-atomic.
502 static int soc_pcm_hw_params(struct snd_pcm_substream
*substream
,
503 struct snd_pcm_hw_params
*params
)
505 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
506 struct snd_soc_platform
*platform
= rtd
->platform
;
507 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
508 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
511 mutex_lock_nested(&rtd
->pcm_mutex
, rtd
->pcm_subclass
);
513 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->hw_params
) {
514 ret
= rtd
->dai_link
->ops
->hw_params(substream
, params
);
516 dev_err(rtd
->card
->dev
, "ASoC: machine hw_params"
517 " failed: %d\n", ret
);
522 if (codec_dai
->driver
->ops
->hw_params
) {
523 ret
= codec_dai
->driver
->ops
->hw_params(substream
, params
, codec_dai
);
525 dev_err(codec_dai
->dev
, "ASoC: can't set %s hw params:"
526 " %d\n", codec_dai
->name
, ret
);
531 if (cpu_dai
->driver
->ops
->hw_params
) {
532 ret
= cpu_dai
->driver
->ops
->hw_params(substream
, params
, cpu_dai
);
534 dev_err(cpu_dai
->dev
, "ASoC: %s hw params failed: %d\n",
540 if (platform
->driver
->ops
&& platform
->driver
->ops
->hw_params
) {
541 ret
= platform
->driver
->ops
->hw_params(substream
, params
);
543 dev_err(platform
->dev
, "ASoC: %s hw params failed: %d\n",
544 platform
->name
, ret
);
549 /* store the rate for each DAIs */
550 cpu_dai
->rate
= params_rate(params
);
551 codec_dai
->rate
= params_rate(params
);
554 mutex_unlock(&rtd
->pcm_mutex
);
558 if (cpu_dai
->driver
->ops
->hw_free
)
559 cpu_dai
->driver
->ops
->hw_free(substream
, cpu_dai
);
562 if (codec_dai
->driver
->ops
->hw_free
)
563 codec_dai
->driver
->ops
->hw_free(substream
, codec_dai
);
566 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->hw_free
)
567 rtd
->dai_link
->ops
->hw_free(substream
);
569 mutex_unlock(&rtd
->pcm_mutex
);
574 * Frees resources allocated by hw_params, can be called multiple times
576 static int soc_pcm_hw_free(struct snd_pcm_substream
*substream
)
578 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
579 struct snd_soc_platform
*platform
= rtd
->platform
;
580 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
581 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
582 struct snd_soc_codec
*codec
= rtd
->codec
;
584 mutex_lock_nested(&rtd
->pcm_mutex
, rtd
->pcm_subclass
);
586 /* apply codec digital mute */
588 snd_soc_dai_digital_mute(codec_dai
, 1, substream
->stream
);
590 /* free any machine hw params */
591 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->hw_free
)
592 rtd
->dai_link
->ops
->hw_free(substream
);
594 /* free any DMA resources */
595 if (platform
->driver
->ops
&& platform
->driver
->ops
->hw_free
)
596 platform
->driver
->ops
->hw_free(substream
);
598 /* now free hw params for the DAIs */
599 if (codec_dai
->driver
->ops
->hw_free
)
600 codec_dai
->driver
->ops
->hw_free(substream
, codec_dai
);
602 if (cpu_dai
->driver
->ops
->hw_free
)
603 cpu_dai
->driver
->ops
->hw_free(substream
, cpu_dai
);
605 mutex_unlock(&rtd
->pcm_mutex
);
609 static int soc_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
611 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
612 struct snd_soc_platform
*platform
= rtd
->platform
;
613 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
614 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
617 if (codec_dai
->driver
->ops
->trigger
) {
618 ret
= codec_dai
->driver
->ops
->trigger(substream
, cmd
, codec_dai
);
623 if (platform
->driver
->ops
&& platform
->driver
->ops
->trigger
) {
624 ret
= platform
->driver
->ops
->trigger(substream
, cmd
);
629 if (cpu_dai
->driver
->ops
->trigger
) {
630 ret
= cpu_dai
->driver
->ops
->trigger(substream
, cmd
, cpu_dai
);
637 static int soc_pcm_bespoke_trigger(struct snd_pcm_substream
*substream
,
640 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
641 struct snd_soc_platform
*platform
= rtd
->platform
;
642 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
643 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
646 if (codec_dai
->driver
->ops
->bespoke_trigger
) {
647 ret
= codec_dai
->driver
->ops
->bespoke_trigger(substream
, cmd
, codec_dai
);
652 if (platform
->driver
->bespoke_trigger
) {
653 ret
= platform
->driver
->bespoke_trigger(substream
, cmd
);
658 if (cpu_dai
->driver
->ops
->bespoke_trigger
) {
659 ret
= cpu_dai
->driver
->ops
->bespoke_trigger(substream
, cmd
, cpu_dai
);
666 * soc level wrapper for pointer callback
667 * If cpu_dai, codec_dai, platform driver has the delay callback, than
668 * the runtime->delay will be updated accordingly.
670 static snd_pcm_uframes_t
soc_pcm_pointer(struct snd_pcm_substream
*substream
)
672 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
673 struct snd_soc_platform
*platform
= rtd
->platform
;
674 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
675 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
676 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
677 snd_pcm_uframes_t offset
= 0;
678 snd_pcm_sframes_t delay
= 0;
680 if (platform
->driver
->ops
&& platform
->driver
->ops
->pointer
)
681 offset
= platform
->driver
->ops
->pointer(substream
);
683 if (cpu_dai
->driver
->ops
->delay
)
684 delay
+= cpu_dai
->driver
->ops
->delay(substream
, cpu_dai
);
686 if (codec_dai
->driver
->ops
->delay
)
687 delay
+= codec_dai
->driver
->ops
->delay(substream
, codec_dai
);
689 if (platform
->driver
->delay
)
690 delay
+= platform
->driver
->delay(substream
, codec_dai
);
692 runtime
->delay
= delay
;
697 /* connect a FE and BE */
698 static int dpcm_be_connect(struct snd_soc_pcm_runtime
*fe
,
699 struct snd_soc_pcm_runtime
*be
, int stream
)
701 struct snd_soc_dpcm
*dpcm
;
703 /* only add new dpcms */
704 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
705 if (dpcm
->be
== be
&& dpcm
->fe
== fe
)
709 dpcm
= kzalloc(sizeof(struct snd_soc_dpcm
), GFP_KERNEL
);
715 be
->dpcm
[stream
].runtime
= fe
->dpcm
[stream
].runtime
;
716 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_NEW
;
717 list_add(&dpcm
->list_be
, &fe
->dpcm
[stream
].be_clients
);
718 list_add(&dpcm
->list_fe
, &be
->dpcm
[stream
].fe_clients
);
720 dev_dbg(fe
->dev
, " connected new DPCM %s path %s %s %s\n",
721 stream
? "capture" : "playback", fe
->dai_link
->name
,
722 stream
? "<-" : "->", be
->dai_link
->name
);
724 #ifdef CONFIG_DEBUG_FS
725 dpcm
->debugfs_state
= debugfs_create_u32(be
->dai_link
->name
, 0644,
726 fe
->debugfs_dpcm_root
, &dpcm
->state
);
731 /* reparent a BE onto another FE */
732 static void dpcm_be_reparent(struct snd_soc_pcm_runtime
*fe
,
733 struct snd_soc_pcm_runtime
*be
, int stream
)
735 struct snd_soc_dpcm
*dpcm
;
736 struct snd_pcm_substream
*fe_substream
, *be_substream
;
738 /* reparent if BE is connected to other FEs */
739 if (!be
->dpcm
[stream
].users
)
742 be_substream
= snd_soc_dpcm_get_substream(be
, stream
);
744 list_for_each_entry(dpcm
, &be
->dpcm
[stream
].fe_clients
, list_fe
) {
748 dev_dbg(fe
->dev
, " reparent %s path %s %s %s\n",
749 stream
? "capture" : "playback",
750 dpcm
->fe
->dai_link
->name
,
751 stream
? "<-" : "->", dpcm
->be
->dai_link
->name
);
753 fe_substream
= snd_soc_dpcm_get_substream(dpcm
->fe
, stream
);
754 be_substream
->runtime
= fe_substream
->runtime
;
759 /* disconnect a BE and FE */
760 static void dpcm_be_disconnect(struct snd_soc_pcm_runtime
*fe
, int stream
)
762 struct snd_soc_dpcm
*dpcm
, *d
;
764 list_for_each_entry_safe(dpcm
, d
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
765 dev_dbg(fe
->dev
, "ASoC: BE %s disconnect check for %s\n",
766 stream
? "capture" : "playback",
767 dpcm
->be
->dai_link
->name
);
769 if (dpcm
->state
!= SND_SOC_DPCM_LINK_STATE_FREE
)
772 dev_dbg(fe
->dev
, " freed DSP %s path %s %s %s\n",
773 stream
? "capture" : "playback", fe
->dai_link
->name
,
774 stream
? "<-" : "->", dpcm
->be
->dai_link
->name
);
776 /* BEs still alive need new FE */
777 dpcm_be_reparent(fe
, dpcm
->be
, stream
);
779 #ifdef CONFIG_DEBUG_FS
780 debugfs_remove(dpcm
->debugfs_state
);
782 list_del(&dpcm
->list_be
);
783 list_del(&dpcm
->list_fe
);
788 /* get BE for DAI widget and stream */
789 static struct snd_soc_pcm_runtime
*dpcm_get_be(struct snd_soc_card
*card
,
790 struct snd_soc_dapm_widget
*widget
, int stream
)
792 struct snd_soc_pcm_runtime
*be
;
795 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
796 for (i
= 0; i
< card
->num_links
; i
++) {
799 if (!be
->dai_link
->no_pcm
)
802 if (be
->cpu_dai
->playback_widget
== widget
||
803 be
->codec_dai
->playback_widget
== widget
)
808 for (i
= 0; i
< card
->num_links
; i
++) {
811 if (!be
->dai_link
->no_pcm
)
814 if (be
->cpu_dai
->capture_widget
== widget
||
815 be
->codec_dai
->capture_widget
== widget
)
820 dev_err(card
->dev
, "ASoC: can't get %s BE for %s\n",
821 stream
? "capture" : "playback", widget
->name
);
825 static inline struct snd_soc_dapm_widget
*
826 rtd_get_cpu_widget(struct snd_soc_pcm_runtime
*rtd
, int stream
)
828 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
)
829 return rtd
->cpu_dai
->playback_widget
;
831 return rtd
->cpu_dai
->capture_widget
;
834 static inline struct snd_soc_dapm_widget
*
835 rtd_get_codec_widget(struct snd_soc_pcm_runtime
*rtd
, int stream
)
837 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
)
838 return rtd
->codec_dai
->playback_widget
;
840 return rtd
->codec_dai
->capture_widget
;
843 static int widget_in_list(struct snd_soc_dapm_widget_list
*list
,
844 struct snd_soc_dapm_widget
*widget
)
848 for (i
= 0; i
< list
->num_widgets
; i
++) {
849 if (widget
== list
->widgets
[i
])
856 static int dpcm_path_get(struct snd_soc_pcm_runtime
*fe
,
857 int stream
, struct snd_soc_dapm_widget_list
**list_
)
859 struct snd_soc_dai
*cpu_dai
= fe
->cpu_dai
;
860 struct snd_soc_dapm_widget_list
*list
;
863 list
= kzalloc(sizeof(struct snd_soc_dapm_widget_list
) +
864 sizeof(struct snd_soc_dapm_widget
*), GFP_KERNEL
);
868 /* get number of valid DAI paths and their widgets */
869 paths
= snd_soc_dapm_dai_get_connected_widgets(cpu_dai
, stream
, &list
);
871 dev_dbg(fe
->dev
, "ASoC: found %d audio %s paths\n", paths
,
872 stream
? "capture" : "playback");
878 static inline void dpcm_path_put(struct snd_soc_dapm_widget_list
**list
)
883 static int dpcm_prune_paths(struct snd_soc_pcm_runtime
*fe
, int stream
,
884 struct snd_soc_dapm_widget_list
**list_
)
886 struct snd_soc_dpcm
*dpcm
;
887 struct snd_soc_dapm_widget_list
*list
= *list_
;
888 struct snd_soc_dapm_widget
*widget
;
891 /* Destroy any old FE <--> BE connections */
892 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
894 /* is there a valid CPU DAI widget for this BE */
895 widget
= rtd_get_cpu_widget(dpcm
->be
, stream
);
897 /* prune the BE if it's no longer in our active list */
898 if (widget
&& widget_in_list(list
, widget
))
901 /* is there a valid CODEC DAI widget for this BE */
902 widget
= rtd_get_codec_widget(dpcm
->be
, stream
);
904 /* prune the BE if it's no longer in our active list */
905 if (widget
&& widget_in_list(list
, widget
))
908 dev_dbg(fe
->dev
, "ASoC: pruning %s BE %s for %s\n",
909 stream
? "capture" : "playback",
910 dpcm
->be
->dai_link
->name
, fe
->dai_link
->name
);
911 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_FREE
;
912 dpcm
->be
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_BE
;
916 dev_dbg(fe
->dev
, "ASoC: found %d old BE paths for pruning\n", prune
);
920 static int dpcm_add_paths(struct snd_soc_pcm_runtime
*fe
, int stream
,
921 struct snd_soc_dapm_widget_list
**list_
)
923 struct snd_soc_card
*card
= fe
->card
;
924 struct snd_soc_dapm_widget_list
*list
= *list_
;
925 struct snd_soc_pcm_runtime
*be
;
928 /* Create any new FE <--> BE connections */
929 for (i
= 0; i
< list
->num_widgets
; i
++) {
931 switch (list
->widgets
[i
]->id
) {
932 case snd_soc_dapm_dai_in
:
933 case snd_soc_dapm_dai_out
:
939 /* is there a valid BE rtd for this widget */
940 be
= dpcm_get_be(card
, list
->widgets
[i
], stream
);
942 dev_err(fe
->dev
, "ASoC: no BE found for %s\n",
943 list
->widgets
[i
]->name
);
947 /* make sure BE is a real BE */
948 if (!be
->dai_link
->no_pcm
)
951 /* don't connect if FE is not running */
952 if (!fe
->dpcm
[stream
].runtime
)
955 /* newly connected FE and BE */
956 err
= dpcm_be_connect(fe
, be
, stream
);
958 dev_err(fe
->dev
, "ASoC: can't connect %s\n",
959 list
->widgets
[i
]->name
);
961 } else if (err
== 0) /* already connected */
965 be
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_BE
;
969 dev_dbg(fe
->dev
, "ASoC: found %d new BE paths\n", new);
974 * Find the corresponding BE DAIs that source or sink audio to this
977 static int dpcm_process_paths(struct snd_soc_pcm_runtime
*fe
,
978 int stream
, struct snd_soc_dapm_widget_list
**list
, int new)
981 return dpcm_add_paths(fe
, stream
, list
);
983 return dpcm_prune_paths(fe
, stream
, list
);
986 static void dpcm_clear_pending_state(struct snd_soc_pcm_runtime
*fe
, int stream
)
988 struct snd_soc_dpcm
*dpcm
;
990 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
)
991 dpcm
->be
->dpcm
[stream
].runtime_update
=
992 SND_SOC_DPCM_UPDATE_NO
;
995 static void dpcm_be_dai_startup_unwind(struct snd_soc_pcm_runtime
*fe
,
998 struct snd_soc_dpcm
*dpcm
;
1000 /* disable any enabled and non active backends */
1001 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1003 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1004 struct snd_pcm_substream
*be_substream
=
1005 snd_soc_dpcm_get_substream(be
, stream
);
1007 if (be
->dpcm
[stream
].users
== 0)
1008 dev_err(be
->dev
, "ASoC: no users %s at close - state %d\n",
1009 stream
? "capture" : "playback",
1010 be
->dpcm
[stream
].state
);
1012 if (--be
->dpcm
[stream
].users
!= 0)
1015 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_OPEN
)
1018 soc_pcm_close(be_substream
);
1019 be_substream
->runtime
= NULL
;
1020 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_CLOSE
;
1024 static int dpcm_be_dai_startup(struct snd_soc_pcm_runtime
*fe
, int stream
)
1026 struct snd_soc_dpcm
*dpcm
;
1029 /* only startup BE DAIs that are either sinks or sources to this FE DAI */
1030 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1032 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1033 struct snd_pcm_substream
*be_substream
=
1034 snd_soc_dpcm_get_substream(be
, stream
);
1036 /* is this op for this BE ? */
1037 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1040 /* first time the dpcm is open ? */
1041 if (be
->dpcm
[stream
].users
== DPCM_MAX_BE_USERS
)
1042 dev_err(be
->dev
, "ASoC: too many users %s at open %d\n",
1043 stream
? "capture" : "playback",
1044 be
->dpcm
[stream
].state
);
1046 if (be
->dpcm
[stream
].users
++ != 0)
1049 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_NEW
) &&
1050 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_CLOSE
))
1053 dev_dbg(be
->dev
, "ASoC: open BE %s\n", be
->dai_link
->name
);
1055 be_substream
->runtime
= be
->dpcm
[stream
].runtime
;
1056 err
= soc_pcm_open(be_substream
);
1058 dev_err(be
->dev
, "ASoC: BE open failed %d\n", err
);
1059 be
->dpcm
[stream
].users
--;
1060 if (be
->dpcm
[stream
].users
< 0)
1061 dev_err(be
->dev
, "ASoC: no users %s at unwind %d\n",
1062 stream
? "capture" : "playback",
1063 be
->dpcm
[stream
].state
);
1065 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_CLOSE
;
1069 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_OPEN
;
1076 /* disable any enabled and non active backends */
1077 list_for_each_entry_continue_reverse(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1078 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1079 struct snd_pcm_substream
*be_substream
=
1080 snd_soc_dpcm_get_substream(be
, stream
);
1082 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1085 if (be
->dpcm
[stream
].users
== 0)
1086 dev_err(be
->dev
, "ASoC: no users %s at close %d\n",
1087 stream
? "capture" : "playback",
1088 be
->dpcm
[stream
].state
);
1090 if (--be
->dpcm
[stream
].users
!= 0)
1093 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_OPEN
)
1096 soc_pcm_close(be_substream
);
1097 be_substream
->runtime
= NULL
;
1098 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_CLOSE
;
1104 static void dpcm_set_fe_runtime(struct snd_pcm_substream
*substream
)
1106 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1107 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
1108 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1109 struct snd_soc_dai_driver
*cpu_dai_drv
= cpu_dai
->driver
;
1111 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
1112 runtime
->hw
.rate_min
= cpu_dai_drv
->playback
.rate_min
;
1113 runtime
->hw
.rate_max
= cpu_dai_drv
->playback
.rate_max
;
1114 runtime
->hw
.channels_min
= cpu_dai_drv
->playback
.channels_min
;
1115 runtime
->hw
.channels_max
= cpu_dai_drv
->playback
.channels_max
;
1116 runtime
->hw
.formats
&= cpu_dai_drv
->playback
.formats
;
1117 runtime
->hw
.rates
= cpu_dai_drv
->playback
.rates
;
1119 runtime
->hw
.rate_min
= cpu_dai_drv
->capture
.rate_min
;
1120 runtime
->hw
.rate_max
= cpu_dai_drv
->capture
.rate_max
;
1121 runtime
->hw
.channels_min
= cpu_dai_drv
->capture
.channels_min
;
1122 runtime
->hw
.channels_max
= cpu_dai_drv
->capture
.channels_max
;
1123 runtime
->hw
.formats
&= cpu_dai_drv
->capture
.formats
;
1124 runtime
->hw
.rates
= cpu_dai_drv
->capture
.rates
;
1128 static int dpcm_fe_dai_startup(struct snd_pcm_substream
*fe_substream
)
1130 struct snd_soc_pcm_runtime
*fe
= fe_substream
->private_data
;
1131 struct snd_pcm_runtime
*runtime
= fe_substream
->runtime
;
1132 int stream
= fe_substream
->stream
, ret
= 0;
1134 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_FE
;
1136 ret
= dpcm_be_dai_startup(fe
, fe_substream
->stream
);
1138 dev_err(fe
->dev
,"ASoC: failed to start some BEs %d\n", ret
);
1142 dev_dbg(fe
->dev
, "ASoC: open FE %s\n", fe
->dai_link
->name
);
1144 /* start the DAI frontend */
1145 ret
= soc_pcm_open(fe_substream
);
1147 dev_err(fe
->dev
,"ASoC: failed to start FE %d\n", ret
);
1151 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_OPEN
;
1153 dpcm_set_fe_runtime(fe_substream
);
1154 snd_pcm_limit_hw_rates(runtime
);
1156 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1160 dpcm_be_dai_startup_unwind(fe
, fe_substream
->stream
);
1162 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1166 static int dpcm_be_dai_shutdown(struct snd_soc_pcm_runtime
*fe
, int stream
)
1168 struct snd_soc_dpcm
*dpcm
;
1170 /* only shutdown BEs that are either sinks or sources to this FE DAI */
1171 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1173 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1174 struct snd_pcm_substream
*be_substream
=
1175 snd_soc_dpcm_get_substream(be
, stream
);
1177 /* is this op for this BE ? */
1178 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1181 if (be
->dpcm
[stream
].users
== 0)
1182 dev_err(be
->dev
, "ASoC: no users %s at close - state %d\n",
1183 stream
? "capture" : "playback",
1184 be
->dpcm
[stream
].state
);
1186 if (--be
->dpcm
[stream
].users
!= 0)
1189 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_FREE
) &&
1190 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_OPEN
))
1193 dev_dbg(be
->dev
, "ASoC: close BE %s\n",
1194 dpcm
->fe
->dai_link
->name
);
1196 soc_pcm_close(be_substream
);
1197 be_substream
->runtime
= NULL
;
1199 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_CLOSE
;
1204 static int dpcm_fe_dai_shutdown(struct snd_pcm_substream
*substream
)
1206 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1207 int stream
= substream
->stream
;
1209 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_FE
;
1211 /* shutdown the BEs */
1212 dpcm_be_dai_shutdown(fe
, substream
->stream
);
1214 dev_dbg(fe
->dev
, "ASoC: close FE %s\n", fe
->dai_link
->name
);
1216 /* now shutdown the frontend */
1217 soc_pcm_close(substream
);
1219 /* run the stream event for each BE */
1220 dpcm_dapm_stream_event(fe
, stream
, SND_SOC_DAPM_STREAM_STOP
);
1222 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_CLOSE
;
1223 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1227 static int dpcm_be_dai_hw_free(struct snd_soc_pcm_runtime
*fe
, int stream
)
1229 struct snd_soc_dpcm
*dpcm
;
1231 /* only hw_params backends that are either sinks or sources
1232 * to this frontend DAI */
1233 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1235 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1236 struct snd_pcm_substream
*be_substream
=
1237 snd_soc_dpcm_get_substream(be
, stream
);
1239 /* is this op for this BE ? */
1240 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1243 /* only free hw when no longer used - check all FEs */
1244 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
1247 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
1248 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_PREPARE
) &&
1249 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_FREE
) &&
1250 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_PAUSED
) &&
1251 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
))
1254 dev_dbg(be
->dev
, "ASoC: hw_free BE %s\n",
1255 dpcm
->fe
->dai_link
->name
);
1257 soc_pcm_hw_free(be_substream
);
1259 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_HW_FREE
;
1265 static int dpcm_fe_dai_hw_free(struct snd_pcm_substream
*substream
)
1267 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1268 int err
, stream
= substream
->stream
;
1270 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1271 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_FE
;
1273 dev_dbg(fe
->dev
, "ASoC: hw_free FE %s\n", fe
->dai_link
->name
);
1275 /* call hw_free on the frontend */
1276 err
= soc_pcm_hw_free(substream
);
1278 dev_err(fe
->dev
,"ASoC: hw_free FE %s failed\n",
1279 fe
->dai_link
->name
);
1281 /* only hw_params backends that are either sinks or sources
1282 * to this frontend DAI */
1283 err
= dpcm_be_dai_hw_free(fe
, stream
);
1285 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_HW_FREE
;
1286 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1288 mutex_unlock(&fe
->card
->mutex
);
1292 static int dpcm_be_dai_hw_params(struct snd_soc_pcm_runtime
*fe
, int stream
)
1294 struct snd_soc_dpcm
*dpcm
;
1297 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1299 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1300 struct snd_pcm_substream
*be_substream
=
1301 snd_soc_dpcm_get_substream(be
, stream
);
1303 /* is this op for this BE ? */
1304 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1307 /* only allow hw_params() if no connected FEs are running */
1308 if (!snd_soc_dpcm_can_be_params(fe
, be
, stream
))
1311 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_OPEN
) &&
1312 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
1313 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_FREE
))
1316 dev_dbg(be
->dev
, "ASoC: hw_params BE %s\n",
1317 dpcm
->fe
->dai_link
->name
);
1319 /* copy params for each dpcm */
1320 memcpy(&dpcm
->hw_params
, &fe
->dpcm
[stream
].hw_params
,
1321 sizeof(struct snd_pcm_hw_params
));
1323 /* perform any hw_params fixups */
1324 if (be
->dai_link
->be_hw_params_fixup
) {
1325 ret
= be
->dai_link
->be_hw_params_fixup(be
,
1329 "ASoC: hw_params BE fixup failed %d\n",
1335 ret
= soc_pcm_hw_params(be_substream
, &dpcm
->hw_params
);
1337 dev_err(dpcm
->be
->dev
,
1338 "ASoC: hw_params BE failed %d\n", ret
);
1342 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_HW_PARAMS
;
1347 /* disable any enabled and non active backends */
1348 list_for_each_entry_continue_reverse(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1349 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1350 struct snd_pcm_substream
*be_substream
=
1351 snd_soc_dpcm_get_substream(be
, stream
);
1353 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1356 /* only allow hw_free() if no connected FEs are running */
1357 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
1360 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_OPEN
) &&
1361 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
1362 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_FREE
) &&
1363 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
))
1366 soc_pcm_hw_free(be_substream
);
1372 static int dpcm_fe_dai_hw_params(struct snd_pcm_substream
*substream
,
1373 struct snd_pcm_hw_params
*params
)
1375 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1376 int ret
, stream
= substream
->stream
;
1378 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1379 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_FE
;
1381 memcpy(&fe
->dpcm
[substream
->stream
].hw_params
, params
,
1382 sizeof(struct snd_pcm_hw_params
));
1383 ret
= dpcm_be_dai_hw_params(fe
, substream
->stream
);
1385 dev_err(fe
->dev
,"ASoC: hw_params BE failed %d\n", ret
);
1389 dev_dbg(fe
->dev
, "ASoC: hw_params FE %s rate %d chan %x fmt %d\n",
1390 fe
->dai_link
->name
, params_rate(params
),
1391 params_channels(params
), params_format(params
));
1393 /* call hw_params on the frontend */
1394 ret
= soc_pcm_hw_params(substream
, params
);
1396 dev_err(fe
->dev
,"ASoC: hw_params FE failed %d\n", ret
);
1397 dpcm_be_dai_hw_free(fe
, stream
);
1399 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_HW_PARAMS
;
1402 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1403 mutex_unlock(&fe
->card
->mutex
);
1407 static int dpcm_do_trigger(struct snd_soc_dpcm
*dpcm
,
1408 struct snd_pcm_substream
*substream
, int cmd
)
1412 dev_dbg(dpcm
->be
->dev
, "ASoC: trigger BE %s cmd %d\n",
1413 dpcm
->fe
->dai_link
->name
, cmd
);
1415 ret
= soc_pcm_trigger(substream
, cmd
);
1417 dev_err(dpcm
->be
->dev
,"ASoC: trigger BE failed %d\n", ret
);
1422 static int dpcm_be_dai_trigger(struct snd_soc_pcm_runtime
*fe
, int stream
,
1425 struct snd_soc_dpcm
*dpcm
;
1428 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1430 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1431 struct snd_pcm_substream
*be_substream
=
1432 snd_soc_dpcm_get_substream(be
, stream
);
1434 /* is this op for this BE ? */
1435 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1439 case SNDRV_PCM_TRIGGER_START
:
1440 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_PREPARE
) &&
1441 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
))
1444 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
1448 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_START
;
1450 case SNDRV_PCM_TRIGGER_RESUME
:
1451 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_SUSPEND
))
1454 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
1458 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_START
;
1460 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
1461 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_PAUSED
))
1464 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
1468 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_START
;
1470 case SNDRV_PCM_TRIGGER_STOP
:
1471 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_START
)
1474 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
1477 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
1481 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_STOP
;
1483 case SNDRV_PCM_TRIGGER_SUSPEND
:
1484 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
)
1487 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
1490 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
1494 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_SUSPEND
;
1496 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
1497 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_START
)
1500 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
1503 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
1507 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_PAUSED
;
1514 EXPORT_SYMBOL_GPL(dpcm_be_dai_trigger
);
1516 static int dpcm_fe_dai_trigger(struct snd_pcm_substream
*substream
, int cmd
)
1518 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1519 int stream
= substream
->stream
, ret
;
1520 enum snd_soc_dpcm_trigger trigger
= fe
->dai_link
->trigger
[stream
];
1522 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_FE
;
1525 case SND_SOC_DPCM_TRIGGER_PRE
:
1526 /* call trigger on the frontend before the backend. */
1528 dev_dbg(fe
->dev
, "ASoC: pre trigger FE %s cmd %d\n",
1529 fe
->dai_link
->name
, cmd
);
1531 ret
= soc_pcm_trigger(substream
, cmd
);
1533 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", ret
);
1537 ret
= dpcm_be_dai_trigger(fe
, substream
->stream
, cmd
);
1539 case SND_SOC_DPCM_TRIGGER_POST
:
1540 /* call trigger on the frontend after the backend. */
1542 ret
= dpcm_be_dai_trigger(fe
, substream
->stream
, cmd
);
1544 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", ret
);
1548 dev_dbg(fe
->dev
, "ASoC: post trigger FE %s cmd %d\n",
1549 fe
->dai_link
->name
, cmd
);
1551 ret
= soc_pcm_trigger(substream
, cmd
);
1553 case SND_SOC_DPCM_TRIGGER_BESPOKE
:
1554 /* bespoke trigger() - handles both FE and BEs */
1556 dev_dbg(fe
->dev
, "ASoC: bespoke trigger FE %s cmd %d\n",
1557 fe
->dai_link
->name
, cmd
);
1559 ret
= soc_pcm_bespoke_trigger(substream
, cmd
);
1561 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", ret
);
1566 dev_err(fe
->dev
, "ASoC: invalid trigger cmd %d for %s\n", cmd
,
1567 fe
->dai_link
->name
);
1573 case SNDRV_PCM_TRIGGER_START
:
1574 case SNDRV_PCM_TRIGGER_RESUME
:
1575 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
1576 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_START
;
1578 case SNDRV_PCM_TRIGGER_STOP
:
1579 case SNDRV_PCM_TRIGGER_SUSPEND
:
1580 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
1581 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_STOP
;
1586 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1590 static int dpcm_be_dai_prepare(struct snd_soc_pcm_runtime
*fe
, int stream
)
1592 struct snd_soc_dpcm
*dpcm
;
1595 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1597 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1598 struct snd_pcm_substream
*be_substream
=
1599 snd_soc_dpcm_get_substream(be
, stream
);
1601 /* is this op for this BE ? */
1602 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1605 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
1606 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
))
1609 dev_dbg(be
->dev
, "ASoC: prepare BE %s\n",
1610 dpcm
->fe
->dai_link
->name
);
1612 ret
= soc_pcm_prepare(be_substream
);
1614 dev_err(be
->dev
, "ASoC: backend prepare failed %d\n",
1619 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_PREPARE
;
1624 static int dpcm_fe_dai_prepare(struct snd_pcm_substream
*substream
)
1626 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1627 int stream
= substream
->stream
, ret
= 0;
1629 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1631 dev_dbg(fe
->dev
, "ASoC: prepare FE %s\n", fe
->dai_link
->name
);
1633 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_FE
;
1635 /* there is no point preparing this FE if there are no BEs */
1636 if (list_empty(&fe
->dpcm
[stream
].be_clients
)) {
1637 dev_err(fe
->dev
, "ASoC: no backend DAIs enabled for %s\n",
1638 fe
->dai_link
->name
);
1643 ret
= dpcm_be_dai_prepare(fe
, substream
->stream
);
1647 /* call prepare on the frontend */
1648 ret
= soc_pcm_prepare(substream
);
1650 dev_err(fe
->dev
,"ASoC: prepare FE %s failed\n",
1651 fe
->dai_link
->name
);
1655 /* run the stream event for each BE */
1656 dpcm_dapm_stream_event(fe
, stream
, SND_SOC_DAPM_STREAM_START
);
1657 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_PREPARE
;
1660 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1661 mutex_unlock(&fe
->card
->mutex
);
1666 static int soc_pcm_ioctl(struct snd_pcm_substream
*substream
,
1667 unsigned int cmd
, void *arg
)
1669 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
1670 struct snd_soc_platform
*platform
= rtd
->platform
;
1672 if (platform
->driver
->ops
->ioctl
)
1673 return platform
->driver
->ops
->ioctl(substream
, cmd
, arg
);
1674 return snd_pcm_lib_ioctl(substream
, cmd
, arg
);
1677 static int dpcm_run_update_shutdown(struct snd_soc_pcm_runtime
*fe
, int stream
)
1679 struct snd_pcm_substream
*substream
=
1680 snd_soc_dpcm_get_substream(fe
, stream
);
1681 enum snd_soc_dpcm_trigger trigger
= fe
->dai_link
->trigger
[stream
];
1684 dev_dbg(fe
->dev
, "ASoC: runtime %s close on FE %s\n",
1685 stream
? "capture" : "playback", fe
->dai_link
->name
);
1687 if (trigger
== SND_SOC_DPCM_TRIGGER_BESPOKE
) {
1688 /* call bespoke trigger - FE takes care of all BE triggers */
1689 dev_dbg(fe
->dev
, "ASoC: bespoke trigger FE %s cmd stop\n",
1690 fe
->dai_link
->name
);
1692 err
= soc_pcm_bespoke_trigger(substream
, SNDRV_PCM_TRIGGER_STOP
);
1694 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", err
);
1696 dev_dbg(fe
->dev
, "ASoC: trigger FE %s cmd stop\n",
1697 fe
->dai_link
->name
);
1699 err
= dpcm_be_dai_trigger(fe
, stream
, SNDRV_PCM_TRIGGER_STOP
);
1701 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", err
);
1704 err
= dpcm_be_dai_hw_free(fe
, stream
);
1706 dev_err(fe
->dev
,"ASoC: hw_free FE failed %d\n", err
);
1708 err
= dpcm_be_dai_shutdown(fe
, stream
);
1710 dev_err(fe
->dev
,"ASoC: shutdown FE failed %d\n", err
);
1712 /* run the stream event for each BE */
1713 dpcm_dapm_stream_event(fe
, stream
, SND_SOC_DAPM_STREAM_NOP
);
1718 static int dpcm_run_update_startup(struct snd_soc_pcm_runtime
*fe
, int stream
)
1720 struct snd_pcm_substream
*substream
=
1721 snd_soc_dpcm_get_substream(fe
, stream
);
1722 struct snd_soc_dpcm
*dpcm
;
1723 enum snd_soc_dpcm_trigger trigger
= fe
->dai_link
->trigger
[stream
];
1726 dev_dbg(fe
->dev
, "ASoC: runtime %s open on FE %s\n",
1727 stream
? "capture" : "playback", fe
->dai_link
->name
);
1729 /* Only start the BE if the FE is ready */
1730 if (fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_HW_FREE
||
1731 fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_CLOSE
)
1734 /* startup must always be called for new BEs */
1735 ret
= dpcm_be_dai_startup(fe
, stream
);
1739 /* keep going if FE state is > open */
1740 if (fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_OPEN
)
1743 ret
= dpcm_be_dai_hw_params(fe
, stream
);
1747 /* keep going if FE state is > hw_params */
1748 if (fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_HW_PARAMS
)
1752 ret
= dpcm_be_dai_prepare(fe
, stream
);
1756 /* run the stream event for each BE */
1757 dpcm_dapm_stream_event(fe
, stream
, SND_SOC_DAPM_STREAM_NOP
);
1759 /* keep going if FE state is > prepare */
1760 if (fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_PREPARE
||
1761 fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_STOP
)
1764 if (trigger
== SND_SOC_DPCM_TRIGGER_BESPOKE
) {
1765 /* call trigger on the frontend - FE takes care of all BE triggers */
1766 dev_dbg(fe
->dev
, "ASoC: bespoke trigger FE %s cmd start\n",
1767 fe
->dai_link
->name
);
1769 ret
= soc_pcm_bespoke_trigger(substream
, SNDRV_PCM_TRIGGER_START
);
1771 dev_err(fe
->dev
,"ASoC: bespoke trigger FE failed %d\n", ret
);
1775 dev_dbg(fe
->dev
, "ASoC: trigger FE %s cmd start\n",
1776 fe
->dai_link
->name
);
1778 ret
= dpcm_be_dai_trigger(fe
, stream
,
1779 SNDRV_PCM_TRIGGER_START
);
1781 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", ret
);
1789 dpcm_be_dai_hw_free(fe
, stream
);
1791 dpcm_be_dai_shutdown(fe
, stream
);
1793 /* disconnect any non started BEs */
1794 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1795 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1796 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_START
)
1797 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_FREE
;
1803 static int dpcm_run_new_update(struct snd_soc_pcm_runtime
*fe
, int stream
)
1807 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_BE
;
1808 ret
= dpcm_run_update_startup(fe
, stream
);
1810 dev_err(fe
->dev
, "ASoC: failed to startup some BEs\n");
1811 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1816 static int dpcm_run_old_update(struct snd_soc_pcm_runtime
*fe
, int stream
)
1820 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_BE
;
1821 ret
= dpcm_run_update_shutdown(fe
, stream
);
1823 dev_err(fe
->dev
, "ASoC: failed to shutdown some BEs\n");
1824 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1829 /* Called by DAPM mixer/mux changes to update audio routing between PCMs and
1832 int soc_dpcm_runtime_update(struct snd_soc_dapm_widget
*widget
)
1834 struct snd_soc_card
*card
;
1835 int i
, old
, new, paths
;
1838 card
= widget
->codec
->card
;
1839 else if (widget
->platform
)
1840 card
= widget
->platform
->card
;
1844 mutex_lock_nested(&card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1845 for (i
= 0; i
< card
->num_rtd
; i
++) {
1846 struct snd_soc_dapm_widget_list
*list
;
1847 struct snd_soc_pcm_runtime
*fe
= &card
->rtd
[i
];
1849 /* make sure link is FE */
1850 if (!fe
->dai_link
->dynamic
)
1853 /* only check active links */
1854 if (!fe
->cpu_dai
->active
)
1857 /* DAPM sync will call this to update DSP paths */
1858 dev_dbg(fe
->dev
, "ASoC: DPCM runtime update for FE %s\n",
1859 fe
->dai_link
->name
);
1861 /* skip if FE doesn't have playback capability */
1862 if (!fe
->cpu_dai
->driver
->playback
.channels_min
)
1865 paths
= dpcm_path_get(fe
, SNDRV_PCM_STREAM_PLAYBACK
, &list
);
1867 dev_warn(fe
->dev
, "ASoC: %s no valid %s path\n",
1868 fe
->dai_link
->name
, "playback");
1869 mutex_unlock(&card
->mutex
);
1873 /* update any new playback paths */
1874 new = dpcm_process_paths(fe
, SNDRV_PCM_STREAM_PLAYBACK
, &list
, 1);
1876 dpcm_run_new_update(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
1877 dpcm_clear_pending_state(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
1878 dpcm_be_disconnect(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
1881 /* update any old playback paths */
1882 old
= dpcm_process_paths(fe
, SNDRV_PCM_STREAM_PLAYBACK
, &list
, 0);
1884 dpcm_run_old_update(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
1885 dpcm_clear_pending_state(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
1886 dpcm_be_disconnect(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
1890 /* skip if FE doesn't have capture capability */
1891 if (!fe
->cpu_dai
->driver
->capture
.channels_min
)
1894 paths
= dpcm_path_get(fe
, SNDRV_PCM_STREAM_CAPTURE
, &list
);
1896 dev_warn(fe
->dev
, "ASoC: %s no valid %s path\n",
1897 fe
->dai_link
->name
, "capture");
1898 mutex_unlock(&card
->mutex
);
1902 /* update any new capture paths */
1903 new = dpcm_process_paths(fe
, SNDRV_PCM_STREAM_CAPTURE
, &list
, 1);
1905 dpcm_run_new_update(fe
, SNDRV_PCM_STREAM_CAPTURE
);
1906 dpcm_clear_pending_state(fe
, SNDRV_PCM_STREAM_CAPTURE
);
1907 dpcm_be_disconnect(fe
, SNDRV_PCM_STREAM_CAPTURE
);
1910 /* update any old capture paths */
1911 old
= dpcm_process_paths(fe
, SNDRV_PCM_STREAM_CAPTURE
, &list
, 0);
1913 dpcm_run_old_update(fe
, SNDRV_PCM_STREAM_CAPTURE
);
1914 dpcm_clear_pending_state(fe
, SNDRV_PCM_STREAM_CAPTURE
);
1915 dpcm_be_disconnect(fe
, SNDRV_PCM_STREAM_CAPTURE
);
1918 dpcm_path_put(&list
);
1921 mutex_unlock(&card
->mutex
);
1924 int soc_dpcm_be_digital_mute(struct snd_soc_pcm_runtime
*fe
, int mute
)
1926 struct snd_soc_dpcm
*dpcm
;
1927 struct list_head
*clients
=
1928 &fe
->dpcm
[SNDRV_PCM_STREAM_PLAYBACK
].be_clients
;
1930 list_for_each_entry(dpcm
, clients
, list_be
) {
1932 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1933 struct snd_soc_dai
*dai
= be
->codec_dai
;
1934 struct snd_soc_dai_driver
*drv
= dai
->driver
;
1936 if (be
->dai_link
->ignore_suspend
)
1939 dev_dbg(be
->dev
, "ASoC: BE digital mute %s\n", be
->dai_link
->name
);
1941 if (drv
->ops
->digital_mute
&& dai
->playback_active
)
1942 drv
->ops
->digital_mute(dai
, mute
);
1948 static int dpcm_fe_dai_open(struct snd_pcm_substream
*fe_substream
)
1950 struct snd_soc_pcm_runtime
*fe
= fe_substream
->private_data
;
1951 struct snd_soc_dpcm
*dpcm
;
1952 struct snd_soc_dapm_widget_list
*list
;
1954 int stream
= fe_substream
->stream
;
1956 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1957 fe
->dpcm
[stream
].runtime
= fe_substream
->runtime
;
1959 if (dpcm_path_get(fe
, stream
, &list
) <= 0) {
1960 dev_dbg(fe
->dev
, "ASoC: %s no valid %s route\n",
1961 fe
->dai_link
->name
, stream
? "capture" : "playback");
1964 /* calculate valid and active FE <-> BE dpcms */
1965 dpcm_process_paths(fe
, stream
, &list
, 1);
1967 ret
= dpcm_fe_dai_startup(fe_substream
);
1969 /* clean up all links */
1970 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
)
1971 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_FREE
;
1973 dpcm_be_disconnect(fe
, stream
);
1974 fe
->dpcm
[stream
].runtime
= NULL
;
1977 dpcm_clear_pending_state(fe
, stream
);
1978 dpcm_path_put(&list
);
1979 mutex_unlock(&fe
->card
->mutex
);
1983 static int dpcm_fe_dai_close(struct snd_pcm_substream
*fe_substream
)
1985 struct snd_soc_pcm_runtime
*fe
= fe_substream
->private_data
;
1986 struct snd_soc_dpcm
*dpcm
;
1987 int stream
= fe_substream
->stream
, ret
;
1989 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1990 ret
= dpcm_fe_dai_shutdown(fe_substream
);
1992 /* mark FE's links ready to prune */
1993 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
)
1994 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_FREE
;
1996 dpcm_be_disconnect(fe
, stream
);
1998 fe
->dpcm
[stream
].runtime
= NULL
;
1999 mutex_unlock(&fe
->card
->mutex
);
2003 /* create a new pcm */
2004 int soc_new_pcm(struct snd_soc_pcm_runtime
*rtd
, int num
)
2006 struct snd_soc_platform
*platform
= rtd
->platform
;
2007 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
2008 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
2009 struct snd_pcm
*pcm
;
2011 int ret
= 0, playback
= 0, capture
= 0;
2013 if (rtd
->dai_link
->dynamic
|| rtd
->dai_link
->no_pcm
) {
2014 if (cpu_dai
->driver
->playback
.channels_min
)
2016 if (cpu_dai
->driver
->capture
.channels_min
)
2019 if (codec_dai
->driver
->playback
.channels_min
&&
2020 cpu_dai
->driver
->playback
.channels_min
)
2022 if (codec_dai
->driver
->capture
.channels_min
&&
2023 cpu_dai
->driver
->capture
.channels_min
)
2027 /* create the PCM */
2028 if (rtd
->dai_link
->no_pcm
) {
2029 snprintf(new_name
, sizeof(new_name
), "(%s)",
2030 rtd
->dai_link
->stream_name
);
2032 ret
= snd_pcm_new_internal(rtd
->card
->snd_card
, new_name
, num
,
2033 playback
, capture
, &pcm
);
2035 if (rtd
->dai_link
->dynamic
)
2036 snprintf(new_name
, sizeof(new_name
), "%s (*)",
2037 rtd
->dai_link
->stream_name
);
2039 snprintf(new_name
, sizeof(new_name
), "%s %s-%d",
2040 rtd
->dai_link
->stream_name
, codec_dai
->name
, num
);
2042 ret
= snd_pcm_new(rtd
->card
->snd_card
, new_name
, num
, playback
,
2046 dev_err(rtd
->card
->dev
, "ASoC: can't create pcm for %s\n",
2047 rtd
->dai_link
->name
);
2050 dev_dbg(rtd
->card
->dev
, "ASoC: registered pcm #%d %s\n",num
, new_name
);
2052 /* DAPM dai link stream work */
2053 INIT_DELAYED_WORK(&rtd
->delayed_work
, close_delayed_work
);
2056 pcm
->private_data
= rtd
;
2058 if (rtd
->dai_link
->no_pcm
) {
2060 pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
->private_data
= rtd
;
2062 pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
->private_data
= rtd
;
2066 /* ASoC PCM operations */
2067 if (rtd
->dai_link
->dynamic
) {
2068 rtd
->ops
.open
= dpcm_fe_dai_open
;
2069 rtd
->ops
.hw_params
= dpcm_fe_dai_hw_params
;
2070 rtd
->ops
.prepare
= dpcm_fe_dai_prepare
;
2071 rtd
->ops
.trigger
= dpcm_fe_dai_trigger
;
2072 rtd
->ops
.hw_free
= dpcm_fe_dai_hw_free
;
2073 rtd
->ops
.close
= dpcm_fe_dai_close
;
2074 rtd
->ops
.pointer
= soc_pcm_pointer
;
2075 rtd
->ops
.ioctl
= soc_pcm_ioctl
;
2077 rtd
->ops
.open
= soc_pcm_open
;
2078 rtd
->ops
.hw_params
= soc_pcm_hw_params
;
2079 rtd
->ops
.prepare
= soc_pcm_prepare
;
2080 rtd
->ops
.trigger
= soc_pcm_trigger
;
2081 rtd
->ops
.hw_free
= soc_pcm_hw_free
;
2082 rtd
->ops
.close
= soc_pcm_close
;
2083 rtd
->ops
.pointer
= soc_pcm_pointer
;
2084 rtd
->ops
.ioctl
= soc_pcm_ioctl
;
2087 if (platform
->driver
->ops
) {
2088 rtd
->ops
.ack
= platform
->driver
->ops
->ack
;
2089 rtd
->ops
.copy
= platform
->driver
->ops
->copy
;
2090 rtd
->ops
.silence
= platform
->driver
->ops
->silence
;
2091 rtd
->ops
.page
= platform
->driver
->ops
->page
;
2092 rtd
->ops
.mmap
= platform
->driver
->ops
->mmap
;
2096 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &rtd
->ops
);
2099 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &rtd
->ops
);
2101 if (platform
->driver
->pcm_new
) {
2102 ret
= platform
->driver
->pcm_new(rtd
);
2104 dev_err(platform
->dev
,
2105 "ASoC: pcm constructor failed: %d\n",
2111 pcm
->private_free
= platform
->driver
->pcm_free
;
2113 dev_info(rtd
->card
->dev
, " %s <-> %s mapping ok\n", codec_dai
->name
,
2118 /* is the current PCM operation for this FE ? */
2119 int snd_soc_dpcm_fe_can_update(struct snd_soc_pcm_runtime
*fe
, int stream
)
2121 if (fe
->dpcm
[stream
].runtime_update
== SND_SOC_DPCM_UPDATE_FE
)
2125 EXPORT_SYMBOL_GPL(snd_soc_dpcm_fe_can_update
);
2127 /* is the current PCM operation for this BE ? */
2128 int snd_soc_dpcm_be_can_update(struct snd_soc_pcm_runtime
*fe
,
2129 struct snd_soc_pcm_runtime
*be
, int stream
)
2131 if ((fe
->dpcm
[stream
].runtime_update
== SND_SOC_DPCM_UPDATE_FE
) ||
2132 ((fe
->dpcm
[stream
].runtime_update
== SND_SOC_DPCM_UPDATE_BE
) &&
2133 be
->dpcm
[stream
].runtime_update
))
2137 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_can_update
);
2139 /* get the substream for this BE */
2140 struct snd_pcm_substream
*
2141 snd_soc_dpcm_get_substream(struct snd_soc_pcm_runtime
*be
, int stream
)
2143 return be
->pcm
->streams
[stream
].substream
;
2145 EXPORT_SYMBOL_GPL(snd_soc_dpcm_get_substream
);
2147 /* get the BE runtime state */
2148 enum snd_soc_dpcm_state
2149 snd_soc_dpcm_be_get_state(struct snd_soc_pcm_runtime
*be
, int stream
)
2151 return be
->dpcm
[stream
].state
;
2153 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_get_state
);
2155 /* set the BE runtime state */
2156 void snd_soc_dpcm_be_set_state(struct snd_soc_pcm_runtime
*be
,
2157 int stream
, enum snd_soc_dpcm_state state
)
2159 be
->dpcm
[stream
].state
= state
;
2161 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_set_state
);
2164 * We can only hw_free, stop, pause or suspend a BE DAI if any of it's FE
2165 * are not running, paused or suspended for the specified stream direction.
2167 int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime
*fe
,
2168 struct snd_soc_pcm_runtime
*be
, int stream
)
2170 struct snd_soc_dpcm
*dpcm
;
2173 list_for_each_entry(dpcm
, &be
->dpcm
[stream
].fe_clients
, list_fe
) {
2178 state
= dpcm
->fe
->dpcm
[stream
].state
;
2179 if (state
== SND_SOC_DPCM_STATE_START
||
2180 state
== SND_SOC_DPCM_STATE_PAUSED
||
2181 state
== SND_SOC_DPCM_STATE_SUSPEND
)
2185 /* it's safe to free/stop this BE DAI */
2188 EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop
);
2191 * We can only change hw params a BE DAI if any of it's FE are not prepared,
2192 * running, paused or suspended for the specified stream direction.
2194 int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime
*fe
,
2195 struct snd_soc_pcm_runtime
*be
, int stream
)
2197 struct snd_soc_dpcm
*dpcm
;
2200 list_for_each_entry(dpcm
, &be
->dpcm
[stream
].fe_clients
, list_fe
) {
2205 state
= dpcm
->fe
->dpcm
[stream
].state
;
2206 if (state
== SND_SOC_DPCM_STATE_START
||
2207 state
== SND_SOC_DPCM_STATE_PAUSED
||
2208 state
== SND_SOC_DPCM_STATE_SUSPEND
||
2209 state
== SND_SOC_DPCM_STATE_PREPARE
)
2213 /* it's safe to change hw_params */
2216 EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params
);
2218 int snd_soc_platform_trigger(struct snd_pcm_substream
*substream
,
2219 int cmd
, struct snd_soc_platform
*platform
)
2221 if (platform
->driver
->ops
->trigger
)
2222 return platform
->driver
->ops
->trigger(substream
, cmd
);
2225 EXPORT_SYMBOL_GPL(snd_soc_platform_trigger
);
2227 #ifdef CONFIG_DEBUG_FS
2228 static char *dpcm_state_string(enum snd_soc_dpcm_state state
)
2231 case SND_SOC_DPCM_STATE_NEW
:
2233 case SND_SOC_DPCM_STATE_OPEN
:
2235 case SND_SOC_DPCM_STATE_HW_PARAMS
:
2237 case SND_SOC_DPCM_STATE_PREPARE
:
2239 case SND_SOC_DPCM_STATE_START
:
2241 case SND_SOC_DPCM_STATE_STOP
:
2243 case SND_SOC_DPCM_STATE_SUSPEND
:
2245 case SND_SOC_DPCM_STATE_PAUSED
:
2247 case SND_SOC_DPCM_STATE_HW_FREE
:
2249 case SND_SOC_DPCM_STATE_CLOSE
:
2256 static ssize_t
dpcm_show_state(struct snd_soc_pcm_runtime
*fe
,
2257 int stream
, char *buf
, size_t size
)
2259 struct snd_pcm_hw_params
*params
= &fe
->dpcm
[stream
].hw_params
;
2260 struct snd_soc_dpcm
*dpcm
;
2264 offset
+= snprintf(buf
+ offset
, size
- offset
,
2265 "[%s - %s]\n", fe
->dai_link
->name
,
2266 stream
? "Capture" : "Playback");
2268 offset
+= snprintf(buf
+ offset
, size
- offset
, "State: %s\n",
2269 dpcm_state_string(fe
->dpcm
[stream
].state
));
2271 if ((fe
->dpcm
[stream
].state
>= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
2272 (fe
->dpcm
[stream
].state
<= SND_SOC_DPCM_STATE_STOP
))
2273 offset
+= snprintf(buf
+ offset
, size
- offset
,
2275 "Format = %s, Channels = %d, Rate = %d\n",
2276 snd_pcm_format_name(params_format(params
)),
2277 params_channels(params
),
2278 params_rate(params
));
2281 offset
+= snprintf(buf
+ offset
, size
- offset
, "Backends:\n");
2283 if (list_empty(&fe
->dpcm
[stream
].be_clients
)) {
2284 offset
+= snprintf(buf
+ offset
, size
- offset
,
2285 " No active DSP links\n");
2289 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
2290 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
2291 params
= &dpcm
->hw_params
;
2293 offset
+= snprintf(buf
+ offset
, size
- offset
,
2294 "- %s\n", be
->dai_link
->name
);
2296 offset
+= snprintf(buf
+ offset
, size
- offset
,
2298 dpcm_state_string(be
->dpcm
[stream
].state
));
2300 if ((be
->dpcm
[stream
].state
>= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
2301 (be
->dpcm
[stream
].state
<= SND_SOC_DPCM_STATE_STOP
))
2302 offset
+= snprintf(buf
+ offset
, size
- offset
,
2303 " Hardware Params: "
2304 "Format = %s, Channels = %d, Rate = %d\n",
2305 snd_pcm_format_name(params_format(params
)),
2306 params_channels(params
),
2307 params_rate(params
));
2314 static ssize_t
dpcm_state_read_file(struct file
*file
, char __user
*user_buf
,
2315 size_t count
, loff_t
*ppos
)
2317 struct snd_soc_pcm_runtime
*fe
= file
->private_data
;
2318 ssize_t out_count
= PAGE_SIZE
, offset
= 0, ret
= 0;
2321 buf
= kmalloc(out_count
, GFP_KERNEL
);
2325 if (fe
->cpu_dai
->driver
->playback
.channels_min
)
2326 offset
+= dpcm_show_state(fe
, SNDRV_PCM_STREAM_PLAYBACK
,
2327 buf
+ offset
, out_count
- offset
);
2329 if (fe
->cpu_dai
->driver
->capture
.channels_min
)
2330 offset
+= dpcm_show_state(fe
, SNDRV_PCM_STREAM_CAPTURE
,
2331 buf
+ offset
, out_count
- offset
);
2333 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, offset
);
2339 static const struct file_operations dpcm_state_fops
= {
2340 .open
= simple_open
,
2341 .read
= dpcm_state_read_file
,
2342 .llseek
= default_llseek
,
2345 int soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime
*rtd
)
2350 rtd
->debugfs_dpcm_root
= debugfs_create_dir(rtd
->dai_link
->name
,
2351 rtd
->card
->debugfs_card_root
);
2352 if (!rtd
->debugfs_dpcm_root
) {
2354 "ASoC: Failed to create dpcm debugfs directory %s\n",
2355 rtd
->dai_link
->name
);
2359 rtd
->debugfs_dpcm_state
= debugfs_create_file("state", 0444,
2360 rtd
->debugfs_dpcm_root
,
2361 rtd
, &dpcm_state_fops
);