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/pinctrl/consumer.h>
23 #include <linux/pm_runtime.h>
24 #include <linux/slab.h>
25 #include <linux/workqueue.h>
26 #include <linux/export.h>
27 #include <linux/debugfs.h>
28 #include <sound/core.h>
29 #include <sound/pcm.h>
30 #include <sound/pcm_params.h>
31 #include <sound/soc.h>
32 #include <sound/soc-dpcm.h>
33 #include <sound/initval.h>
35 #define DPCM_MAX_BE_USERS 8
38 * snd_soc_dai_stream_valid() - check if a DAI supports the given stream
40 * Returns true if the DAI supports the indicated stream type.
42 static bool snd_soc_dai_stream_valid(struct snd_soc_dai
*dai
, int stream
)
44 struct snd_soc_pcm_stream
*codec_stream
;
46 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
)
47 codec_stream
= &dai
->driver
->playback
;
49 codec_stream
= &dai
->driver
->capture
;
51 /* If the codec specifies any rate at all, it supports the stream. */
52 return codec_stream
->rates
;
56 * snd_soc_runtime_activate() - Increment active count for PCM runtime components
57 * @rtd: ASoC PCM runtime that is activated
58 * @stream: Direction of the PCM stream
60 * Increments the active count for all the DAIs and components attached to a PCM
61 * runtime. Should typically be called when a stream is opened.
63 * Must be called with the rtd->pcm_mutex being held
65 void snd_soc_runtime_activate(struct snd_soc_pcm_runtime
*rtd
, int stream
)
67 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
70 lockdep_assert_held(&rtd
->pcm_mutex
);
72 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
73 cpu_dai
->playback_active
++;
74 for (i
= 0; i
< rtd
->num_codecs
; i
++)
75 rtd
->codec_dais
[i
]->playback_active
++;
77 cpu_dai
->capture_active
++;
78 for (i
= 0; i
< rtd
->num_codecs
; i
++)
79 rtd
->codec_dais
[i
]->capture_active
++;
83 cpu_dai
->component
->active
++;
84 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
85 rtd
->codec_dais
[i
]->active
++;
86 rtd
->codec_dais
[i
]->component
->active
++;
91 * snd_soc_runtime_deactivate() - Decrement active count for PCM runtime components
92 * @rtd: ASoC PCM runtime that is deactivated
93 * @stream: Direction of the PCM stream
95 * Decrements the active count for all the DAIs and components attached to a PCM
96 * runtime. Should typically be called when a stream is closed.
98 * Must be called with the rtd->pcm_mutex being held
100 void snd_soc_runtime_deactivate(struct snd_soc_pcm_runtime
*rtd
, int stream
)
102 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
105 lockdep_assert_held(&rtd
->pcm_mutex
);
107 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
108 cpu_dai
->playback_active
--;
109 for (i
= 0; i
< rtd
->num_codecs
; i
++)
110 rtd
->codec_dais
[i
]->playback_active
--;
112 cpu_dai
->capture_active
--;
113 for (i
= 0; i
< rtd
->num_codecs
; i
++)
114 rtd
->codec_dais
[i
]->capture_active
--;
118 cpu_dai
->component
->active
--;
119 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
120 rtd
->codec_dais
[i
]->component
->active
--;
121 rtd
->codec_dais
[i
]->active
--;
126 * snd_soc_runtime_ignore_pmdown_time() - Check whether to ignore the power down delay
127 * @rtd: The ASoC PCM runtime that should be checked.
129 * This function checks whether the power down delay should be ignored for a
130 * specific PCM runtime. Returns true if the delay is 0, if it the DAI link has
131 * been configured to ignore the delay, or if none of the components benefits
132 * from having the delay.
134 bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime
*rtd
)
139 if (!rtd
->pmdown_time
|| rtd
->dai_link
->ignore_pmdown_time
)
142 for (i
= 0; i
< rtd
->num_codecs
; i
++)
143 ignore
&= rtd
->codec_dais
[i
]->component
->ignore_pmdown_time
;
145 return rtd
->cpu_dai
->component
->ignore_pmdown_time
&& ignore
;
149 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
150 * @substream: the pcm substream
151 * @hw: the hardware parameters
153 * Sets the substream runtime hardware parameters.
155 int snd_soc_set_runtime_hwparams(struct snd_pcm_substream
*substream
,
156 const struct snd_pcm_hardware
*hw
)
158 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
159 runtime
->hw
.info
= hw
->info
;
160 runtime
->hw
.formats
= hw
->formats
;
161 runtime
->hw
.period_bytes_min
= hw
->period_bytes_min
;
162 runtime
->hw
.period_bytes_max
= hw
->period_bytes_max
;
163 runtime
->hw
.periods_min
= hw
->periods_min
;
164 runtime
->hw
.periods_max
= hw
->periods_max
;
165 runtime
->hw
.buffer_bytes_max
= hw
->buffer_bytes_max
;
166 runtime
->hw
.fifo_size
= hw
->fifo_size
;
169 EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams
);
171 /* DPCM stream event, send event to FE and all active BEs. */
172 int dpcm_dapm_stream_event(struct snd_soc_pcm_runtime
*fe
, int dir
,
175 struct snd_soc_dpcm
*dpcm
;
177 list_for_each_entry(dpcm
, &fe
->dpcm
[dir
].be_clients
, list_be
) {
179 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
181 dev_dbg(be
->dev
, "ASoC: BE %s event %d dir %d\n",
182 be
->dai_link
->name
, event
, dir
);
184 if ((event
== SND_SOC_DAPM_STREAM_STOP
) &&
185 (be
->dpcm
[dir
].users
>= 1))
188 snd_soc_dapm_stream_event(be
, dir
, event
);
191 snd_soc_dapm_stream_event(fe
, dir
, event
);
196 static int soc_pcm_apply_symmetry(struct snd_pcm_substream
*substream
,
197 struct snd_soc_dai
*soc_dai
)
199 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
202 if (soc_dai
->rate
&& (soc_dai
->driver
->symmetric_rates
||
203 rtd
->dai_link
->symmetric_rates
)) {
204 dev_dbg(soc_dai
->dev
, "ASoC: Symmetry forces %dHz rate\n",
207 ret
= snd_pcm_hw_constraint_single(substream
->runtime
,
208 SNDRV_PCM_HW_PARAM_RATE
,
211 dev_err(soc_dai
->dev
,
212 "ASoC: Unable to apply rate constraint: %d\n",
218 if (soc_dai
->channels
&& (soc_dai
->driver
->symmetric_channels
||
219 rtd
->dai_link
->symmetric_channels
)) {
220 dev_dbg(soc_dai
->dev
, "ASoC: Symmetry forces %d channel(s)\n",
223 ret
= snd_pcm_hw_constraint_single(substream
->runtime
,
224 SNDRV_PCM_HW_PARAM_CHANNELS
,
227 dev_err(soc_dai
->dev
,
228 "ASoC: Unable to apply channel symmetry constraint: %d\n",
234 if (soc_dai
->sample_bits
&& (soc_dai
->driver
->symmetric_samplebits
||
235 rtd
->dai_link
->symmetric_samplebits
)) {
236 dev_dbg(soc_dai
->dev
, "ASoC: Symmetry forces %d sample bits\n",
237 soc_dai
->sample_bits
);
239 ret
= snd_pcm_hw_constraint_single(substream
->runtime
,
240 SNDRV_PCM_HW_PARAM_SAMPLE_BITS
,
241 soc_dai
->sample_bits
);
243 dev_err(soc_dai
->dev
,
244 "ASoC: Unable to apply sample bits symmetry constraint: %d\n",
253 static int soc_pcm_params_symmetry(struct snd_pcm_substream
*substream
,
254 struct snd_pcm_hw_params
*params
)
256 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
257 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
258 unsigned int rate
, channels
, sample_bits
, symmetry
, i
;
260 rate
= params_rate(params
);
261 channels
= params_channels(params
);
262 sample_bits
= snd_pcm_format_physical_width(params_format(params
));
264 /* reject unmatched parameters when applying symmetry */
265 symmetry
= cpu_dai
->driver
->symmetric_rates
||
266 rtd
->dai_link
->symmetric_rates
;
268 for (i
= 0; i
< rtd
->num_codecs
; i
++)
269 symmetry
|= rtd
->codec_dais
[i
]->driver
->symmetric_rates
;
271 if (symmetry
&& cpu_dai
->rate
&& cpu_dai
->rate
!= rate
) {
272 dev_err(rtd
->dev
, "ASoC: unmatched rate symmetry: %d - %d\n",
273 cpu_dai
->rate
, rate
);
277 symmetry
= cpu_dai
->driver
->symmetric_channels
||
278 rtd
->dai_link
->symmetric_channels
;
280 for (i
= 0; i
< rtd
->num_codecs
; i
++)
281 symmetry
|= rtd
->codec_dais
[i
]->driver
->symmetric_channels
;
283 if (symmetry
&& cpu_dai
->channels
&& cpu_dai
->channels
!= channels
) {
284 dev_err(rtd
->dev
, "ASoC: unmatched channel symmetry: %d - %d\n",
285 cpu_dai
->channels
, channels
);
289 symmetry
= cpu_dai
->driver
->symmetric_samplebits
||
290 rtd
->dai_link
->symmetric_samplebits
;
292 for (i
= 0; i
< rtd
->num_codecs
; i
++)
293 symmetry
|= rtd
->codec_dais
[i
]->driver
->symmetric_samplebits
;
295 if (symmetry
&& cpu_dai
->sample_bits
&& cpu_dai
->sample_bits
!= sample_bits
) {
296 dev_err(rtd
->dev
, "ASoC: unmatched sample bits symmetry: %d - %d\n",
297 cpu_dai
->sample_bits
, sample_bits
);
304 static bool soc_pcm_has_symmetry(struct snd_pcm_substream
*substream
)
306 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
307 struct snd_soc_dai_driver
*cpu_driver
= rtd
->cpu_dai
->driver
;
308 struct snd_soc_dai_link
*link
= rtd
->dai_link
;
309 unsigned int symmetry
, i
;
311 symmetry
= cpu_driver
->symmetric_rates
|| link
->symmetric_rates
||
312 cpu_driver
->symmetric_channels
|| link
->symmetric_channels
||
313 cpu_driver
->symmetric_samplebits
|| link
->symmetric_samplebits
;
315 for (i
= 0; i
< rtd
->num_codecs
; i
++)
316 symmetry
= symmetry
||
317 rtd
->codec_dais
[i
]->driver
->symmetric_rates
||
318 rtd
->codec_dais
[i
]->driver
->symmetric_channels
||
319 rtd
->codec_dais
[i
]->driver
->symmetric_samplebits
;
324 static void soc_pcm_set_msb(struct snd_pcm_substream
*substream
, int bits
)
326 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
332 ret
= snd_pcm_hw_constraint_msbits(substream
->runtime
, 0, 0, bits
);
334 dev_warn(rtd
->dev
, "ASoC: Failed to set MSB %d: %d\n",
338 static void soc_pcm_apply_msb(struct snd_pcm_substream
*substream
)
340 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
341 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
342 struct snd_soc_dai
*codec_dai
;
344 unsigned int bits
= 0, cpu_bits
;
346 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
347 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
348 codec_dai
= rtd
->codec_dais
[i
];
349 if (codec_dai
->driver
->playback
.sig_bits
== 0) {
353 bits
= max(codec_dai
->driver
->playback
.sig_bits
, bits
);
355 cpu_bits
= cpu_dai
->driver
->playback
.sig_bits
;
357 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
358 codec_dai
= rtd
->codec_dais
[i
];
359 if (codec_dai
->driver
->capture
.sig_bits
== 0) {
363 bits
= max(codec_dai
->driver
->capture
.sig_bits
, bits
);
365 cpu_bits
= cpu_dai
->driver
->capture
.sig_bits
;
368 soc_pcm_set_msb(substream
, bits
);
369 soc_pcm_set_msb(substream
, cpu_bits
);
372 static void soc_pcm_init_runtime_hw(struct snd_pcm_substream
*substream
)
374 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
375 struct snd_pcm_hardware
*hw
= &runtime
->hw
;
376 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
377 struct snd_soc_dai_driver
*cpu_dai_drv
= rtd
->cpu_dai
->driver
;
378 struct snd_soc_dai_driver
*codec_dai_drv
;
379 struct snd_soc_pcm_stream
*codec_stream
;
380 struct snd_soc_pcm_stream
*cpu_stream
;
381 unsigned int chan_min
= 0, chan_max
= UINT_MAX
;
382 unsigned int rate_min
= 0, rate_max
= UINT_MAX
;
383 unsigned int rates
= UINT_MAX
;
384 u64 formats
= ULLONG_MAX
;
387 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
388 cpu_stream
= &cpu_dai_drv
->playback
;
390 cpu_stream
= &cpu_dai_drv
->capture
;
392 /* first calculate min/max only for CODECs in the DAI link */
393 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
396 * Skip CODECs which don't support the current stream type.
397 * Otherwise, since the rate, channel, and format values will
398 * zero in that case, we would have no usable settings left,
399 * causing the resulting setup to fail.
400 * At least one CODEC should match, otherwise we should have
401 * bailed out on a higher level, since there would be no
402 * CODEC to support the transfer direction in that case.
404 if (!snd_soc_dai_stream_valid(rtd
->codec_dais
[i
],
408 codec_dai_drv
= rtd
->codec_dais
[i
]->driver
;
409 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
410 codec_stream
= &codec_dai_drv
->playback
;
412 codec_stream
= &codec_dai_drv
->capture
;
413 chan_min
= max(chan_min
, codec_stream
->channels_min
);
414 chan_max
= min(chan_max
, codec_stream
->channels_max
);
415 rate_min
= max(rate_min
, codec_stream
->rate_min
);
416 rate_max
= min_not_zero(rate_max
, codec_stream
->rate_max
);
417 formats
&= codec_stream
->formats
;
418 rates
= snd_pcm_rate_mask_intersect(codec_stream
->rates
, rates
);
422 * chan min/max cannot be enforced if there are multiple CODEC DAIs
423 * connected to a single CPU DAI, use CPU DAI's directly and let
424 * channel allocation be fixed up later
426 if (rtd
->num_codecs
> 1) {
427 chan_min
= cpu_stream
->channels_min
;
428 chan_max
= cpu_stream
->channels_max
;
431 hw
->channels_min
= max(chan_min
, cpu_stream
->channels_min
);
432 hw
->channels_max
= min(chan_max
, cpu_stream
->channels_max
);
434 hw
->formats
&= formats
& cpu_stream
->formats
;
436 hw
->formats
= formats
& cpu_stream
->formats
;
437 hw
->rates
= snd_pcm_rate_mask_intersect(rates
, cpu_stream
->rates
);
439 snd_pcm_limit_hw_rates(runtime
);
441 hw
->rate_min
= max(hw
->rate_min
, cpu_stream
->rate_min
);
442 hw
->rate_min
= max(hw
->rate_min
, rate_min
);
443 hw
->rate_max
= min_not_zero(hw
->rate_max
, cpu_stream
->rate_max
);
444 hw
->rate_max
= min_not_zero(hw
->rate_max
, rate_max
);
448 * Called by ALSA when a PCM substream is opened, the runtime->hw record is
449 * then initialized and any private data can be allocated. This also calls
450 * startup for the cpu DAI, platform, machine and codec DAI.
452 static int soc_pcm_open(struct snd_pcm_substream
*substream
)
454 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
455 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
456 struct snd_soc_platform
*platform
= rtd
->platform
;
457 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
458 struct snd_soc_dai
*codec_dai
;
459 const char *codec_dai_name
= "multicodec";
462 pinctrl_pm_select_default_state(cpu_dai
->dev
);
463 for (i
= 0; i
< rtd
->num_codecs
; i
++)
464 pinctrl_pm_select_default_state(rtd
->codec_dais
[i
]->dev
);
465 pm_runtime_get_sync(cpu_dai
->dev
);
466 for (i
= 0; i
< rtd
->num_codecs
; i
++)
467 pm_runtime_get_sync(rtd
->codec_dais
[i
]->dev
);
468 pm_runtime_get_sync(platform
->dev
);
470 mutex_lock_nested(&rtd
->pcm_mutex
, rtd
->pcm_subclass
);
472 /* startup the audio subsystem */
473 if (cpu_dai
->driver
->ops
&& cpu_dai
->driver
->ops
->startup
) {
474 ret
= cpu_dai
->driver
->ops
->startup(substream
, cpu_dai
);
476 dev_err(cpu_dai
->dev
, "ASoC: can't open interface"
477 " %s: %d\n", cpu_dai
->name
, ret
);
482 if (platform
->driver
->ops
&& platform
->driver
->ops
->open
) {
483 ret
= platform
->driver
->ops
->open(substream
);
485 dev_err(platform
->dev
, "ASoC: can't open platform"
486 " %s: %d\n", platform
->component
.name
, ret
);
491 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
492 codec_dai
= rtd
->codec_dais
[i
];
493 if (codec_dai
->driver
->ops
&& codec_dai
->driver
->ops
->startup
) {
494 ret
= codec_dai
->driver
->ops
->startup(substream
,
497 dev_err(codec_dai
->dev
,
498 "ASoC: can't open codec %s: %d\n",
499 codec_dai
->name
, ret
);
504 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
505 codec_dai
->tx_mask
= 0;
507 codec_dai
->rx_mask
= 0;
510 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->startup
) {
511 ret
= rtd
->dai_link
->ops
->startup(substream
);
513 pr_err("ASoC: %s startup failed: %d\n",
514 rtd
->dai_link
->name
, ret
);
519 /* Dynamic PCM DAI links compat checks use dynamic capabilities */
520 if (rtd
->dai_link
->dynamic
|| rtd
->dai_link
->no_pcm
)
523 /* Check that the codec and cpu DAIs are compatible */
524 soc_pcm_init_runtime_hw(substream
);
526 if (rtd
->num_codecs
== 1)
527 codec_dai_name
= rtd
->codec_dai
->name
;
529 if (soc_pcm_has_symmetry(substream
))
530 runtime
->hw
.info
|= SNDRV_PCM_INFO_JOINT_DUPLEX
;
533 if (!runtime
->hw
.rates
) {
534 printk(KERN_ERR
"ASoC: %s <-> %s No matching rates\n",
535 codec_dai_name
, cpu_dai
->name
);
538 if (!runtime
->hw
.formats
) {
539 printk(KERN_ERR
"ASoC: %s <-> %s No matching formats\n",
540 codec_dai_name
, cpu_dai
->name
);
543 if (!runtime
->hw
.channels_min
|| !runtime
->hw
.channels_max
||
544 runtime
->hw
.channels_min
> runtime
->hw
.channels_max
) {
545 printk(KERN_ERR
"ASoC: %s <-> %s No matching channels\n",
546 codec_dai_name
, cpu_dai
->name
);
550 soc_pcm_apply_msb(substream
);
552 /* Symmetry only applies if we've already got an active stream. */
553 if (cpu_dai
->active
) {
554 ret
= soc_pcm_apply_symmetry(substream
, cpu_dai
);
559 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
560 if (rtd
->codec_dais
[i
]->active
) {
561 ret
= soc_pcm_apply_symmetry(substream
,
568 pr_debug("ASoC: %s <-> %s info:\n",
569 codec_dai_name
, cpu_dai
->name
);
570 pr_debug("ASoC: rate mask 0x%x\n", runtime
->hw
.rates
);
571 pr_debug("ASoC: min ch %d max ch %d\n", runtime
->hw
.channels_min
,
572 runtime
->hw
.channels_max
);
573 pr_debug("ASoC: min rate %d max rate %d\n", runtime
->hw
.rate_min
,
574 runtime
->hw
.rate_max
);
578 snd_soc_runtime_activate(rtd
, substream
->stream
);
580 mutex_unlock(&rtd
->pcm_mutex
);
584 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->shutdown
)
585 rtd
->dai_link
->ops
->shutdown(substream
);
592 codec_dai
= rtd
->codec_dais
[i
];
593 if (codec_dai
->driver
->ops
->shutdown
)
594 codec_dai
->driver
->ops
->shutdown(substream
, codec_dai
);
597 if (platform
->driver
->ops
&& platform
->driver
->ops
->close
)
598 platform
->driver
->ops
->close(substream
);
601 if (cpu_dai
->driver
->ops
->shutdown
)
602 cpu_dai
->driver
->ops
->shutdown(substream
, cpu_dai
);
604 mutex_unlock(&rtd
->pcm_mutex
);
606 pm_runtime_mark_last_busy(platform
->dev
);
607 pm_runtime_put_autosuspend(platform
->dev
);
608 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
609 pm_runtime_mark_last_busy(rtd
->codec_dais
[i
]->dev
);
610 pm_runtime_put_autosuspend(rtd
->codec_dais
[i
]->dev
);
613 pm_runtime_mark_last_busy(cpu_dai
->dev
);
614 pm_runtime_put_autosuspend(cpu_dai
->dev
);
615 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
616 if (!rtd
->codec_dais
[i
]->active
)
617 pinctrl_pm_select_sleep_state(rtd
->codec_dais
[i
]->dev
);
619 if (!cpu_dai
->active
)
620 pinctrl_pm_select_sleep_state(cpu_dai
->dev
);
626 * Power down the audio subsystem pmdown_time msecs after close is called.
627 * This is to ensure there are no pops or clicks in between any music tracks
628 * due to DAPM power cycling.
630 static void close_delayed_work(struct work_struct
*work
)
632 struct snd_soc_pcm_runtime
*rtd
=
633 container_of(work
, struct snd_soc_pcm_runtime
, delayed_work
.work
);
634 struct snd_soc_dai
*codec_dai
= rtd
->codec_dais
[0];
636 mutex_lock_nested(&rtd
->pcm_mutex
, rtd
->pcm_subclass
);
638 dev_dbg(rtd
->dev
, "ASoC: pop wq checking: %s status: %s waiting: %s\n",
639 codec_dai
->driver
->playback
.stream_name
,
640 codec_dai
->playback_active
? "active" : "inactive",
641 rtd
->pop_wait
? "yes" : "no");
643 /* are we waiting on this codec DAI stream */
644 if (rtd
->pop_wait
== 1) {
646 snd_soc_dapm_stream_event(rtd
, SNDRV_PCM_STREAM_PLAYBACK
,
647 SND_SOC_DAPM_STREAM_STOP
);
650 mutex_unlock(&rtd
->pcm_mutex
);
654 * Called by ALSA when a PCM substream is closed. Private data can be
655 * freed here. The cpu DAI, codec DAI, machine and platform are also
658 static int soc_pcm_close(struct snd_pcm_substream
*substream
)
660 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
661 struct snd_soc_platform
*platform
= rtd
->platform
;
662 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
663 struct snd_soc_dai
*codec_dai
;
666 mutex_lock_nested(&rtd
->pcm_mutex
, rtd
->pcm_subclass
);
668 snd_soc_runtime_deactivate(rtd
, substream
->stream
);
670 /* clear the corresponding DAIs rate when inactive */
671 if (!cpu_dai
->active
)
674 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
675 codec_dai
= rtd
->codec_dais
[i
];
676 if (!codec_dai
->active
)
680 snd_soc_dai_digital_mute(cpu_dai
, 1, substream
->stream
);
682 if (cpu_dai
->driver
->ops
->shutdown
)
683 cpu_dai
->driver
->ops
->shutdown(substream
, cpu_dai
);
685 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
686 codec_dai
= rtd
->codec_dais
[i
];
687 if (codec_dai
->driver
->ops
->shutdown
)
688 codec_dai
->driver
->ops
->shutdown(substream
, codec_dai
);
691 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->shutdown
)
692 rtd
->dai_link
->ops
->shutdown(substream
);
694 if (platform
->driver
->ops
&& platform
->driver
->ops
->close
)
695 platform
->driver
->ops
->close(substream
);
697 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
698 if (snd_soc_runtime_ignore_pmdown_time(rtd
)) {
699 /* powered down playback stream now */
700 snd_soc_dapm_stream_event(rtd
,
701 SNDRV_PCM_STREAM_PLAYBACK
,
702 SND_SOC_DAPM_STREAM_STOP
);
704 /* start delayed pop wq here for playback streams */
706 queue_delayed_work(system_power_efficient_wq
,
708 msecs_to_jiffies(rtd
->pmdown_time
));
711 /* capture streams can be powered down now */
712 snd_soc_dapm_stream_event(rtd
, SNDRV_PCM_STREAM_CAPTURE
,
713 SND_SOC_DAPM_STREAM_STOP
);
716 mutex_unlock(&rtd
->pcm_mutex
);
718 pm_runtime_mark_last_busy(platform
->dev
);
719 pm_runtime_put_autosuspend(platform
->dev
);
721 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
722 pm_runtime_mark_last_busy(rtd
->codec_dais
[i
]->dev
);
723 pm_runtime_put_autosuspend(rtd
->codec_dais
[i
]->dev
);
726 pm_runtime_mark_last_busy(cpu_dai
->dev
);
727 pm_runtime_put_autosuspend(cpu_dai
->dev
);
729 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
730 if (!rtd
->codec_dais
[i
]->active
)
731 pinctrl_pm_select_sleep_state(rtd
->codec_dais
[i
]->dev
);
733 if (!cpu_dai
->active
)
734 pinctrl_pm_select_sleep_state(cpu_dai
->dev
);
740 * Called by ALSA when the PCM substream is prepared, can set format, sample
741 * rate, etc. This function is non atomic and can be called multiple times,
742 * it can refer to the runtime info.
744 static int soc_pcm_prepare(struct snd_pcm_substream
*substream
)
746 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
747 struct snd_soc_platform
*platform
= rtd
->platform
;
748 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
749 struct snd_soc_dai
*codec_dai
;
752 mutex_lock_nested(&rtd
->pcm_mutex
, rtd
->pcm_subclass
);
754 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->prepare
) {
755 ret
= rtd
->dai_link
->ops
->prepare(substream
);
757 dev_err(rtd
->card
->dev
, "ASoC: machine prepare error:"
763 if (platform
->driver
->ops
&& platform
->driver
->ops
->prepare
) {
764 ret
= platform
->driver
->ops
->prepare(substream
);
766 dev_err(platform
->dev
, "ASoC: platform prepare error:"
772 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
773 codec_dai
= rtd
->codec_dais
[i
];
774 if (codec_dai
->driver
->ops
&& codec_dai
->driver
->ops
->prepare
) {
775 ret
= codec_dai
->driver
->ops
->prepare(substream
,
778 dev_err(codec_dai
->dev
,
779 "ASoC: codec DAI prepare error: %d\n",
786 if (cpu_dai
->driver
->ops
&& cpu_dai
->driver
->ops
->prepare
) {
787 ret
= cpu_dai
->driver
->ops
->prepare(substream
, cpu_dai
);
789 dev_err(cpu_dai
->dev
,
790 "ASoC: cpu DAI prepare error: %d\n", ret
);
795 /* cancel any delayed stream shutdown that is pending */
796 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
&&
799 cancel_delayed_work(&rtd
->delayed_work
);
802 snd_soc_dapm_stream_event(rtd
, substream
->stream
,
803 SND_SOC_DAPM_STREAM_START
);
805 for (i
= 0; i
< rtd
->num_codecs
; i
++)
806 snd_soc_dai_digital_mute(rtd
->codec_dais
[i
], 0,
808 snd_soc_dai_digital_mute(cpu_dai
, 0, substream
->stream
);
811 mutex_unlock(&rtd
->pcm_mutex
);
815 static void soc_pcm_codec_params_fixup(struct snd_pcm_hw_params
*params
,
818 struct snd_interval
*interval
;
819 int channels
= hweight_long(mask
);
821 interval
= hw_param_interval(params
, SNDRV_PCM_HW_PARAM_CHANNELS
);
822 interval
->min
= channels
;
823 interval
->max
= channels
;
826 int soc_dai_hw_params(struct snd_pcm_substream
*substream
,
827 struct snd_pcm_hw_params
*params
,
828 struct snd_soc_dai
*dai
)
832 if (dai
->driver
->ops
&& dai
->driver
->ops
->hw_params
) {
833 ret
= dai
->driver
->ops
->hw_params(substream
, params
, dai
);
835 dev_err(dai
->dev
, "ASoC: can't set %s hw params: %d\n",
845 * Called by ALSA when the hardware params are set by application. This
846 * function can also be called multiple times and can allocate buffers
847 * (using snd_pcm_lib_* ). It's non-atomic.
849 static int soc_pcm_hw_params(struct snd_pcm_substream
*substream
,
850 struct snd_pcm_hw_params
*params
)
852 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
853 struct snd_soc_platform
*platform
= rtd
->platform
;
854 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
857 mutex_lock_nested(&rtd
->pcm_mutex
, rtd
->pcm_subclass
);
859 ret
= soc_pcm_params_symmetry(substream
, params
);
863 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->hw_params
) {
864 ret
= rtd
->dai_link
->ops
->hw_params(substream
, params
);
866 dev_err(rtd
->card
->dev
, "ASoC: machine hw_params"
867 " failed: %d\n", ret
);
872 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
873 struct snd_soc_dai
*codec_dai
= rtd
->codec_dais
[i
];
874 struct snd_pcm_hw_params codec_params
;
877 * Skip CODECs which don't support the current stream type,
878 * the idea being that if a CODEC is not used for the currently
879 * set up transfer direction, it should not need to be
880 * configured, especially since the configuration used might
881 * not even be supported by that CODEC. There may be cases
882 * however where a CODEC needs to be set up although it is
883 * actually not being used for the transfer, e.g. if a
884 * capture-only CODEC is acting as an LRCLK and/or BCLK master
885 * for the DAI link including a playback-only CODEC.
886 * If this becomes necessary, we will have to augment the
887 * machine driver setup with information on how to act, so
888 * we can do the right thing here.
890 if (!snd_soc_dai_stream_valid(codec_dai
, substream
->stream
))
893 /* copy params for each codec */
894 codec_params
= *params
;
896 /* fixup params based on TDM slot masks */
897 if (codec_dai
->tx_mask
)
898 soc_pcm_codec_params_fixup(&codec_params
,
900 if (codec_dai
->rx_mask
)
901 soc_pcm_codec_params_fixup(&codec_params
,
904 ret
= soc_dai_hw_params(substream
, &codec_params
, codec_dai
);
908 codec_dai
->rate
= params_rate(&codec_params
);
909 codec_dai
->channels
= params_channels(&codec_params
);
910 codec_dai
->sample_bits
= snd_pcm_format_physical_width(
911 params_format(&codec_params
));
914 ret
= soc_dai_hw_params(substream
, params
, cpu_dai
);
918 if (platform
->driver
->ops
&& platform
->driver
->ops
->hw_params
) {
919 ret
= platform
->driver
->ops
->hw_params(substream
, params
);
921 dev_err(platform
->dev
, "ASoC: %s hw params failed: %d\n",
922 platform
->component
.name
, ret
);
927 /* store the parameters for each DAIs */
928 cpu_dai
->rate
= params_rate(params
);
929 cpu_dai
->channels
= params_channels(params
);
930 cpu_dai
->sample_bits
=
931 snd_pcm_format_physical_width(params_format(params
));
934 mutex_unlock(&rtd
->pcm_mutex
);
938 if (cpu_dai
->driver
->ops
&& cpu_dai
->driver
->ops
->hw_free
)
939 cpu_dai
->driver
->ops
->hw_free(substream
, cpu_dai
);
946 struct snd_soc_dai
*codec_dai
= rtd
->codec_dais
[i
];
947 if (codec_dai
->driver
->ops
&& codec_dai
->driver
->ops
->hw_free
)
948 codec_dai
->driver
->ops
->hw_free(substream
, codec_dai
);
952 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->hw_free
)
953 rtd
->dai_link
->ops
->hw_free(substream
);
955 mutex_unlock(&rtd
->pcm_mutex
);
960 * Frees resources allocated by hw_params, can be called multiple times
962 static int soc_pcm_hw_free(struct snd_pcm_substream
*substream
)
964 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
965 struct snd_soc_platform
*platform
= rtd
->platform
;
966 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
967 struct snd_soc_dai
*codec_dai
;
968 bool playback
= substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
;
971 mutex_lock_nested(&rtd
->pcm_mutex
, rtd
->pcm_subclass
);
973 /* clear the corresponding DAIs parameters when going to be inactive */
974 if (cpu_dai
->active
== 1) {
976 cpu_dai
->channels
= 0;
977 cpu_dai
->sample_bits
= 0;
980 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
981 codec_dai
= rtd
->codec_dais
[i
];
982 if (codec_dai
->active
== 1) {
984 codec_dai
->channels
= 0;
985 codec_dai
->sample_bits
= 0;
989 /* apply codec digital mute */
990 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
991 if ((playback
&& rtd
->codec_dais
[i
]->playback_active
== 1) ||
992 (!playback
&& rtd
->codec_dais
[i
]->capture_active
== 1))
993 snd_soc_dai_digital_mute(rtd
->codec_dais
[i
], 1,
997 /* free any machine hw params */
998 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->hw_free
)
999 rtd
->dai_link
->ops
->hw_free(substream
);
1001 /* free any DMA resources */
1002 if (platform
->driver
->ops
&& platform
->driver
->ops
->hw_free
)
1003 platform
->driver
->ops
->hw_free(substream
);
1005 /* now free hw params for the DAIs */
1006 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
1007 codec_dai
= rtd
->codec_dais
[i
];
1008 if (codec_dai
->driver
->ops
&& codec_dai
->driver
->ops
->hw_free
)
1009 codec_dai
->driver
->ops
->hw_free(substream
, codec_dai
);
1012 if (cpu_dai
->driver
->ops
&& cpu_dai
->driver
->ops
->hw_free
)
1013 cpu_dai
->driver
->ops
->hw_free(substream
, cpu_dai
);
1015 mutex_unlock(&rtd
->pcm_mutex
);
1019 static int soc_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
1021 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
1022 struct snd_soc_platform
*platform
= rtd
->platform
;
1023 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1024 struct snd_soc_dai
*codec_dai
;
1027 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
1028 codec_dai
= rtd
->codec_dais
[i
];
1029 if (codec_dai
->driver
->ops
&& codec_dai
->driver
->ops
->trigger
) {
1030 ret
= codec_dai
->driver
->ops
->trigger(substream
,
1037 if (platform
->driver
->ops
&& platform
->driver
->ops
->trigger
) {
1038 ret
= platform
->driver
->ops
->trigger(substream
, cmd
);
1043 if (cpu_dai
->driver
->ops
&& cpu_dai
->driver
->ops
->trigger
) {
1044 ret
= cpu_dai
->driver
->ops
->trigger(substream
, cmd
, cpu_dai
);
1049 if (rtd
->dai_link
->ops
&& rtd
->dai_link
->ops
->trigger
) {
1050 ret
= rtd
->dai_link
->ops
->trigger(substream
, cmd
);
1058 static int soc_pcm_bespoke_trigger(struct snd_pcm_substream
*substream
,
1061 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
1062 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1063 struct snd_soc_dai
*codec_dai
;
1066 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
1067 codec_dai
= rtd
->codec_dais
[i
];
1068 if (codec_dai
->driver
->ops
&&
1069 codec_dai
->driver
->ops
->bespoke_trigger
) {
1070 ret
= codec_dai
->driver
->ops
->bespoke_trigger(substream
,
1077 if (cpu_dai
->driver
->ops
&& cpu_dai
->driver
->ops
->bespoke_trigger
) {
1078 ret
= cpu_dai
->driver
->ops
->bespoke_trigger(substream
, cmd
, cpu_dai
);
1085 * soc level wrapper for pointer callback
1086 * If cpu_dai, codec_dai, platform driver has the delay callback, than
1087 * the runtime->delay will be updated accordingly.
1089 static snd_pcm_uframes_t
soc_pcm_pointer(struct snd_pcm_substream
*substream
)
1091 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
1092 struct snd_soc_platform
*platform
= rtd
->platform
;
1093 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1094 struct snd_soc_dai
*codec_dai
;
1095 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1096 snd_pcm_uframes_t offset
= 0;
1097 snd_pcm_sframes_t delay
= 0;
1098 snd_pcm_sframes_t codec_delay
= 0;
1101 if (platform
->driver
->ops
&& platform
->driver
->ops
->pointer
)
1102 offset
= platform
->driver
->ops
->pointer(substream
);
1104 if (cpu_dai
->driver
->ops
&& cpu_dai
->driver
->ops
->delay
)
1105 delay
+= cpu_dai
->driver
->ops
->delay(substream
, cpu_dai
);
1107 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
1108 codec_dai
= rtd
->codec_dais
[i
];
1109 if (codec_dai
->driver
->ops
&& codec_dai
->driver
->ops
->delay
)
1110 codec_delay
= max(codec_delay
,
1111 codec_dai
->driver
->ops
->delay(substream
,
1114 delay
+= codec_delay
;
1116 runtime
->delay
= delay
;
1121 /* connect a FE and BE */
1122 static int dpcm_be_connect(struct snd_soc_pcm_runtime
*fe
,
1123 struct snd_soc_pcm_runtime
*be
, int stream
)
1125 struct snd_soc_dpcm
*dpcm
;
1127 /* only add new dpcms */
1128 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1129 if (dpcm
->be
== be
&& dpcm
->fe
== fe
)
1133 dpcm
= kzalloc(sizeof(struct snd_soc_dpcm
), GFP_KERNEL
);
1139 be
->dpcm
[stream
].runtime
= fe
->dpcm
[stream
].runtime
;
1140 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_NEW
;
1141 list_add(&dpcm
->list_be
, &fe
->dpcm
[stream
].be_clients
);
1142 list_add(&dpcm
->list_fe
, &be
->dpcm
[stream
].fe_clients
);
1144 dev_dbg(fe
->dev
, "connected new DPCM %s path %s %s %s\n",
1145 stream
? "capture" : "playback", fe
->dai_link
->name
,
1146 stream
? "<-" : "->", be
->dai_link
->name
);
1148 #ifdef CONFIG_DEBUG_FS
1149 if (fe
->debugfs_dpcm_root
)
1150 dpcm
->debugfs_state
= debugfs_create_u32(be
->dai_link
->name
, 0644,
1151 fe
->debugfs_dpcm_root
, &dpcm
->state
);
1156 /* reparent a BE onto another FE */
1157 static void dpcm_be_reparent(struct snd_soc_pcm_runtime
*fe
,
1158 struct snd_soc_pcm_runtime
*be
, int stream
)
1160 struct snd_soc_dpcm
*dpcm
;
1161 struct snd_pcm_substream
*fe_substream
, *be_substream
;
1163 /* reparent if BE is connected to other FEs */
1164 if (!be
->dpcm
[stream
].users
)
1167 be_substream
= snd_soc_dpcm_get_substream(be
, stream
);
1169 list_for_each_entry(dpcm
, &be
->dpcm
[stream
].fe_clients
, list_fe
) {
1173 dev_dbg(fe
->dev
, "reparent %s path %s %s %s\n",
1174 stream
? "capture" : "playback",
1175 dpcm
->fe
->dai_link
->name
,
1176 stream
? "<-" : "->", dpcm
->be
->dai_link
->name
);
1178 fe_substream
= snd_soc_dpcm_get_substream(dpcm
->fe
, stream
);
1179 be_substream
->runtime
= fe_substream
->runtime
;
1184 /* disconnect a BE and FE */
1185 void dpcm_be_disconnect(struct snd_soc_pcm_runtime
*fe
, int stream
)
1187 struct snd_soc_dpcm
*dpcm
, *d
;
1189 list_for_each_entry_safe(dpcm
, d
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1190 dev_dbg(fe
->dev
, "ASoC: BE %s disconnect check for %s\n",
1191 stream
? "capture" : "playback",
1192 dpcm
->be
->dai_link
->name
);
1194 if (dpcm
->state
!= SND_SOC_DPCM_LINK_STATE_FREE
)
1197 dev_dbg(fe
->dev
, "freed DSP %s path %s %s %s\n",
1198 stream
? "capture" : "playback", fe
->dai_link
->name
,
1199 stream
? "<-" : "->", dpcm
->be
->dai_link
->name
);
1201 /* BEs still alive need new FE */
1202 dpcm_be_reparent(fe
, dpcm
->be
, stream
);
1204 #ifdef CONFIG_DEBUG_FS
1205 debugfs_remove(dpcm
->debugfs_state
);
1207 list_del(&dpcm
->list_be
);
1208 list_del(&dpcm
->list_fe
);
1213 /* get BE for DAI widget and stream */
1214 static struct snd_soc_pcm_runtime
*dpcm_get_be(struct snd_soc_card
*card
,
1215 struct snd_soc_dapm_widget
*widget
, int stream
)
1217 struct snd_soc_pcm_runtime
*be
;
1220 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
1221 list_for_each_entry(be
, &card
->rtd_list
, list
) {
1223 if (!be
->dai_link
->no_pcm
)
1226 if (be
->cpu_dai
->playback_widget
== widget
)
1229 for (i
= 0; i
< be
->num_codecs
; i
++) {
1230 struct snd_soc_dai
*dai
= be
->codec_dais
[i
];
1231 if (dai
->playback_widget
== widget
)
1237 list_for_each_entry(be
, &card
->rtd_list
, list
) {
1239 if (!be
->dai_link
->no_pcm
)
1242 if (be
->cpu_dai
->capture_widget
== widget
)
1245 for (i
= 0; i
< be
->num_codecs
; i
++) {
1246 struct snd_soc_dai
*dai
= be
->codec_dais
[i
];
1247 if (dai
->capture_widget
== widget
)
1253 dev_err(card
->dev
, "ASoC: can't get %s BE for %s\n",
1254 stream
? "capture" : "playback", widget
->name
);
1258 static inline struct snd_soc_dapm_widget
*
1259 dai_get_widget(struct snd_soc_dai
*dai
, int stream
)
1261 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
)
1262 return dai
->playback_widget
;
1264 return dai
->capture_widget
;
1267 static int widget_in_list(struct snd_soc_dapm_widget_list
*list
,
1268 struct snd_soc_dapm_widget
*widget
)
1272 for (i
= 0; i
< list
->num_widgets
; i
++) {
1273 if (widget
== list
->widgets
[i
])
1280 static bool dpcm_end_walk_at_be(struct snd_soc_dapm_widget
*widget
,
1281 enum snd_soc_dapm_direction dir
)
1283 struct snd_soc_card
*card
= widget
->dapm
->card
;
1284 struct snd_soc_pcm_runtime
*rtd
;
1287 if (dir
== SND_SOC_DAPM_DIR_OUT
) {
1288 list_for_each_entry(rtd
, &card
->rtd_list
, list
) {
1289 if (!rtd
->dai_link
->no_pcm
)
1292 if (rtd
->cpu_dai
->playback_widget
== widget
)
1295 for (i
= 0; i
< rtd
->num_codecs
; ++i
) {
1296 struct snd_soc_dai
*dai
= rtd
->codec_dais
[i
];
1297 if (dai
->playback_widget
== widget
)
1301 } else { /* SND_SOC_DAPM_DIR_IN */
1302 list_for_each_entry(rtd
, &card
->rtd_list
, list
) {
1303 if (!rtd
->dai_link
->no_pcm
)
1306 if (rtd
->cpu_dai
->capture_widget
== widget
)
1309 for (i
= 0; i
< rtd
->num_codecs
; ++i
) {
1310 struct snd_soc_dai
*dai
= rtd
->codec_dais
[i
];
1311 if (dai
->capture_widget
== widget
)
1320 int dpcm_path_get(struct snd_soc_pcm_runtime
*fe
,
1321 int stream
, struct snd_soc_dapm_widget_list
**list
)
1323 struct snd_soc_dai
*cpu_dai
= fe
->cpu_dai
;
1326 /* get number of valid DAI paths and their widgets */
1327 paths
= snd_soc_dapm_dai_get_connected_widgets(cpu_dai
, stream
, list
,
1328 dpcm_end_walk_at_be
);
1330 dev_dbg(fe
->dev
, "ASoC: found %d audio %s paths\n", paths
,
1331 stream
? "capture" : "playback");
1336 static int dpcm_prune_paths(struct snd_soc_pcm_runtime
*fe
, int stream
,
1337 struct snd_soc_dapm_widget_list
**list_
)
1339 struct snd_soc_dpcm
*dpcm
;
1340 struct snd_soc_dapm_widget_list
*list
= *list_
;
1341 struct snd_soc_dapm_widget
*widget
;
1344 /* Destroy any old FE <--> BE connections */
1345 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1348 /* is there a valid CPU DAI widget for this BE */
1349 widget
= dai_get_widget(dpcm
->be
->cpu_dai
, stream
);
1351 /* prune the BE if it's no longer in our active list */
1352 if (widget
&& widget_in_list(list
, widget
))
1355 /* is there a valid CODEC DAI widget for this BE */
1356 for (i
= 0; i
< dpcm
->be
->num_codecs
; i
++) {
1357 struct snd_soc_dai
*dai
= dpcm
->be
->codec_dais
[i
];
1358 widget
= dai_get_widget(dai
, stream
);
1360 /* prune the BE if it's no longer in our active list */
1361 if (widget
&& widget_in_list(list
, widget
))
1365 dev_dbg(fe
->dev
, "ASoC: pruning %s BE %s for %s\n",
1366 stream
? "capture" : "playback",
1367 dpcm
->be
->dai_link
->name
, fe
->dai_link
->name
);
1368 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_FREE
;
1369 dpcm
->be
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_BE
;
1373 dev_dbg(fe
->dev
, "ASoC: found %d old BE paths for pruning\n", prune
);
1377 static int dpcm_add_paths(struct snd_soc_pcm_runtime
*fe
, int stream
,
1378 struct snd_soc_dapm_widget_list
**list_
)
1380 struct snd_soc_card
*card
= fe
->card
;
1381 struct snd_soc_dapm_widget_list
*list
= *list_
;
1382 struct snd_soc_pcm_runtime
*be
;
1383 int i
, new = 0, err
;
1385 /* Create any new FE <--> BE connections */
1386 for (i
= 0; i
< list
->num_widgets
; i
++) {
1388 switch (list
->widgets
[i
]->id
) {
1389 case snd_soc_dapm_dai_in
:
1390 if (stream
!= SNDRV_PCM_STREAM_PLAYBACK
)
1393 case snd_soc_dapm_dai_out
:
1394 if (stream
!= SNDRV_PCM_STREAM_CAPTURE
)
1401 /* is there a valid BE rtd for this widget */
1402 be
= dpcm_get_be(card
, list
->widgets
[i
], stream
);
1404 dev_err(fe
->dev
, "ASoC: no BE found for %s\n",
1405 list
->widgets
[i
]->name
);
1409 /* make sure BE is a real BE */
1410 if (!be
->dai_link
->no_pcm
)
1413 /* don't connect if FE is not running */
1414 if (!fe
->dpcm
[stream
].runtime
&& !fe
->fe_compr
)
1417 /* newly connected FE and BE */
1418 err
= dpcm_be_connect(fe
, be
, stream
);
1420 dev_err(fe
->dev
, "ASoC: can't connect %s\n",
1421 list
->widgets
[i
]->name
);
1423 } else if (err
== 0) /* already connected */
1427 be
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_BE
;
1431 dev_dbg(fe
->dev
, "ASoC: found %d new BE paths\n", new);
1436 * Find the corresponding BE DAIs that source or sink audio to this
1439 int dpcm_process_paths(struct snd_soc_pcm_runtime
*fe
,
1440 int stream
, struct snd_soc_dapm_widget_list
**list
, int new)
1443 return dpcm_add_paths(fe
, stream
, list
);
1445 return dpcm_prune_paths(fe
, stream
, list
);
1448 void dpcm_clear_pending_state(struct snd_soc_pcm_runtime
*fe
, int stream
)
1450 struct snd_soc_dpcm
*dpcm
;
1452 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
)
1453 dpcm
->be
->dpcm
[stream
].runtime_update
=
1454 SND_SOC_DPCM_UPDATE_NO
;
1457 static void dpcm_be_dai_startup_unwind(struct snd_soc_pcm_runtime
*fe
,
1460 struct snd_soc_dpcm
*dpcm
;
1462 /* disable any enabled and non active backends */
1463 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1465 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1466 struct snd_pcm_substream
*be_substream
=
1467 snd_soc_dpcm_get_substream(be
, stream
);
1469 if (be
->dpcm
[stream
].users
== 0)
1470 dev_err(be
->dev
, "ASoC: no users %s at close - state %d\n",
1471 stream
? "capture" : "playback",
1472 be
->dpcm
[stream
].state
);
1474 if (--be
->dpcm
[stream
].users
!= 0)
1477 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_OPEN
)
1480 soc_pcm_close(be_substream
);
1481 be_substream
->runtime
= NULL
;
1482 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_CLOSE
;
1486 int dpcm_be_dai_startup(struct snd_soc_pcm_runtime
*fe
, int stream
)
1488 struct snd_soc_dpcm
*dpcm
;
1491 /* only startup BE DAIs that are either sinks or sources to this FE DAI */
1492 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1494 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1495 struct snd_pcm_substream
*be_substream
=
1496 snd_soc_dpcm_get_substream(be
, stream
);
1498 if (!be_substream
) {
1499 dev_err(be
->dev
, "ASoC: no backend %s stream\n",
1500 stream
? "capture" : "playback");
1504 /* is this op for this BE ? */
1505 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1508 /* first time the dpcm is open ? */
1509 if (be
->dpcm
[stream
].users
== DPCM_MAX_BE_USERS
)
1510 dev_err(be
->dev
, "ASoC: too many users %s at open %d\n",
1511 stream
? "capture" : "playback",
1512 be
->dpcm
[stream
].state
);
1514 if (be
->dpcm
[stream
].users
++ != 0)
1517 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_NEW
) &&
1518 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_CLOSE
))
1521 dev_dbg(be
->dev
, "ASoC: open %s BE %s\n",
1522 stream
? "capture" : "playback", be
->dai_link
->name
);
1524 be_substream
->runtime
= be
->dpcm
[stream
].runtime
;
1525 err
= soc_pcm_open(be_substream
);
1527 dev_err(be
->dev
, "ASoC: BE open failed %d\n", err
);
1528 be
->dpcm
[stream
].users
--;
1529 if (be
->dpcm
[stream
].users
< 0)
1530 dev_err(be
->dev
, "ASoC: no users %s at unwind %d\n",
1531 stream
? "capture" : "playback",
1532 be
->dpcm
[stream
].state
);
1534 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_CLOSE
;
1538 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_OPEN
;
1545 /* disable any enabled and non active backends */
1546 list_for_each_entry_continue_reverse(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1547 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1548 struct snd_pcm_substream
*be_substream
=
1549 snd_soc_dpcm_get_substream(be
, stream
);
1551 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1554 if (be
->dpcm
[stream
].users
== 0)
1555 dev_err(be
->dev
, "ASoC: no users %s at close %d\n",
1556 stream
? "capture" : "playback",
1557 be
->dpcm
[stream
].state
);
1559 if (--be
->dpcm
[stream
].users
!= 0)
1562 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_OPEN
)
1565 soc_pcm_close(be_substream
);
1566 be_substream
->runtime
= NULL
;
1567 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_CLOSE
;
1573 static void dpcm_init_runtime_hw(struct snd_pcm_runtime
*runtime
,
1574 struct snd_soc_pcm_stream
*stream
,
1577 runtime
->hw
.rate_min
= stream
->rate_min
;
1578 runtime
->hw
.rate_max
= stream
->rate_max
;
1579 runtime
->hw
.channels_min
= stream
->channels_min
;
1580 runtime
->hw
.channels_max
= stream
->channels_max
;
1581 if (runtime
->hw
.formats
)
1582 runtime
->hw
.formats
&= formats
& stream
->formats
;
1584 runtime
->hw
.formats
= formats
& stream
->formats
;
1585 runtime
->hw
.rates
= stream
->rates
;
1588 static u64
dpcm_runtime_base_format(struct snd_pcm_substream
*substream
)
1590 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1591 struct snd_soc_dpcm
*dpcm
;
1592 u64 formats
= ULLONG_MAX
;
1593 int stream
= substream
->stream
;
1595 if (!fe
->dai_link
->dpcm_merged_format
)
1599 * It returns merged BE codec format
1600 * if FE want to use it (= dpcm_merged_format)
1603 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1604 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1605 struct snd_soc_dai_driver
*codec_dai_drv
;
1606 struct snd_soc_pcm_stream
*codec_stream
;
1609 for (i
= 0; i
< be
->num_codecs
; i
++) {
1610 codec_dai_drv
= be
->codec_dais
[i
]->driver
;
1611 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
)
1612 codec_stream
= &codec_dai_drv
->playback
;
1614 codec_stream
= &codec_dai_drv
->capture
;
1616 formats
&= codec_stream
->formats
;
1623 static void dpcm_set_fe_runtime(struct snd_pcm_substream
*substream
)
1625 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1626 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
1627 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1628 struct snd_soc_dai_driver
*cpu_dai_drv
= cpu_dai
->driver
;
1629 u64 format
= dpcm_runtime_base_format(substream
);
1631 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
1632 dpcm_init_runtime_hw(runtime
, &cpu_dai_drv
->playback
, format
);
1634 dpcm_init_runtime_hw(runtime
, &cpu_dai_drv
->capture
, format
);
1637 static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream
*substream
, int cmd
);
1639 /* Set FE's runtime_update state; the state is protected via PCM stream lock
1640 * for avoiding the race with trigger callback.
1641 * If the state is unset and a trigger is pending while the previous operation,
1642 * process the pending trigger action here.
1644 static void dpcm_set_fe_update_state(struct snd_soc_pcm_runtime
*fe
,
1645 int stream
, enum snd_soc_dpcm_update state
)
1647 struct snd_pcm_substream
*substream
=
1648 snd_soc_dpcm_get_substream(fe
, stream
);
1650 snd_pcm_stream_lock_irq(substream
);
1651 if (state
== SND_SOC_DPCM_UPDATE_NO
&& fe
->dpcm
[stream
].trigger_pending
) {
1652 dpcm_fe_dai_do_trigger(substream
,
1653 fe
->dpcm
[stream
].trigger_pending
- 1);
1654 fe
->dpcm
[stream
].trigger_pending
= 0;
1656 fe
->dpcm
[stream
].runtime_update
= state
;
1657 snd_pcm_stream_unlock_irq(substream
);
1660 static int dpcm_apply_symmetry(struct snd_pcm_substream
*fe_substream
,
1663 struct snd_soc_dpcm
*dpcm
;
1664 struct snd_soc_pcm_runtime
*fe
= fe_substream
->private_data
;
1665 struct snd_soc_dai
*fe_cpu_dai
= fe
->cpu_dai
;
1668 /* apply symmetry for FE */
1669 if (soc_pcm_has_symmetry(fe_substream
))
1670 fe_substream
->runtime
->hw
.info
|= SNDRV_PCM_INFO_JOINT_DUPLEX
;
1672 /* Symmetry only applies if we've got an active stream. */
1673 if (fe_cpu_dai
->active
) {
1674 err
= soc_pcm_apply_symmetry(fe_substream
, fe_cpu_dai
);
1679 /* apply symmetry for BE */
1680 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1681 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1682 struct snd_pcm_substream
*be_substream
=
1683 snd_soc_dpcm_get_substream(be
, stream
);
1684 struct snd_soc_pcm_runtime
*rtd
= be_substream
->private_data
;
1687 if (rtd
->dai_link
->be_hw_params_fixup
)
1690 if (soc_pcm_has_symmetry(be_substream
))
1691 be_substream
->runtime
->hw
.info
|= SNDRV_PCM_INFO_JOINT_DUPLEX
;
1693 /* Symmetry only applies if we've got an active stream. */
1694 if (rtd
->cpu_dai
->active
) {
1695 err
= soc_pcm_apply_symmetry(be_substream
, rtd
->cpu_dai
);
1700 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
1701 if (rtd
->codec_dais
[i
]->active
) {
1702 err
= soc_pcm_apply_symmetry(be_substream
,
1703 rtd
->codec_dais
[i
]);
1713 static int dpcm_fe_dai_startup(struct snd_pcm_substream
*fe_substream
)
1715 struct snd_soc_pcm_runtime
*fe
= fe_substream
->private_data
;
1716 struct snd_pcm_runtime
*runtime
= fe_substream
->runtime
;
1717 int stream
= fe_substream
->stream
, ret
= 0;
1719 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_FE
);
1721 ret
= dpcm_be_dai_startup(fe
, fe_substream
->stream
);
1723 dev_err(fe
->dev
,"ASoC: failed to start some BEs %d\n", ret
);
1727 dev_dbg(fe
->dev
, "ASoC: open FE %s\n", fe
->dai_link
->name
);
1729 /* start the DAI frontend */
1730 ret
= soc_pcm_open(fe_substream
);
1732 dev_err(fe
->dev
,"ASoC: failed to start FE %d\n", ret
);
1736 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_OPEN
;
1738 dpcm_set_fe_runtime(fe_substream
);
1739 snd_pcm_limit_hw_rates(runtime
);
1741 ret
= dpcm_apply_symmetry(fe_substream
, stream
);
1743 dev_err(fe
->dev
, "ASoC: failed to apply dpcm symmetry %d\n",
1748 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_NO
);
1752 dpcm_be_dai_startup_unwind(fe
, fe_substream
->stream
);
1754 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_NO
);
1758 int dpcm_be_dai_shutdown(struct snd_soc_pcm_runtime
*fe
, int stream
)
1760 struct snd_soc_dpcm
*dpcm
;
1762 /* only shutdown BEs that are either sinks or sources to this FE DAI */
1763 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1765 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1766 struct snd_pcm_substream
*be_substream
=
1767 snd_soc_dpcm_get_substream(be
, stream
);
1769 /* is this op for this BE ? */
1770 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1773 if (be
->dpcm
[stream
].users
== 0)
1774 dev_err(be
->dev
, "ASoC: no users %s at close - state %d\n",
1775 stream
? "capture" : "playback",
1776 be
->dpcm
[stream
].state
);
1778 if (--be
->dpcm
[stream
].users
!= 0)
1781 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_FREE
) &&
1782 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_OPEN
))
1785 dev_dbg(be
->dev
, "ASoC: close BE %s\n",
1786 be
->dai_link
->name
);
1788 soc_pcm_close(be_substream
);
1789 be_substream
->runtime
= NULL
;
1791 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_CLOSE
;
1796 static int dpcm_fe_dai_shutdown(struct snd_pcm_substream
*substream
)
1798 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1799 int stream
= substream
->stream
;
1801 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_FE
);
1803 /* shutdown the BEs */
1804 dpcm_be_dai_shutdown(fe
, substream
->stream
);
1806 dev_dbg(fe
->dev
, "ASoC: close FE %s\n", fe
->dai_link
->name
);
1808 /* now shutdown the frontend */
1809 soc_pcm_close(substream
);
1811 /* run the stream event for each BE */
1812 dpcm_dapm_stream_event(fe
, stream
, SND_SOC_DAPM_STREAM_STOP
);
1814 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_CLOSE
;
1815 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_NO
);
1819 int dpcm_be_dai_hw_free(struct snd_soc_pcm_runtime
*fe
, int stream
)
1821 struct snd_soc_dpcm
*dpcm
;
1823 /* only hw_params backends that are either sinks or sources
1824 * to this frontend DAI */
1825 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1827 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1828 struct snd_pcm_substream
*be_substream
=
1829 snd_soc_dpcm_get_substream(be
, stream
);
1831 /* is this op for this BE ? */
1832 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1835 /* only free hw when no longer used - check all FEs */
1836 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
1839 /* do not free hw if this BE is used by other FE */
1840 if (be
->dpcm
[stream
].users
> 1)
1843 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
1844 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_PREPARE
) &&
1845 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_FREE
) &&
1846 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_PAUSED
) &&
1847 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
) &&
1848 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_SUSPEND
))
1851 dev_dbg(be
->dev
, "ASoC: hw_free BE %s\n",
1852 be
->dai_link
->name
);
1854 soc_pcm_hw_free(be_substream
);
1856 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_HW_FREE
;
1862 static int dpcm_fe_dai_hw_free(struct snd_pcm_substream
*substream
)
1864 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1865 int err
, stream
= substream
->stream
;
1867 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1868 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_FE
);
1870 dev_dbg(fe
->dev
, "ASoC: hw_free FE %s\n", fe
->dai_link
->name
);
1872 /* call hw_free on the frontend */
1873 err
= soc_pcm_hw_free(substream
);
1875 dev_err(fe
->dev
,"ASoC: hw_free FE %s failed\n",
1876 fe
->dai_link
->name
);
1878 /* only hw_params backends that are either sinks or sources
1879 * to this frontend DAI */
1880 err
= dpcm_be_dai_hw_free(fe
, stream
);
1882 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_HW_FREE
;
1883 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_NO
);
1885 mutex_unlock(&fe
->card
->mutex
);
1889 int dpcm_be_dai_hw_params(struct snd_soc_pcm_runtime
*fe
, int stream
)
1891 struct snd_soc_dpcm
*dpcm
;
1894 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1896 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1897 struct snd_pcm_substream
*be_substream
=
1898 snd_soc_dpcm_get_substream(be
, stream
);
1900 /* is this op for this BE ? */
1901 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1904 /* copy params for each dpcm */
1905 memcpy(&dpcm
->hw_params
, &fe
->dpcm
[stream
].hw_params
,
1906 sizeof(struct snd_pcm_hw_params
));
1908 /* perform any hw_params fixups */
1909 if (be
->dai_link
->be_hw_params_fixup
) {
1910 ret
= be
->dai_link
->be_hw_params_fixup(be
,
1914 "ASoC: hw_params BE fixup failed %d\n",
1920 /* only allow hw_params() if no connected FEs are running */
1921 if (!snd_soc_dpcm_can_be_params(fe
, be
, stream
))
1924 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_OPEN
) &&
1925 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
1926 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_FREE
))
1929 dev_dbg(be
->dev
, "ASoC: hw_params BE %s\n",
1930 be
->dai_link
->name
);
1932 ret
= soc_pcm_hw_params(be_substream
, &dpcm
->hw_params
);
1934 dev_err(dpcm
->be
->dev
,
1935 "ASoC: hw_params BE failed %d\n", ret
);
1939 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_HW_PARAMS
;
1944 /* disable any enabled and non active backends */
1945 list_for_each_entry_continue_reverse(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
1946 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
1947 struct snd_pcm_substream
*be_substream
=
1948 snd_soc_dpcm_get_substream(be
, stream
);
1950 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
1953 /* only allow hw_free() if no connected FEs are running */
1954 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
1957 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_OPEN
) &&
1958 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
1959 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_FREE
) &&
1960 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
))
1963 soc_pcm_hw_free(be_substream
);
1969 static int dpcm_fe_dai_hw_params(struct snd_pcm_substream
*substream
,
1970 struct snd_pcm_hw_params
*params
)
1972 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
1973 int ret
, stream
= substream
->stream
;
1975 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
1976 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_FE
);
1978 memcpy(&fe
->dpcm
[substream
->stream
].hw_params
, params
,
1979 sizeof(struct snd_pcm_hw_params
));
1980 ret
= dpcm_be_dai_hw_params(fe
, substream
->stream
);
1982 dev_err(fe
->dev
,"ASoC: hw_params BE failed %d\n", ret
);
1986 dev_dbg(fe
->dev
, "ASoC: hw_params FE %s rate %d chan %x fmt %d\n",
1987 fe
->dai_link
->name
, params_rate(params
),
1988 params_channels(params
), params_format(params
));
1990 /* call hw_params on the frontend */
1991 ret
= soc_pcm_hw_params(substream
, params
);
1993 dev_err(fe
->dev
,"ASoC: hw_params FE failed %d\n", ret
);
1994 dpcm_be_dai_hw_free(fe
, stream
);
1996 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_HW_PARAMS
;
1999 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_NO
);
2000 mutex_unlock(&fe
->card
->mutex
);
2004 static int dpcm_do_trigger(struct snd_soc_dpcm
*dpcm
,
2005 struct snd_pcm_substream
*substream
, int cmd
)
2009 dev_dbg(dpcm
->be
->dev
, "ASoC: trigger BE %s cmd %d\n",
2010 dpcm
->be
->dai_link
->name
, cmd
);
2012 ret
= soc_pcm_trigger(substream
, cmd
);
2014 dev_err(dpcm
->be
->dev
,"ASoC: trigger BE failed %d\n", ret
);
2019 int dpcm_be_dai_trigger(struct snd_soc_pcm_runtime
*fe
, int stream
,
2022 struct snd_soc_dpcm
*dpcm
;
2025 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
2027 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
2028 struct snd_pcm_substream
*be_substream
=
2029 snd_soc_dpcm_get_substream(be
, stream
);
2031 /* is this op for this BE ? */
2032 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
2036 case SNDRV_PCM_TRIGGER_START
:
2037 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_PREPARE
) &&
2038 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
))
2041 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
2045 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_START
;
2047 case SNDRV_PCM_TRIGGER_RESUME
:
2048 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_SUSPEND
))
2051 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
2055 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_START
;
2057 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
2058 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_PAUSED
))
2061 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
2065 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_START
;
2067 case SNDRV_PCM_TRIGGER_STOP
:
2068 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_START
)
2071 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
2074 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
2078 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_STOP
;
2080 case SNDRV_PCM_TRIGGER_SUSPEND
:
2081 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_START
)
2084 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
2087 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
2091 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_SUSPEND
;
2093 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
2094 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_START
)
2097 if (!snd_soc_dpcm_can_be_free_stop(fe
, be
, stream
))
2100 ret
= dpcm_do_trigger(dpcm
, be_substream
, cmd
);
2104 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_PAUSED
;
2111 EXPORT_SYMBOL_GPL(dpcm_be_dai_trigger
);
2113 static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream
*substream
, int cmd
)
2115 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
2116 int stream
= substream
->stream
, ret
;
2117 enum snd_soc_dpcm_trigger trigger
= fe
->dai_link
->trigger
[stream
];
2119 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_FE
;
2122 case SND_SOC_DPCM_TRIGGER_PRE
:
2123 /* call trigger on the frontend before the backend. */
2125 dev_dbg(fe
->dev
, "ASoC: pre trigger FE %s cmd %d\n",
2126 fe
->dai_link
->name
, cmd
);
2128 ret
= soc_pcm_trigger(substream
, cmd
);
2130 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", ret
);
2134 ret
= dpcm_be_dai_trigger(fe
, substream
->stream
, cmd
);
2136 case SND_SOC_DPCM_TRIGGER_POST
:
2137 /* call trigger on the frontend after the backend. */
2139 ret
= dpcm_be_dai_trigger(fe
, substream
->stream
, cmd
);
2141 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", ret
);
2145 dev_dbg(fe
->dev
, "ASoC: post trigger FE %s cmd %d\n",
2146 fe
->dai_link
->name
, cmd
);
2148 ret
= soc_pcm_trigger(substream
, cmd
);
2150 case SND_SOC_DPCM_TRIGGER_BESPOKE
:
2151 /* bespoke trigger() - handles both FE and BEs */
2153 dev_dbg(fe
->dev
, "ASoC: bespoke trigger FE %s cmd %d\n",
2154 fe
->dai_link
->name
, cmd
);
2156 ret
= soc_pcm_bespoke_trigger(substream
, cmd
);
2158 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", ret
);
2163 dev_err(fe
->dev
, "ASoC: invalid trigger cmd %d for %s\n", cmd
,
2164 fe
->dai_link
->name
);
2170 case SNDRV_PCM_TRIGGER_START
:
2171 case SNDRV_PCM_TRIGGER_RESUME
:
2172 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
2173 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_START
;
2175 case SNDRV_PCM_TRIGGER_STOP
:
2176 case SNDRV_PCM_TRIGGER_SUSPEND
:
2177 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_STOP
;
2179 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
2180 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_PAUSED
;
2185 fe
->dpcm
[stream
].runtime_update
= SND_SOC_DPCM_UPDATE_NO
;
2189 static int dpcm_fe_dai_trigger(struct snd_pcm_substream
*substream
, int cmd
)
2191 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
2192 int stream
= substream
->stream
;
2194 /* if FE's runtime_update is already set, we're in race;
2195 * process this trigger later at exit
2197 if (fe
->dpcm
[stream
].runtime_update
!= SND_SOC_DPCM_UPDATE_NO
) {
2198 fe
->dpcm
[stream
].trigger_pending
= cmd
+ 1;
2199 return 0; /* delayed, assuming it's successful */
2202 /* we're alone, let's trigger */
2203 return dpcm_fe_dai_do_trigger(substream
, cmd
);
2206 int dpcm_be_dai_prepare(struct snd_soc_pcm_runtime
*fe
, int stream
)
2208 struct snd_soc_dpcm
*dpcm
;
2211 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
2213 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
2214 struct snd_pcm_substream
*be_substream
=
2215 snd_soc_dpcm_get_substream(be
, stream
);
2217 /* is this op for this BE ? */
2218 if (!snd_soc_dpcm_be_can_update(fe
, be
, stream
))
2221 if ((be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
2222 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_STOP
) &&
2223 (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_SUSPEND
))
2226 dev_dbg(be
->dev
, "ASoC: prepare BE %s\n",
2227 be
->dai_link
->name
);
2229 ret
= soc_pcm_prepare(be_substream
);
2231 dev_err(be
->dev
, "ASoC: backend prepare failed %d\n",
2236 be
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_PREPARE
;
2241 static int dpcm_fe_dai_prepare(struct snd_pcm_substream
*substream
)
2243 struct snd_soc_pcm_runtime
*fe
= substream
->private_data
;
2244 int stream
= substream
->stream
, ret
= 0;
2246 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
2248 dev_dbg(fe
->dev
, "ASoC: prepare FE %s\n", fe
->dai_link
->name
);
2250 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_FE
);
2252 /* there is no point preparing this FE if there are no BEs */
2253 if (list_empty(&fe
->dpcm
[stream
].be_clients
)) {
2254 dev_err(fe
->dev
, "ASoC: no backend DAIs enabled for %s\n",
2255 fe
->dai_link
->name
);
2260 ret
= dpcm_be_dai_prepare(fe
, substream
->stream
);
2264 /* call prepare on the frontend */
2265 ret
= soc_pcm_prepare(substream
);
2267 dev_err(fe
->dev
,"ASoC: prepare FE %s failed\n",
2268 fe
->dai_link
->name
);
2272 /* run the stream event for each BE */
2273 dpcm_dapm_stream_event(fe
, stream
, SND_SOC_DAPM_STREAM_START
);
2274 fe
->dpcm
[stream
].state
= SND_SOC_DPCM_STATE_PREPARE
;
2277 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_NO
);
2278 mutex_unlock(&fe
->card
->mutex
);
2283 static int soc_pcm_ioctl(struct snd_pcm_substream
*substream
,
2284 unsigned int cmd
, void *arg
)
2286 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
2287 struct snd_soc_platform
*platform
= rtd
->platform
;
2289 if (platform
->driver
->ops
&& platform
->driver
->ops
->ioctl
)
2290 return platform
->driver
->ops
->ioctl(substream
, cmd
, arg
);
2291 return snd_pcm_lib_ioctl(substream
, cmd
, arg
);
2294 static int dpcm_run_update_shutdown(struct snd_soc_pcm_runtime
*fe
, int stream
)
2296 struct snd_pcm_substream
*substream
=
2297 snd_soc_dpcm_get_substream(fe
, stream
);
2298 enum snd_soc_dpcm_trigger trigger
= fe
->dai_link
->trigger
[stream
];
2301 dev_dbg(fe
->dev
, "ASoC: runtime %s close on FE %s\n",
2302 stream
? "capture" : "playback", fe
->dai_link
->name
);
2304 if (trigger
== SND_SOC_DPCM_TRIGGER_BESPOKE
) {
2305 /* call bespoke trigger - FE takes care of all BE triggers */
2306 dev_dbg(fe
->dev
, "ASoC: bespoke trigger FE %s cmd stop\n",
2307 fe
->dai_link
->name
);
2309 err
= soc_pcm_bespoke_trigger(substream
, SNDRV_PCM_TRIGGER_STOP
);
2311 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", err
);
2313 dev_dbg(fe
->dev
, "ASoC: trigger FE %s cmd stop\n",
2314 fe
->dai_link
->name
);
2316 err
= dpcm_be_dai_trigger(fe
, stream
, SNDRV_PCM_TRIGGER_STOP
);
2318 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", err
);
2321 err
= dpcm_be_dai_hw_free(fe
, stream
);
2323 dev_err(fe
->dev
,"ASoC: hw_free FE failed %d\n", err
);
2325 err
= dpcm_be_dai_shutdown(fe
, stream
);
2327 dev_err(fe
->dev
,"ASoC: shutdown FE failed %d\n", err
);
2329 /* run the stream event for each BE */
2330 dpcm_dapm_stream_event(fe
, stream
, SND_SOC_DAPM_STREAM_NOP
);
2335 static int dpcm_run_update_startup(struct snd_soc_pcm_runtime
*fe
, int stream
)
2337 struct snd_pcm_substream
*substream
=
2338 snd_soc_dpcm_get_substream(fe
, stream
);
2339 struct snd_soc_dpcm
*dpcm
;
2340 enum snd_soc_dpcm_trigger trigger
= fe
->dai_link
->trigger
[stream
];
2343 dev_dbg(fe
->dev
, "ASoC: runtime %s open on FE %s\n",
2344 stream
? "capture" : "playback", fe
->dai_link
->name
);
2346 /* Only start the BE if the FE is ready */
2347 if (fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_HW_FREE
||
2348 fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_CLOSE
)
2351 /* startup must always be called for new BEs */
2352 ret
= dpcm_be_dai_startup(fe
, stream
);
2356 /* keep going if FE state is > open */
2357 if (fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_OPEN
)
2360 ret
= dpcm_be_dai_hw_params(fe
, stream
);
2364 /* keep going if FE state is > hw_params */
2365 if (fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_HW_PARAMS
)
2369 ret
= dpcm_be_dai_prepare(fe
, stream
);
2373 /* run the stream event for each BE */
2374 dpcm_dapm_stream_event(fe
, stream
, SND_SOC_DAPM_STREAM_NOP
);
2376 /* keep going if FE state is > prepare */
2377 if (fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_PREPARE
||
2378 fe
->dpcm
[stream
].state
== SND_SOC_DPCM_STATE_STOP
)
2381 if (trigger
== SND_SOC_DPCM_TRIGGER_BESPOKE
) {
2382 /* call trigger on the frontend - FE takes care of all BE triggers */
2383 dev_dbg(fe
->dev
, "ASoC: bespoke trigger FE %s cmd start\n",
2384 fe
->dai_link
->name
);
2386 ret
= soc_pcm_bespoke_trigger(substream
, SNDRV_PCM_TRIGGER_START
);
2388 dev_err(fe
->dev
,"ASoC: bespoke trigger FE failed %d\n", ret
);
2392 dev_dbg(fe
->dev
, "ASoC: trigger FE %s cmd start\n",
2393 fe
->dai_link
->name
);
2395 ret
= dpcm_be_dai_trigger(fe
, stream
,
2396 SNDRV_PCM_TRIGGER_START
);
2398 dev_err(fe
->dev
,"ASoC: trigger FE failed %d\n", ret
);
2406 dpcm_be_dai_hw_free(fe
, stream
);
2408 dpcm_be_dai_shutdown(fe
, stream
);
2410 /* disconnect any non started BEs */
2411 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
2412 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
2413 if (be
->dpcm
[stream
].state
!= SND_SOC_DPCM_STATE_START
)
2414 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_FREE
;
2420 static int dpcm_run_new_update(struct snd_soc_pcm_runtime
*fe
, int stream
)
2424 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_BE
);
2425 ret
= dpcm_run_update_startup(fe
, stream
);
2427 dev_err(fe
->dev
, "ASoC: failed to startup some BEs\n");
2428 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_NO
);
2433 static int dpcm_run_old_update(struct snd_soc_pcm_runtime
*fe
, int stream
)
2437 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_BE
);
2438 ret
= dpcm_run_update_shutdown(fe
, stream
);
2440 dev_err(fe
->dev
, "ASoC: failed to shutdown some BEs\n");
2441 dpcm_set_fe_update_state(fe
, stream
, SND_SOC_DPCM_UPDATE_NO
);
2446 /* Called by DAPM mixer/mux changes to update audio routing between PCMs and
2449 int soc_dpcm_runtime_update(struct snd_soc_card
*card
)
2451 struct snd_soc_pcm_runtime
*fe
;
2452 int old
, new, paths
;
2454 mutex_lock_nested(&card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
2455 list_for_each_entry(fe
, &card
->rtd_list
, list
) {
2456 struct snd_soc_dapm_widget_list
*list
;
2458 /* make sure link is FE */
2459 if (!fe
->dai_link
->dynamic
)
2462 /* only check active links */
2463 if (!fe
->cpu_dai
->active
)
2466 /* DAPM sync will call this to update DSP paths */
2467 dev_dbg(fe
->dev
, "ASoC: DPCM runtime update for FE %s\n",
2468 fe
->dai_link
->name
);
2470 /* skip if FE doesn't have playback capability */
2471 if (!fe
->cpu_dai
->driver
->playback
.channels_min
2472 || !fe
->codec_dai
->driver
->playback
.channels_min
)
2475 /* skip if FE isn't currently playing */
2476 if (!fe
->cpu_dai
->playback_active
2477 || !fe
->codec_dai
->playback_active
)
2480 paths
= dpcm_path_get(fe
, SNDRV_PCM_STREAM_PLAYBACK
, &list
);
2482 dev_warn(fe
->dev
, "ASoC: %s no valid %s path\n",
2483 fe
->dai_link
->name
, "playback");
2484 mutex_unlock(&card
->mutex
);
2488 /* update any new playback paths */
2489 new = dpcm_process_paths(fe
, SNDRV_PCM_STREAM_PLAYBACK
, &list
, 1);
2491 dpcm_run_new_update(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
2492 dpcm_clear_pending_state(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
2493 dpcm_be_disconnect(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
2496 /* update any old playback paths */
2497 old
= dpcm_process_paths(fe
, SNDRV_PCM_STREAM_PLAYBACK
, &list
, 0);
2499 dpcm_run_old_update(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
2500 dpcm_clear_pending_state(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
2501 dpcm_be_disconnect(fe
, SNDRV_PCM_STREAM_PLAYBACK
);
2504 dpcm_path_put(&list
);
2506 /* skip if FE doesn't have capture capability */
2507 if (!fe
->cpu_dai
->driver
->capture
.channels_min
2508 || !fe
->codec_dai
->driver
->capture
.channels_min
)
2511 /* skip if FE isn't currently capturing */
2512 if (!fe
->cpu_dai
->capture_active
2513 || !fe
->codec_dai
->capture_active
)
2516 paths
= dpcm_path_get(fe
, SNDRV_PCM_STREAM_CAPTURE
, &list
);
2518 dev_warn(fe
->dev
, "ASoC: %s no valid %s path\n",
2519 fe
->dai_link
->name
, "capture");
2520 mutex_unlock(&card
->mutex
);
2524 /* update any new capture paths */
2525 new = dpcm_process_paths(fe
, SNDRV_PCM_STREAM_CAPTURE
, &list
, 1);
2527 dpcm_run_new_update(fe
, SNDRV_PCM_STREAM_CAPTURE
);
2528 dpcm_clear_pending_state(fe
, SNDRV_PCM_STREAM_CAPTURE
);
2529 dpcm_be_disconnect(fe
, SNDRV_PCM_STREAM_CAPTURE
);
2532 /* update any old capture paths */
2533 old
= dpcm_process_paths(fe
, SNDRV_PCM_STREAM_CAPTURE
, &list
, 0);
2535 dpcm_run_old_update(fe
, SNDRV_PCM_STREAM_CAPTURE
);
2536 dpcm_clear_pending_state(fe
, SNDRV_PCM_STREAM_CAPTURE
);
2537 dpcm_be_disconnect(fe
, SNDRV_PCM_STREAM_CAPTURE
);
2540 dpcm_path_put(&list
);
2543 mutex_unlock(&card
->mutex
);
2546 int soc_dpcm_be_digital_mute(struct snd_soc_pcm_runtime
*fe
, int mute
)
2548 struct snd_soc_dpcm
*dpcm
;
2549 struct list_head
*clients
=
2550 &fe
->dpcm
[SNDRV_PCM_STREAM_PLAYBACK
].be_clients
;
2552 list_for_each_entry(dpcm
, clients
, list_be
) {
2554 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
2557 if (be
->dai_link
->ignore_suspend
)
2560 for (i
= 0; i
< be
->num_codecs
; i
++) {
2561 struct snd_soc_dai
*dai
= be
->codec_dais
[i
];
2562 struct snd_soc_dai_driver
*drv
= dai
->driver
;
2564 dev_dbg(be
->dev
, "ASoC: BE digital mute %s\n",
2565 be
->dai_link
->name
);
2567 if (drv
->ops
&& drv
->ops
->digital_mute
&&
2568 dai
->playback_active
)
2569 drv
->ops
->digital_mute(dai
, mute
);
2576 static int dpcm_fe_dai_open(struct snd_pcm_substream
*fe_substream
)
2578 struct snd_soc_pcm_runtime
*fe
= fe_substream
->private_data
;
2579 struct snd_soc_dpcm
*dpcm
;
2580 struct snd_soc_dapm_widget_list
*list
;
2582 int stream
= fe_substream
->stream
;
2584 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
2585 fe
->dpcm
[stream
].runtime
= fe_substream
->runtime
;
2587 ret
= dpcm_path_get(fe
, stream
, &list
);
2589 mutex_unlock(&fe
->card
->mutex
);
2591 } else if (ret
== 0) {
2592 dev_dbg(fe
->dev
, "ASoC: %s no valid %s route\n",
2593 fe
->dai_link
->name
, stream
? "capture" : "playback");
2596 /* calculate valid and active FE <-> BE dpcms */
2597 dpcm_process_paths(fe
, stream
, &list
, 1);
2599 ret
= dpcm_fe_dai_startup(fe_substream
);
2601 /* clean up all links */
2602 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
)
2603 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_FREE
;
2605 dpcm_be_disconnect(fe
, stream
);
2606 fe
->dpcm
[stream
].runtime
= NULL
;
2609 dpcm_clear_pending_state(fe
, stream
);
2610 dpcm_path_put(&list
);
2611 mutex_unlock(&fe
->card
->mutex
);
2615 static int dpcm_fe_dai_close(struct snd_pcm_substream
*fe_substream
)
2617 struct snd_soc_pcm_runtime
*fe
= fe_substream
->private_data
;
2618 struct snd_soc_dpcm
*dpcm
;
2619 int stream
= fe_substream
->stream
, ret
;
2621 mutex_lock_nested(&fe
->card
->mutex
, SND_SOC_CARD_CLASS_RUNTIME
);
2622 ret
= dpcm_fe_dai_shutdown(fe_substream
);
2624 /* mark FE's links ready to prune */
2625 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
)
2626 dpcm
->state
= SND_SOC_DPCM_LINK_STATE_FREE
;
2628 dpcm_be_disconnect(fe
, stream
);
2630 fe
->dpcm
[stream
].runtime
= NULL
;
2631 mutex_unlock(&fe
->card
->mutex
);
2635 /* create a new pcm */
2636 int soc_new_pcm(struct snd_soc_pcm_runtime
*rtd
, int num
)
2638 struct snd_soc_platform
*platform
= rtd
->platform
;
2639 struct snd_soc_dai
*codec_dai
;
2640 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
2641 struct snd_pcm
*pcm
;
2643 int ret
= 0, playback
= 0, capture
= 0;
2646 if (rtd
->dai_link
->dynamic
|| rtd
->dai_link
->no_pcm
) {
2647 playback
= rtd
->dai_link
->dpcm_playback
;
2648 capture
= rtd
->dai_link
->dpcm_capture
;
2650 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
2651 codec_dai
= rtd
->codec_dais
[i
];
2652 if (codec_dai
->driver
->playback
.channels_min
)
2654 if (codec_dai
->driver
->capture
.channels_min
)
2658 capture
= capture
&& cpu_dai
->driver
->capture
.channels_min
;
2659 playback
= playback
&& cpu_dai
->driver
->playback
.channels_min
;
2662 if (rtd
->dai_link
->playback_only
) {
2667 if (rtd
->dai_link
->capture_only
) {
2672 /* create the PCM */
2673 if (rtd
->dai_link
->no_pcm
) {
2674 snprintf(new_name
, sizeof(new_name
), "(%s)",
2675 rtd
->dai_link
->stream_name
);
2677 ret
= snd_pcm_new_internal(rtd
->card
->snd_card
, new_name
, num
,
2678 playback
, capture
, &pcm
);
2680 if (rtd
->dai_link
->dynamic
)
2681 snprintf(new_name
, sizeof(new_name
), "%s (*)",
2682 rtd
->dai_link
->stream_name
);
2684 snprintf(new_name
, sizeof(new_name
), "%s %s-%d",
2685 rtd
->dai_link
->stream_name
,
2686 (rtd
->num_codecs
> 1) ?
2687 "multicodec" : rtd
->codec_dai
->name
, num
);
2689 ret
= snd_pcm_new(rtd
->card
->snd_card
, new_name
, num
, playback
,
2693 dev_err(rtd
->card
->dev
, "ASoC: can't create pcm for %s\n",
2694 rtd
->dai_link
->name
);
2697 dev_dbg(rtd
->card
->dev
, "ASoC: registered pcm #%d %s\n",num
, new_name
);
2699 /* DAPM dai link stream work */
2700 INIT_DELAYED_WORK(&rtd
->delayed_work
, close_delayed_work
);
2702 pcm
->nonatomic
= rtd
->dai_link
->nonatomic
;
2704 pcm
->private_data
= rtd
;
2706 if (rtd
->dai_link
->no_pcm
) {
2708 pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
->private_data
= rtd
;
2710 pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
->private_data
= rtd
;
2714 /* ASoC PCM operations */
2715 if (rtd
->dai_link
->dynamic
) {
2716 rtd
->ops
.open
= dpcm_fe_dai_open
;
2717 rtd
->ops
.hw_params
= dpcm_fe_dai_hw_params
;
2718 rtd
->ops
.prepare
= dpcm_fe_dai_prepare
;
2719 rtd
->ops
.trigger
= dpcm_fe_dai_trigger
;
2720 rtd
->ops
.hw_free
= dpcm_fe_dai_hw_free
;
2721 rtd
->ops
.close
= dpcm_fe_dai_close
;
2722 rtd
->ops
.pointer
= soc_pcm_pointer
;
2723 rtd
->ops
.ioctl
= soc_pcm_ioctl
;
2725 rtd
->ops
.open
= soc_pcm_open
;
2726 rtd
->ops
.hw_params
= soc_pcm_hw_params
;
2727 rtd
->ops
.prepare
= soc_pcm_prepare
;
2728 rtd
->ops
.trigger
= soc_pcm_trigger
;
2729 rtd
->ops
.hw_free
= soc_pcm_hw_free
;
2730 rtd
->ops
.close
= soc_pcm_close
;
2731 rtd
->ops
.pointer
= soc_pcm_pointer
;
2732 rtd
->ops
.ioctl
= soc_pcm_ioctl
;
2735 if (platform
->driver
->ops
) {
2736 rtd
->ops
.ack
= platform
->driver
->ops
->ack
;
2737 rtd
->ops
.copy_user
= platform
->driver
->ops
->copy_user
;
2738 rtd
->ops
.copy_kernel
= platform
->driver
->ops
->copy_kernel
;
2739 rtd
->ops
.fill_silence
= platform
->driver
->ops
->fill_silence
;
2740 rtd
->ops
.page
= platform
->driver
->ops
->page
;
2741 rtd
->ops
.mmap
= platform
->driver
->ops
->mmap
;
2745 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &rtd
->ops
);
2748 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &rtd
->ops
);
2750 if (platform
->driver
->pcm_new
) {
2751 ret
= platform
->driver
->pcm_new(rtd
);
2753 dev_err(platform
->dev
,
2754 "ASoC: pcm constructor failed: %d\n",
2760 pcm
->private_free
= platform
->driver
->pcm_free
;
2762 dev_info(rtd
->card
->dev
, "%s <-> %s mapping ok\n",
2763 (rtd
->num_codecs
> 1) ? "multicodec" : rtd
->codec_dai
->name
,
2768 /* is the current PCM operation for this FE ? */
2769 int snd_soc_dpcm_fe_can_update(struct snd_soc_pcm_runtime
*fe
, int stream
)
2771 if (fe
->dpcm
[stream
].runtime_update
== SND_SOC_DPCM_UPDATE_FE
)
2775 EXPORT_SYMBOL_GPL(snd_soc_dpcm_fe_can_update
);
2777 /* is the current PCM operation for this BE ? */
2778 int snd_soc_dpcm_be_can_update(struct snd_soc_pcm_runtime
*fe
,
2779 struct snd_soc_pcm_runtime
*be
, int stream
)
2781 if ((fe
->dpcm
[stream
].runtime_update
== SND_SOC_DPCM_UPDATE_FE
) ||
2782 ((fe
->dpcm
[stream
].runtime_update
== SND_SOC_DPCM_UPDATE_BE
) &&
2783 be
->dpcm
[stream
].runtime_update
))
2787 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_can_update
);
2789 /* get the substream for this BE */
2790 struct snd_pcm_substream
*
2791 snd_soc_dpcm_get_substream(struct snd_soc_pcm_runtime
*be
, int stream
)
2793 return be
->pcm
->streams
[stream
].substream
;
2795 EXPORT_SYMBOL_GPL(snd_soc_dpcm_get_substream
);
2797 /* get the BE runtime state */
2798 enum snd_soc_dpcm_state
2799 snd_soc_dpcm_be_get_state(struct snd_soc_pcm_runtime
*be
, int stream
)
2801 return be
->dpcm
[stream
].state
;
2803 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_get_state
);
2805 /* set the BE runtime state */
2806 void snd_soc_dpcm_be_set_state(struct snd_soc_pcm_runtime
*be
,
2807 int stream
, enum snd_soc_dpcm_state state
)
2809 be
->dpcm
[stream
].state
= state
;
2811 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_set_state
);
2814 * We can only hw_free, stop, pause or suspend a BE DAI if any of it's FE
2815 * are not running, paused or suspended for the specified stream direction.
2817 int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime
*fe
,
2818 struct snd_soc_pcm_runtime
*be
, int stream
)
2820 struct snd_soc_dpcm
*dpcm
;
2823 list_for_each_entry(dpcm
, &be
->dpcm
[stream
].fe_clients
, list_fe
) {
2828 state
= dpcm
->fe
->dpcm
[stream
].state
;
2829 if (state
== SND_SOC_DPCM_STATE_START
||
2830 state
== SND_SOC_DPCM_STATE_PAUSED
||
2831 state
== SND_SOC_DPCM_STATE_SUSPEND
)
2835 /* it's safe to free/stop this BE DAI */
2838 EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop
);
2841 * We can only change hw params a BE DAI if any of it's FE are not prepared,
2842 * running, paused or suspended for the specified stream direction.
2844 int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime
*fe
,
2845 struct snd_soc_pcm_runtime
*be
, int stream
)
2847 struct snd_soc_dpcm
*dpcm
;
2850 list_for_each_entry(dpcm
, &be
->dpcm
[stream
].fe_clients
, list_fe
) {
2855 state
= dpcm
->fe
->dpcm
[stream
].state
;
2856 if (state
== SND_SOC_DPCM_STATE_START
||
2857 state
== SND_SOC_DPCM_STATE_PAUSED
||
2858 state
== SND_SOC_DPCM_STATE_SUSPEND
||
2859 state
== SND_SOC_DPCM_STATE_PREPARE
)
2863 /* it's safe to change hw_params */
2866 EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params
);
2868 #ifdef CONFIG_DEBUG_FS
2869 static const char *dpcm_state_string(enum snd_soc_dpcm_state state
)
2872 case SND_SOC_DPCM_STATE_NEW
:
2874 case SND_SOC_DPCM_STATE_OPEN
:
2876 case SND_SOC_DPCM_STATE_HW_PARAMS
:
2878 case SND_SOC_DPCM_STATE_PREPARE
:
2880 case SND_SOC_DPCM_STATE_START
:
2882 case SND_SOC_DPCM_STATE_STOP
:
2884 case SND_SOC_DPCM_STATE_SUSPEND
:
2886 case SND_SOC_DPCM_STATE_PAUSED
:
2888 case SND_SOC_DPCM_STATE_HW_FREE
:
2890 case SND_SOC_DPCM_STATE_CLOSE
:
2897 static ssize_t
dpcm_show_state(struct snd_soc_pcm_runtime
*fe
,
2898 int stream
, char *buf
, size_t size
)
2900 struct snd_pcm_hw_params
*params
= &fe
->dpcm
[stream
].hw_params
;
2901 struct snd_soc_dpcm
*dpcm
;
2905 offset
+= snprintf(buf
+ offset
, size
- offset
,
2906 "[%s - %s]\n", fe
->dai_link
->name
,
2907 stream
? "Capture" : "Playback");
2909 offset
+= snprintf(buf
+ offset
, size
- offset
, "State: %s\n",
2910 dpcm_state_string(fe
->dpcm
[stream
].state
));
2912 if ((fe
->dpcm
[stream
].state
>= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
2913 (fe
->dpcm
[stream
].state
<= SND_SOC_DPCM_STATE_STOP
))
2914 offset
+= snprintf(buf
+ offset
, size
- offset
,
2916 "Format = %s, Channels = %d, Rate = %d\n",
2917 snd_pcm_format_name(params_format(params
)),
2918 params_channels(params
),
2919 params_rate(params
));
2922 offset
+= snprintf(buf
+ offset
, size
- offset
, "Backends:\n");
2924 if (list_empty(&fe
->dpcm
[stream
].be_clients
)) {
2925 offset
+= snprintf(buf
+ offset
, size
- offset
,
2926 " No active DSP links\n");
2930 list_for_each_entry(dpcm
, &fe
->dpcm
[stream
].be_clients
, list_be
) {
2931 struct snd_soc_pcm_runtime
*be
= dpcm
->be
;
2932 params
= &dpcm
->hw_params
;
2934 offset
+= snprintf(buf
+ offset
, size
- offset
,
2935 "- %s\n", be
->dai_link
->name
);
2937 offset
+= snprintf(buf
+ offset
, size
- offset
,
2939 dpcm_state_string(be
->dpcm
[stream
].state
));
2941 if ((be
->dpcm
[stream
].state
>= SND_SOC_DPCM_STATE_HW_PARAMS
) &&
2942 (be
->dpcm
[stream
].state
<= SND_SOC_DPCM_STATE_STOP
))
2943 offset
+= snprintf(buf
+ offset
, size
- offset
,
2944 " Hardware Params: "
2945 "Format = %s, Channels = %d, Rate = %d\n",
2946 snd_pcm_format_name(params_format(params
)),
2947 params_channels(params
),
2948 params_rate(params
));
2955 static ssize_t
dpcm_state_read_file(struct file
*file
, char __user
*user_buf
,
2956 size_t count
, loff_t
*ppos
)
2958 struct snd_soc_pcm_runtime
*fe
= file
->private_data
;
2959 ssize_t out_count
= PAGE_SIZE
, offset
= 0, ret
= 0;
2962 buf
= kmalloc(out_count
, GFP_KERNEL
);
2966 if (fe
->cpu_dai
->driver
->playback
.channels_min
)
2967 offset
+= dpcm_show_state(fe
, SNDRV_PCM_STREAM_PLAYBACK
,
2968 buf
+ offset
, out_count
- offset
);
2970 if (fe
->cpu_dai
->driver
->capture
.channels_min
)
2971 offset
+= dpcm_show_state(fe
, SNDRV_PCM_STREAM_CAPTURE
,
2972 buf
+ offset
, out_count
- offset
);
2974 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, offset
);
2980 static const struct file_operations dpcm_state_fops
= {
2981 .open
= simple_open
,
2982 .read
= dpcm_state_read_file
,
2983 .llseek
= default_llseek
,
2986 void soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime
*rtd
)
2991 if (!rtd
->card
->debugfs_card_root
)
2994 rtd
->debugfs_dpcm_root
= debugfs_create_dir(rtd
->dai_link
->name
,
2995 rtd
->card
->debugfs_card_root
);
2996 if (!rtd
->debugfs_dpcm_root
) {
2998 "ASoC: Failed to create dpcm debugfs directory %s\n",
2999 rtd
->dai_link
->name
);
3003 rtd
->debugfs_dpcm_state
= debugfs_create_file("state", 0444,
3004 rtd
->debugfs_dpcm_root
,
3005 rtd
, &dpcm_state_fops
);