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
) &&
1252 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_SUSPEND
))
1255 dev_dbg(be
->dev
, "ASoC: hw_free BE %s\n",
1256 dpcm
->fe
->dai_link
->name
);
1258 soc_pcm_hw_free(be_substream
);
1260 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_HW_FREE
;
1266 static int dpcm_fe_dai_hw_free(struct snd_pcm_substream
*substream
)
1268 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1269 int err
, stream
= substream
->stream
;
1271 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1272 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_FE
;
1274 dev_dbg(fe
->dev
, "ASoC: hw_free FE %s\n", fe
->dai_link
->name
);
1276 /* call hw_free on the frontend */
1277 err
= soc_pcm_hw_free(substream
);
1279 dev_err(fe
->dev
,"ASoC: hw_free FE %s failed\n",
1280 fe
->dai_link
->name
);
1282 /* only hw_params backends that are either sinks or sources
1283 * to this frontend DAI */
1284 err
= dpcm_be_dai_hw_free(fe
, stream
);
1286 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_HW_FREE
;
1287 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1289 mutex_unlock(&fe
->card
->mutex
);
1293 static int dpcm_be_dai_hw_params(struct snd_soc_pcm_runtime
*fe
, int stream
)
1295 struct snd_soc_dpcm
*dpcm
;
1298 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1300 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1301 struct snd_pcm_substream
*be_substream
=
1302 snd_soc_dpcm_get_substream(be
, stream
);
1304 /* is this op for this BE ? */
1305 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1308 /* only allow hw_params() if no connected FEs are running */
1309 if (!snd_soc_dpcm_can_be_params(fe
, be
, stream
))
1312 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_OPEN
) &&
1313 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
1314 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_FREE
))
1317 dev_dbg(be
->dev
, "ASoC: hw_params BE %s\n",
1318 dpcm
->fe
->dai_link
->name
);
1320 /* copy params for each dpcm */
1321 memcpy(&dpcm
->hw_params
, &fe
->dpcm
[stream
].hw_params
,
1322 sizeof(struct snd_pcm_hw_params
));
1324 /* perform any hw_params fixups */
1325 if (be
->dai_link
->be_hw_params_fixup
) {
1326 ret
= be
->dai_link
->be_hw_params_fixup(be
,
1330 "ASoC: hw_params BE fixup failed %d\n",
1336 ret
= soc_pcm_hw_params(be_substream
, &dpcm
->hw_params
);
1338 dev_err(dpcm
->be
->dev
,
1339 "ASoC: hw_params BE failed %d\n", ret
);
1343 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_HW_PARAMS
;
1348 /* disable any enabled and non active backends */
1349 list_for_each_entry_continue_reverse(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1350 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1351 struct snd_pcm_substream
*be_substream
=
1352 snd_soc_dpcm_get_substream(be
, stream
);
1354 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1357 /* only allow hw_free() if no connected FEs are running */
1358 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
1361 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_OPEN
) &&
1362 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
1363 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_FREE
) &&
1364 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
))
1367 soc_pcm_hw_free(be_substream
);
1373 static int dpcm_fe_dai_hw_params(struct snd_pcm_substream
*substream
,
1374 struct snd_pcm_hw_params
*params
)
1376 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1377 int ret
, stream
= substream
->stream
;
1379 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1380 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_FE
;
1382 memcpy(&fe
->dpcm
[substream
->stream
].hw_params
, params
,
1383 sizeof(struct snd_pcm_hw_params
));
1384 ret
= dpcm_be_dai_hw_params(fe
, substream
->stream
);
1386 dev_err(fe
->dev
,"ASoC: hw_params BE failed %d\n", ret
);
1390 dev_dbg(fe
->dev
, "ASoC: hw_params FE %s rate %d chan %x fmt %d\n",
1391 fe
->dai_link
->name
, params_rate(params
),
1392 params_channels(params
), params_format(params
));
1394 /* call hw_params on the frontend */
1395 ret
= soc_pcm_hw_params(substream
, params
);
1397 dev_err(fe
->dev
,"ASoC: hw_params FE failed %d\n", ret
);
1398 dpcm_be_dai_hw_free(fe
, stream
);
1400 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_HW_PARAMS
;
1403 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1404 mutex_unlock(&fe
->card
->mutex
);
1408 static int dpcm_do_trigger(struct snd_soc_dpcm
*dpcm
,
1409 struct snd_pcm_substream
*substream
, int cmd
)
1413 dev_dbg(dpcm
->be
->dev
, "ASoC: trigger BE %s cmd %d\n",
1414 dpcm
->fe
->dai_link
->name
, cmd
);
1416 ret
= soc_pcm_trigger(substream
, cmd
);
1418 dev_err(dpcm
->be
->dev
,"ASoC: trigger BE failed %d\n", ret
);
1423 static int dpcm_be_dai_trigger(struct snd_soc_pcm_runtime
*fe
, int stream
,
1426 struct snd_soc_dpcm
*dpcm
;
1429 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1431 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1432 struct snd_pcm_substream
*be_substream
=
1433 snd_soc_dpcm_get_substream(be
, stream
);
1435 /* is this op for this BE ? */
1436 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1440 case SNDRV_PCM_TRIGGER_START
:
1441 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_PREPARE
) &&
1442 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
))
1445 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
1449 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_START
;
1451 case SNDRV_PCM_TRIGGER_RESUME
:
1452 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_SUSPEND
))
1455 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
1459 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_START
;
1461 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
1462 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_PAUSED
))
1465 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
1469 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_START
;
1471 case SNDRV_PCM_TRIGGER_STOP
:
1472 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_START
)
1475 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
1478 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
1482 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_STOP
;
1484 case SNDRV_PCM_TRIGGER_SUSPEND
:
1485 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
)
1488 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
1491 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
1495 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_SUSPEND
;
1497 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
1498 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_START
)
1501 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
1504 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
1508 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_PAUSED
;
1515 EXPORT_SYMBOL_GPL(dpcm_be_dai_trigger
);
1517 static int dpcm_fe_dai_trigger(struct snd_pcm_substream
*substream
, int cmd
)
1519 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1520 int stream
= substream
->stream
, ret
;
1521 enum snd_soc_dpcm_trigger trigger
= fe
->dai_link
->trigger
[stream
];
1523 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_FE
;
1526 case SND_SOC_DPCM_TRIGGER_PRE
:
1527 /* call trigger on the frontend before the backend. */
1529 dev_dbg(fe
->dev
, "ASoC: pre trigger FE %s cmd %d\n",
1530 fe
->dai_link
->name
, cmd
);
1532 ret
= soc_pcm_trigger(substream
, cmd
);
1534 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", ret
);
1538 ret
= dpcm_be_dai_trigger(fe
, substream
->stream
, cmd
);
1540 case SND_SOC_DPCM_TRIGGER_POST
:
1541 /* call trigger on the frontend after the backend. */
1543 ret
= dpcm_be_dai_trigger(fe
, substream
->stream
, cmd
);
1545 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", ret
);
1549 dev_dbg(fe
->dev
, "ASoC: post trigger FE %s cmd %d\n",
1550 fe
->dai_link
->name
, cmd
);
1552 ret
= soc_pcm_trigger(substream
, cmd
);
1554 case SND_SOC_DPCM_TRIGGER_BESPOKE
:
1555 /* bespoke trigger() - handles both FE and BEs */
1557 dev_dbg(fe
->dev
, "ASoC: bespoke trigger FE %s cmd %d\n",
1558 fe
->dai_link
->name
, cmd
);
1560 ret
= soc_pcm_bespoke_trigger(substream
, cmd
);
1562 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", ret
);
1567 dev_err(fe
->dev
, "ASoC: invalid trigger cmd %d for %s\n", cmd
,
1568 fe
->dai_link
->name
);
1574 case SNDRV_PCM_TRIGGER_START
:
1575 case SNDRV_PCM_TRIGGER_RESUME
:
1576 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
1577 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_START
;
1579 case SNDRV_PCM_TRIGGER_STOP
:
1580 case SNDRV_PCM_TRIGGER_SUSPEND
:
1581 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
1582 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_STOP
;
1587 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1591 static int dpcm_be_dai_prepare(struct snd_soc_pcm_runtime
*fe
, int stream
)
1593 struct snd_soc_dpcm
*dpcm
;
1596 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1598 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1599 struct snd_pcm_substream
*be_substream
=
1600 snd_soc_dpcm_get_substream(be
, stream
);
1602 /* is this op for this BE ? */
1603 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1606 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
1607 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
))
1610 dev_dbg(be
->dev
, "ASoC: prepare BE %s\n",
1611 dpcm
->fe
->dai_link
->name
);
1613 ret
= soc_pcm_prepare(be_substream
);
1615 dev_err(be
->dev
, "ASoC: backend prepare failed %d\n",
1620 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_PREPARE
;
1625 static int dpcm_fe_dai_prepare(struct snd_pcm_substream
*substream
)
1627 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1628 int stream
= substream
->stream
, ret
= 0;
1630 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1632 dev_dbg(fe
->dev
, "ASoC: prepare FE %s\n", fe
->dai_link
->name
);
1634 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_FE
;
1636 /* there is no point preparing this FE if there are no BEs */
1637 if (list_empty(&fe
->dpcm
[stream
].be_clients
)) {
1638 dev_err(fe
->dev
, "ASoC: no backend DAIs enabled for %s\n",
1639 fe
->dai_link
->name
);
1644 ret
= dpcm_be_dai_prepare(fe
, substream
->stream
);
1648 /* call prepare on the frontend */
1649 ret
= soc_pcm_prepare(substream
);
1651 dev_err(fe
->dev
,"ASoC: prepare FE %s failed\n",
1652 fe
->dai_link
->name
);
1656 /* run the stream event for each BE */
1657 dpcm_dapm_stream_event(fe
, stream
, SND_SOC_DAPM_STREAM_START
);
1658 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_PREPARE
;
1661 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1662 mutex_unlock(&fe
->card
->mutex
);
1667 static int soc_pcm_ioctl(struct snd_pcm_substream
*substream
,
1668 unsigned int cmd
, void *arg
)
1670 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
1671 struct snd_soc_platform
*platform
= rtd
->platform
;
1673 if (platform
->driver
->ops
->ioctl
)
1674 return platform
->driver
->ops
->ioctl(substream
, cmd
, arg
);
1675 return snd_pcm_lib_ioctl(substream
, cmd
, arg
);
1678 static int dpcm_run_update_shutdown(struct snd_soc_pcm_runtime
*fe
, int stream
)
1680 struct snd_pcm_substream
*substream
=
1681 snd_soc_dpcm_get_substream(fe
, stream
);
1682 enum snd_soc_dpcm_trigger trigger
= fe
->dai_link
->trigger
[stream
];
1685 dev_dbg(fe
->dev
, "ASoC: runtime %s close on FE %s\n",
1686 stream
? "capture" : "playback", fe
->dai_link
->name
);
1688 if (trigger
== SND_SOC_DPCM_TRIGGER_BESPOKE
) {
1689 /* call bespoke trigger - FE takes care of all BE triggers */
1690 dev_dbg(fe
->dev
, "ASoC: bespoke trigger FE %s cmd stop\n",
1691 fe
->dai_link
->name
);
1693 err
= soc_pcm_bespoke_trigger(substream
, SNDRV_PCM_TRIGGER_STOP
);
1695 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", err
);
1697 dev_dbg(fe
->dev
, "ASoC: trigger FE %s cmd stop\n",
1698 fe
->dai_link
->name
);
1700 err
= dpcm_be_dai_trigger(fe
, stream
, SNDRV_PCM_TRIGGER_STOP
);
1702 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", err
);
1705 err
= dpcm_be_dai_hw_free(fe
, stream
);
1707 dev_err(fe
->dev
,"ASoC: hw_free FE failed %d\n", err
);
1709 err
= dpcm_be_dai_shutdown(fe
, stream
);
1711 dev_err(fe
->dev
,"ASoC: shutdown FE failed %d\n", err
);
1713 /* run the stream event for each BE */
1714 dpcm_dapm_stream_event(fe
, stream
, SND_SOC_DAPM_STREAM_NOP
);
1719 static int dpcm_run_update_startup(struct snd_soc_pcm_runtime
*fe
, int stream
)
1721 struct snd_pcm_substream
*substream
=
1722 snd_soc_dpcm_get_substream(fe
, stream
);
1723 struct snd_soc_dpcm
*dpcm
;
1724 enum snd_soc_dpcm_trigger trigger
= fe
->dai_link
->trigger
[stream
];
1727 dev_dbg(fe
->dev
, "ASoC: runtime %s open on FE %s\n",
1728 stream
? "capture" : "playback", fe
->dai_link
->name
);
1730 /* Only start the BE if the FE is ready */
1731 if (fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_HW_FREE
||
1732 fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_CLOSE
)
1735 /* startup must always be called for new BEs */
1736 ret
= dpcm_be_dai_startup(fe
, stream
);
1740 /* keep going if FE state is > open */
1741 if (fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_OPEN
)
1744 ret
= dpcm_be_dai_hw_params(fe
, stream
);
1748 /* keep going if FE state is > hw_params */
1749 if (fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_HW_PARAMS
)
1753 ret
= dpcm_be_dai_prepare(fe
, stream
);
1757 /* run the stream event for each BE */
1758 dpcm_dapm_stream_event(fe
, stream
, SND_SOC_DAPM_STREAM_NOP
);
1760 /* keep going if FE state is > prepare */
1761 if (fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_PREPARE
||
1762 fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_STOP
)
1765 if (trigger
== SND_SOC_DPCM_TRIGGER_BESPOKE
) {
1766 /* call trigger on the frontend - FE takes care of all BE triggers */
1767 dev_dbg(fe
->dev
, "ASoC: bespoke trigger FE %s cmd start\n",
1768 fe
->dai_link
->name
);
1770 ret
= soc_pcm_bespoke_trigger(substream
, SNDRV_PCM_TRIGGER_START
);
1772 dev_err(fe
->dev
,"ASoC: bespoke trigger FE failed %d\n", ret
);
1776 dev_dbg(fe
->dev
, "ASoC: trigger FE %s cmd start\n",
1777 fe
->dai_link
->name
);
1779 ret
= dpcm_be_dai_trigger(fe
, stream
,
1780 SNDRV_PCM_TRIGGER_START
);
1782 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", ret
);
1790 dpcm_be_dai_hw_free(fe
, stream
);
1792 dpcm_be_dai_shutdown(fe
, stream
);
1794 /* disconnect any non started BEs */
1795 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1796 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1797 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_START
)
1798 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_FREE
;
1804 static int dpcm_run_new_update(struct snd_soc_pcm_runtime
*fe
, int stream
)
1808 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_BE
;
1809 ret
= dpcm_run_update_startup(fe
, stream
);
1811 dev_err(fe
->dev
, "ASoC: failed to startup some BEs\n");
1812 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1817 static int dpcm_run_old_update(struct snd_soc_pcm_runtime
*fe
, int stream
)
1821 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_BE
;
1822 ret
= dpcm_run_update_shutdown(fe
, stream
);
1824 dev_err(fe
->dev
, "ASoC: failed to shutdown some BEs\n");
1825 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
1830 /* Called by DAPM mixer/mux changes to update audio routing between PCMs and
1833 int soc_dpcm_runtime_update(struct snd_soc_dapm_widget
*widget
)
1835 struct snd_soc_card
*card
;
1836 int i
, old
, new, paths
;
1839 card
= widget
->codec
->card
;
1840 else if (widget
->platform
)
1841 card
= widget
->platform
->card
;
1845 mutex_lock_nested(&card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1846 for (i
= 0; i
< card
->num_rtd
; i
++) {
1847 struct snd_soc_dapm_widget_list
*list
;
1848 struct snd_soc_pcm_runtime
*fe
= &card
->rtd
[i
];
1850 /* make sure link is FE */
1851 if (!fe
->dai_link
->dynamic
)
1854 /* only check active links */
1855 if (!fe
->cpu_dai
->active
)
1858 /* DAPM sync will call this to update DSP paths */
1859 dev_dbg(fe
->dev
, "ASoC: DPCM runtime update for FE %s\n",
1860 fe
->dai_link
->name
);
1862 /* skip if FE doesn't have playback capability */
1863 if (!fe
->cpu_dai
->driver
->playback
.channels_min
)
1866 paths
= dpcm_path_get(fe
, SNDRV_PCM_STREAM_PLAYBACK
, &list
);
1868 dev_warn(fe
->dev
, "ASoC: %s no valid %s path\n",
1869 fe
->dai_link
->name
, "playback");
1870 mutex_unlock(&card
->mutex
);
1874 /* update any new playback paths */
1875 new = dpcm_process_paths(fe
, SNDRV_PCM_STREAM_PLAYBACK
, &list
, 1);
1877 dpcm_run_new_update(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
1878 dpcm_clear_pending_state(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
1879 dpcm_be_disconnect(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
1882 /* update any old playback paths */
1883 old
= dpcm_process_paths(fe
, SNDRV_PCM_STREAM_PLAYBACK
, &list
, 0);
1885 dpcm_run_old_update(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
1886 dpcm_clear_pending_state(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
1887 dpcm_be_disconnect(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
1890 dpcm_path_put(&list
);
1892 /* skip if FE doesn't have capture capability */
1893 if (!fe
->cpu_dai
->driver
->capture
.channels_min
)
1896 paths
= dpcm_path_get(fe
, SNDRV_PCM_STREAM_CAPTURE
, &list
);
1898 dev_warn(fe
->dev
, "ASoC: %s no valid %s path\n",
1899 fe
->dai_link
->name
, "capture");
1900 mutex_unlock(&card
->mutex
);
1904 /* update any new capture paths */
1905 new = dpcm_process_paths(fe
, SNDRV_PCM_STREAM_CAPTURE
, &list
, 1);
1907 dpcm_run_new_update(fe
, SNDRV_PCM_STREAM_CAPTURE
);
1908 dpcm_clear_pending_state(fe
, SNDRV_PCM_STREAM_CAPTURE
);
1909 dpcm_be_disconnect(fe
, SNDRV_PCM_STREAM_CAPTURE
);
1912 /* update any old capture paths */
1913 old
= dpcm_process_paths(fe
, SNDRV_PCM_STREAM_CAPTURE
, &list
, 0);
1915 dpcm_run_old_update(fe
, SNDRV_PCM_STREAM_CAPTURE
);
1916 dpcm_clear_pending_state(fe
, SNDRV_PCM_STREAM_CAPTURE
);
1917 dpcm_be_disconnect(fe
, SNDRV_PCM_STREAM_CAPTURE
);
1920 dpcm_path_put(&list
);
1923 mutex_unlock(&card
->mutex
);
1926 int soc_dpcm_be_digital_mute(struct snd_soc_pcm_runtime
*fe
, int mute
)
1928 struct snd_soc_dpcm
*dpcm
;
1929 struct list_head
*clients
=
1930 &fe
->dpcm
[SNDRV_PCM_STREAM_PLAYBACK
].be_clients
;
1932 list_for_each_entry(dpcm
, clients
, list_be
) {
1934 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1935 struct snd_soc_dai
*dai
= be
->codec_dai
;
1936 struct snd_soc_dai_driver
*drv
= dai
->driver
;
1938 if (be
->dai_link
->ignore_suspend
)
1941 dev_dbg(be
->dev
, "ASoC: BE digital mute %s\n", be
->dai_link
->name
);
1943 if (drv
->ops
->digital_mute
&& dai
->playback_active
)
1944 drv
->ops
->digital_mute(dai
, mute
);
1950 static int dpcm_fe_dai_open(struct snd_pcm_substream
*fe_substream
)
1952 struct snd_soc_pcm_runtime
*fe
= fe_substream
->private_data
;
1953 struct snd_soc_dpcm
*dpcm
;
1954 struct snd_soc_dapm_widget_list
*list
;
1956 int stream
= fe_substream
->stream
;
1958 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1959 fe
->dpcm
[stream
].runtime
= fe_substream
->runtime
;
1961 if (dpcm_path_get(fe
, stream
, &list
) <= 0) {
1962 dev_dbg(fe
->dev
, "ASoC: %s no valid %s route\n",
1963 fe
->dai_link
->name
, stream
? "capture" : "playback");
1966 /* calculate valid and active FE <-> BE dpcms */
1967 dpcm_process_paths(fe
, stream
, &list
, 1);
1969 ret
= dpcm_fe_dai_startup(fe_substream
);
1971 /* clean up all links */
1972 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
)
1973 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_FREE
;
1975 dpcm_be_disconnect(fe
, stream
);
1976 fe
->dpcm
[stream
].runtime
= NULL
;
1979 dpcm_clear_pending_state(fe
, stream
);
1980 dpcm_path_put(&list
);
1981 mutex_unlock(&fe
->card
->mutex
);
1985 static int dpcm_fe_dai_close(struct snd_pcm_substream
*fe_substream
)
1987 struct snd_soc_pcm_runtime
*fe
= fe_substream
->private_data
;
1988 struct snd_soc_dpcm
*dpcm
;
1989 int stream
= fe_substream
->stream
, ret
;
1991 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1992 ret
= dpcm_fe_dai_shutdown(fe_substream
);
1994 /* mark FE's links ready to prune */
1995 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
)
1996 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_FREE
;
1998 dpcm_be_disconnect(fe
, stream
);
2000 fe
->dpcm
[stream
].runtime
= NULL
;
2001 mutex_unlock(&fe
->card
->mutex
);
2005 /* create a new pcm */
2006 int soc_new_pcm(struct snd_soc_pcm_runtime
*rtd
, int num
)
2008 struct snd_soc_platform
*platform
= rtd
->platform
;
2009 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
2010 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
2011 struct snd_pcm
*pcm
;
2013 int ret
= 0, playback
= 0, capture
= 0;
2015 if (rtd
->dai_link
->dynamic
|| rtd
->dai_link
->no_pcm
) {
2016 if (cpu_dai
->driver
->playback
.channels_min
)
2018 if (cpu_dai
->driver
->capture
.channels_min
)
2021 if (codec_dai
->driver
->playback
.channels_min
&&
2022 cpu_dai
->driver
->playback
.channels_min
)
2024 if (codec_dai
->driver
->capture
.channels_min
&&
2025 cpu_dai
->driver
->capture
.channels_min
)
2029 /* create the PCM */
2030 if (rtd
->dai_link
->no_pcm
) {
2031 snprintf(new_name
, sizeof(new_name
), "(%s)",
2032 rtd
->dai_link
->stream_name
);
2034 ret
= snd_pcm_new_internal(rtd
->card
->snd_card
, new_name
, num
,
2035 playback
, capture
, &pcm
);
2037 if (rtd
->dai_link
->dynamic
)
2038 snprintf(new_name
, sizeof(new_name
), "%s (*)",
2039 rtd
->dai_link
->stream_name
);
2041 snprintf(new_name
, sizeof(new_name
), "%s %s-%d",
2042 rtd
->dai_link
->stream_name
, codec_dai
->name
, num
);
2044 ret
= snd_pcm_new(rtd
->card
->snd_card
, new_name
, num
, playback
,
2048 dev_err(rtd
->card
->dev
, "ASoC: can't create pcm for %s\n",
2049 rtd
->dai_link
->name
);
2052 dev_dbg(rtd
->card
->dev
, "ASoC: registered pcm #%d %s\n",num
, new_name
);
2054 /* DAPM dai link stream work */
2055 INIT_DELAYED_WORK(&rtd
->delayed_work
, close_delayed_work
);
2058 pcm
->private_data
= rtd
;
2060 if (rtd
->dai_link
->no_pcm
) {
2062 pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
->private_data
= rtd
;
2064 pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
->private_data
= rtd
;
2068 /* ASoC PCM operations */
2069 if (rtd
->dai_link
->dynamic
) {
2070 rtd
->ops
.open
= dpcm_fe_dai_open
;
2071 rtd
->ops
.hw_params
= dpcm_fe_dai_hw_params
;
2072 rtd
->ops
.prepare
= dpcm_fe_dai_prepare
;
2073 rtd
->ops
.trigger
= dpcm_fe_dai_trigger
;
2074 rtd
->ops
.hw_free
= dpcm_fe_dai_hw_free
;
2075 rtd
->ops
.close
= dpcm_fe_dai_close
;
2076 rtd
->ops
.pointer
= soc_pcm_pointer
;
2077 rtd
->ops
.ioctl
= soc_pcm_ioctl
;
2079 rtd
->ops
.open
= soc_pcm_open
;
2080 rtd
->ops
.hw_params
= soc_pcm_hw_params
;
2081 rtd
->ops
.prepare
= soc_pcm_prepare
;
2082 rtd
->ops
.trigger
= soc_pcm_trigger
;
2083 rtd
->ops
.hw_free
= soc_pcm_hw_free
;
2084 rtd
->ops
.close
= soc_pcm_close
;
2085 rtd
->ops
.pointer
= soc_pcm_pointer
;
2086 rtd
->ops
.ioctl
= soc_pcm_ioctl
;
2089 if (platform
->driver
->ops
) {
2090 rtd
->ops
.ack
= platform
->driver
->ops
->ack
;
2091 rtd
->ops
.copy
= platform
->driver
->ops
->copy
;
2092 rtd
->ops
.silence
= platform
->driver
->ops
->silence
;
2093 rtd
->ops
.page
= platform
->driver
->ops
->page
;
2094 rtd
->ops
.mmap
= platform
->driver
->ops
->mmap
;
2098 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &rtd
->ops
);
2101 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &rtd
->ops
);
2103 if (platform
->driver
->pcm_new
) {
2104 ret
= platform
->driver
->pcm_new(rtd
);
2106 dev_err(platform
->dev
,
2107 "ASoC: pcm constructor failed: %d\n",
2113 pcm
->private_free
= platform
->driver
->pcm_free
;
2115 dev_info(rtd
->card
->dev
, " %s <-> %s mapping ok\n", codec_dai
->name
,
2120 /* is the current PCM operation for this FE ? */
2121 int snd_soc_dpcm_fe_can_update(struct snd_soc_pcm_runtime
*fe
, int stream
)
2123 if (fe
->dpcm
[stream
].runtime_update
== SND_SOC_DPCM_UPDATE_FE
)
2127 EXPORT_SYMBOL_GPL(snd_soc_dpcm_fe_can_update
);
2129 /* is the current PCM operation for this BE ? */
2130 int snd_soc_dpcm_be_can_update(struct snd_soc_pcm_runtime
*fe
,
2131 struct snd_soc_pcm_runtime
*be
, int stream
)
2133 if ((fe
->dpcm
[stream
].runtime_update
== SND_SOC_DPCM_UPDATE_FE
) ||
2134 ((fe
->dpcm
[stream
].runtime_update
== SND_SOC_DPCM_UPDATE_BE
) &&
2135 be
->dpcm
[stream
].runtime_update
))
2139 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_can_update
);
2141 /* get the substream for this BE */
2142 struct snd_pcm_substream
*
2143 snd_soc_dpcm_get_substream(struct snd_soc_pcm_runtime
*be
, int stream
)
2145 return be
->pcm
->streams
[stream
].substream
;
2147 EXPORT_SYMBOL_GPL(snd_soc_dpcm_get_substream
);
2149 /* get the BE runtime state */
2150 enum snd_soc_dpcm_state
2151 snd_soc_dpcm_be_get_state(struct snd_soc_pcm_runtime
*be
, int stream
)
2153 return be
->dpcm
[stream
].state
;
2155 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_get_state
);
2157 /* set the BE runtime state */
2158 void snd_soc_dpcm_be_set_state(struct snd_soc_pcm_runtime
*be
,
2159 int stream
, enum snd_soc_dpcm_state state
)
2161 be
->dpcm
[stream
].state
= state
;
2163 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_set_state
);
2166 * We can only hw_free, stop, pause or suspend a BE DAI if any of it's FE
2167 * are not running, paused or suspended for the specified stream direction.
2169 int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime
*fe
,
2170 struct snd_soc_pcm_runtime
*be
, int stream
)
2172 struct snd_soc_dpcm
*dpcm
;
2175 list_for_each_entry(dpcm
, &be
->dpcm
[stream
].fe_clients
, list_fe
) {
2180 state
= dpcm
->fe
->dpcm
[stream
].state
;
2181 if (state
== SND_SOC_DPCM_STATE_START
||
2182 state
== SND_SOC_DPCM_STATE_PAUSED
||
2183 state
== SND_SOC_DPCM_STATE_SUSPEND
)
2187 /* it's safe to free/stop this BE DAI */
2190 EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop
);
2193 * We can only change hw params a BE DAI if any of it's FE are not prepared,
2194 * running, paused or suspended for the specified stream direction.
2196 int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime
*fe
,
2197 struct snd_soc_pcm_runtime
*be
, int stream
)
2199 struct snd_soc_dpcm
*dpcm
;
2202 list_for_each_entry(dpcm
, &be
->dpcm
[stream
].fe_clients
, list_fe
) {
2207 state
= dpcm
->fe
->dpcm
[stream
].state
;
2208 if (state
== SND_SOC_DPCM_STATE_START
||
2209 state
== SND_SOC_DPCM_STATE_PAUSED
||
2210 state
== SND_SOC_DPCM_STATE_SUSPEND
||
2211 state
== SND_SOC_DPCM_STATE_PREPARE
)
2215 /* it's safe to change hw_params */
2218 EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params
);
2220 int snd_soc_platform_trigger(struct snd_pcm_substream
*substream
,
2221 int cmd
, struct snd_soc_platform
*platform
)
2223 if (platform
->driver
->ops
->trigger
)
2224 return platform
->driver
->ops
->trigger(substream
, cmd
);
2227 EXPORT_SYMBOL_GPL(snd_soc_platform_trigger
);
2229 #ifdef CONFIG_DEBUG_FS
2230 static char *dpcm_state_string(enum snd_soc_dpcm_state state
)
2233 case SND_SOC_DPCM_STATE_NEW
:
2235 case SND_SOC_DPCM_STATE_OPEN
:
2237 case SND_SOC_DPCM_STATE_HW_PARAMS
:
2239 case SND_SOC_DPCM_STATE_PREPARE
:
2241 case SND_SOC_DPCM_STATE_START
:
2243 case SND_SOC_DPCM_STATE_STOP
:
2245 case SND_SOC_DPCM_STATE_SUSPEND
:
2247 case SND_SOC_DPCM_STATE_PAUSED
:
2249 case SND_SOC_DPCM_STATE_HW_FREE
:
2251 case SND_SOC_DPCM_STATE_CLOSE
:
2258 static ssize_t
dpcm_show_state(struct snd_soc_pcm_runtime
*fe
,
2259 int stream
, char *buf
, size_t size
)
2261 struct snd_pcm_hw_params
*params
= &fe
->dpcm
[stream
].hw_params
;
2262 struct snd_soc_dpcm
*dpcm
;
2266 offset
+= snprintf(buf
+ offset
, size
- offset
,
2267 "[%s - %s]\n", fe
->dai_link
->name
,
2268 stream
? "Capture" : "Playback");
2270 offset
+= snprintf(buf
+ offset
, size
- offset
, "State: %s\n",
2271 dpcm_state_string(fe
->dpcm
[stream
].state
));
2273 if ((fe
->dpcm
[stream
].state
>= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
2274 (fe
->dpcm
[stream
].state
<= SND_SOC_DPCM_STATE_STOP
))
2275 offset
+= snprintf(buf
+ offset
, size
- offset
,
2277 "Format = %s, Channels = %d, Rate = %d\n",
2278 snd_pcm_format_name(params_format(params
)),
2279 params_channels(params
),
2280 params_rate(params
));
2283 offset
+= snprintf(buf
+ offset
, size
- offset
, "Backends:\n");
2285 if (list_empty(&fe
->dpcm
[stream
].be_clients
)) {
2286 offset
+= snprintf(buf
+ offset
, size
- offset
,
2287 " No active DSP links\n");
2291 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
2292 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
2293 params
= &dpcm
->hw_params
;
2295 offset
+= snprintf(buf
+ offset
, size
- offset
,
2296 "- %s\n", be
->dai_link
->name
);
2298 offset
+= snprintf(buf
+ offset
, size
- offset
,
2300 dpcm_state_string(be
->dpcm
[stream
].state
));
2302 if ((be
->dpcm
[stream
].state
>= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
2303 (be
->dpcm
[stream
].state
<= SND_SOC_DPCM_STATE_STOP
))
2304 offset
+= snprintf(buf
+ offset
, size
- offset
,
2305 " Hardware Params: "
2306 "Format = %s, Channels = %d, Rate = %d\n",
2307 snd_pcm_format_name(params_format(params
)),
2308 params_channels(params
),
2309 params_rate(params
));
2316 static ssize_t
dpcm_state_read_file(struct file
*file
, char __user
*user_buf
,
2317 size_t count
, loff_t
*ppos
)
2319 struct snd_soc_pcm_runtime
*fe
= file
->private_data
;
2320 ssize_t out_count
= PAGE_SIZE
, offset
= 0, ret
= 0;
2323 buf
= kmalloc(out_count
, GFP_KERNEL
);
2327 if (fe
->cpu_dai
->driver
->playback
.channels_min
)
2328 offset
+= dpcm_show_state(fe
, SNDRV_PCM_STREAM_PLAYBACK
,
2329 buf
+ offset
, out_count
- offset
);
2331 if (fe
->cpu_dai
->driver
->capture
.channels_min
)
2332 offset
+= dpcm_show_state(fe
, SNDRV_PCM_STREAM_CAPTURE
,
2333 buf
+ offset
, out_count
- offset
);
2335 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, offset
);
2341 static const struct file_operations dpcm_state_fops
= {
2342 .open
= simple_open
,
2343 .read
= dpcm_state_read_file
,
2344 .llseek
= default_llseek
,
2347 int soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime
*rtd
)
2352 rtd
->debugfs_dpcm_root
= debugfs_create_dir(rtd
->dai_link
->name
,
2353 rtd
->card
->debugfs_card_root
);
2354 if (!rtd
->debugfs_dpcm_root
) {
2356 "ASoC: Failed to create dpcm debugfs directory %s\n",
2357 rtd
->dai_link
->name
);
2361 rtd
->debugfs_dpcm_state
= debugfs_create_file("state", 0444,
2362 rtd
->debugfs_dpcm_root
,
2363 rtd
, &dpcm_state_fops
);