ASoC: dsp - Add ASoC DSP core
This adds ASoC core support for internal and external DSPs and represents them
to the audio user as a CODEC like device with mixers, muxes and runtime audio
route changing.
The DSP core allows DSP DAIs to be dynamically re-routed at runtime between the
PCM device end (or Frontend - FE) and the physical DAI (Backend - BE) using
regular kcontrols (just like a hardware CODEC).
The DSP core also deal with DSP FE+BE suspend and resume PM ops.
Signed-off-by: Liam Girdwood <lrg@ti.com>
diff --git a/include/sound/soc-dsp.h b/include/sound/soc-dsp.h
new file mode 100644
index 0000000..b10360e
--- /dev/null
+++ b/include/sound/soc-dsp.h
@@ -0,0 +1,129 @@
+/*
+ * linux/sound/soc-dsp.h -- ALSA SoC DSP
+ *
+ * Author: Liam Girdwood <lrg@slimlogic.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __LINUX_SND_SOC_DSP_H
+#define __LINUX_SND_SOC_DSP_H
+
+#include <sound/pcm.h>
+
+struct snd_soc_dapm_widget;
+
+/*
+ * DSP trigger ordering. Triggering flexibility is required as some DSPs
+ * require triggering before/after their clients/hosts.
+ *
+ * i.e. some clients may want to manually order this call in their PCM
+ * trigger() whilst others will just use the regular core ordering.
+ */
+enum snd_soc_dsp_trigger {
+ SND_SOC_DSP_TRIGGER_PRE = 0,
+ SND_SOC_DSP_TRIGGER_POST,
+ SND_SOC_DSP_TRIGGER_BESPOKE,
+};
+
+/*
+ * The DSP Backend state.
+ */
+enum snd_soc_dsp_link_state {
+ SND_SOC_DSP_LINK_STATE_NEW = 0, /* newly created path */
+ SND_SOC_DSP_LINK_STATE_FREE, /* path to be dismantled */
+ SND_SOC_DSP_LINK_STATE_HW_PARAMS, /* path hw_params configured */
+ SND_SOC_DSP_LINK_STATE_PREPARE, /* path is prepared */
+ SND_SOC_DSP_LINK_STATE_START, /* path is started */
+ SND_SOC_DSP_LINK_STATE_PAUSED, /* path is paused */
+};
+
+struct snd_soc_dsp_params {
+ struct snd_soc_pcm_runtime *be;
+ struct snd_soc_pcm_runtime *fe;
+ enum snd_soc_dsp_link_state state;
+ struct list_head list_be;
+ struct list_head list_fe;
+ struct snd_pcm_hw_params params;
+#ifdef CONFIG_DEBUG_FS
+ struct dentry *debugfs_state;
+#endif
+};
+
+struct snd_soc_dsp_link {
+ /* supported BE */
+ const char **supported_be;
+ int num_be;
+ /* supported channels */
+ int fe_playback_channels;
+ int fe_capture_channels;
+
+ enum snd_soc_dsp_trigger trigger[2];
+};
+
+/* FE DSP PCM ops - called by soc-core */
+int soc_dsp_fe_dai_open(struct snd_pcm_substream *substream);
+int soc_dsp_fe_dai_close(struct snd_pcm_substream *substream);
+int soc_dsp_fe_dai_prepare(struct snd_pcm_substream *substream);
+int soc_dsp_fe_dai_hw_free(struct snd_pcm_substream *substream);
+int soc_dsp_fe_dai_trigger(struct snd_pcm_substream *substream, int cmd);
+int soc_dsp_fe_dai_hw_params(struct snd_pcm_substream *substream,
+ struct snd_pcm_hw_params *params);
+
+/* Backend DSP trigger.
+ * Can be called by core or components depending on trigger config.
+ */
+int soc_dsp_be_dai_trigger(struct snd_soc_pcm_runtime *fe, int stream, int cmd);
+
+/* Is this trigger() call required for this BE and stream */
+static inline int snd_soc_dsp_is_trigger_for_be(struct snd_soc_pcm_runtime *fe,
+ struct snd_soc_pcm_runtime *be, int stream)
+{
+ if (!fe->dsp[stream].runtime_update)
+ return 1;
+ else if (be->dsp[stream].runtime_update)
+ return 1;
+ else
+ return 0;
+}
+
+/* Is this trigger() call required for this FE and stream */
+static inline int snd_soc_dsp_is_trigger_for_fe(struct snd_soc_pcm_runtime *fe,
+ int stream)
+{
+ return !fe->dsp[stream].runtime_update;
+}
+
+static inline int snd_soc_dsp_platform_trigger(struct snd_pcm_substream *substream,
+ int cmd, struct snd_soc_platform *platform)
+{
+ if (platform->driver->ops->trigger)
+ return platform->driver->ops->trigger(substream, cmd);
+ return 0;
+}
+
+/* Runtime update - open/close Backend DSP paths depending on mixer updates */
+int soc_dsp_runtime_update(struct snd_soc_dapm_widget *widget);
+
+/* Backend DSP suspend and resume */
+int soc_dsp_be_digital_mute(struct snd_soc_pcm_runtime *fe, int mute);
+int soc_dsp_be_cpu_dai_suspend(struct snd_soc_pcm_runtime *fe);
+int soc_dsp_be_ac97_cpu_dai_suspend(struct snd_soc_pcm_runtime *fe);
+int soc_dsp_be_platform_suspend(struct snd_soc_pcm_runtime *fe);
+int soc_dsp_be_cpu_dai_resume(struct snd_soc_pcm_runtime *fe);
+int soc_dsp_be_ac97_cpu_dai_resume(struct snd_soc_pcm_runtime *fe);
+int soc_dsp_be_platform_resume(struct snd_soc_pcm_runtime *fe);
+
+/* DAPM stream events for Backend DSP paths */
+int soc_dsp_dapm_stream_event(struct snd_soc_pcm_runtime *fe,
+ int dir, const char *stream, int event);
+
+static inline struct snd_pcm_substream *snd_soc_dsp_get_substream(
+ struct snd_soc_pcm_runtime *be, int stream)
+{
+ return be->pcm->streams[stream].substream;
+}
+
+#endif
diff --git a/sound/soc/soc-dsp.c b/sound/soc/soc-dsp.c
new file mode 100644
index 0000000..7938e8c
--- /dev/null
+++ b/sound/soc/soc-dsp.c
@@ -0,0 +1,1498 @@
+/*
+ * soc-dsp.c -- ALSA SoC Audio DSP
+ *
+ * Copyright (C) 2010 Texas Instruments Inc.
+ *
+ * Author: Liam Girdwood <lrg@slimlogic.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ */
+
+#define DEBUG
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/bitops.h>
+#include <linux/debugfs.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <sound/ac97_codec.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/soc-dsp.h>
+
+int soc_pcm_open(struct snd_pcm_substream *);
+void soc_pcm_close(struct snd_pcm_substream *);
+int soc_pcm_hw_params(struct snd_pcm_substream *, struct snd_pcm_hw_params *);
+int soc_pcm_hw_free(struct snd_pcm_substream *);
+int soc_pcm_prepare(struct snd_pcm_substream *);
+int soc_pcm_trigger(struct snd_pcm_substream *, int);
+int soc_pcm_bespoke_trigger(struct snd_pcm_substream *, int);
+
+static int is_be_supported(struct snd_soc_pcm_runtime *rtd, const char *link)
+{
+ struct snd_soc_dsp_link *dsp = rtd->dai_link->dsp_link;
+ int i;
+
+ for (i= 0; i < dsp->num_be; i++) {
+ if(!strcmp(dsp->supported_be[i], link))
+ return 1;
+ }
+ return 0;
+}
+
+static inline int be_connect(struct snd_soc_pcm_runtime *fe,
+ struct snd_soc_pcm_runtime *be, int stream)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ /* only add new dsp_paramss */
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+ if (dsp_params->be == be && dsp_params->fe == fe)
+ return 0;
+ }
+
+ dsp_params = kzalloc(sizeof(struct snd_soc_dsp_params), GFP_KERNEL);
+ if (!dsp_params)
+ return -ENOMEM;
+
+ dsp_params->be = be;
+ dsp_params->fe = fe;
+ be->dsp[stream].runtime = fe->dsp[stream].runtime;
+ dsp_params->state = SND_SOC_DSP_LINK_STATE_NEW;
+ list_add(&dsp_params->list_be, &fe->dsp[stream].be_clients);
+ list_add(&dsp_params->list_fe, &be->dsp[stream].fe_clients);
+
+ dev_dbg(&fe->dev, " connected new DSP %s path %s %s %s\n",
+ stream ? "capture" : "playback", fe->dai_link->name,
+ stream ? "<-" : "->", be->dai_link->name);
+
+#ifdef CONFIG_DEBUG_FS
+ dsp_params->debugfs_state = debugfs_create_u32(be->dai_link->name, 0644,
+ fe->debugfs_dsp_root, &dsp_params->state);
+#endif
+
+ return 1;
+}
+
+static inline void be_disconnect(struct snd_soc_pcm_runtime *fe, int stream)
+{
+ struct snd_soc_dsp_params *dsp_params, *d;
+
+ list_for_each_entry_safe(dsp_params, d, &fe->dsp[stream].be_clients, list_be) {
+ if (dsp_params->state == SND_SOC_DSP_LINK_STATE_FREE) {
+ dev_dbg(&fe->dev, " freed DSP %s path %s %s %s\n",
+ stream ? "capture" : "playback", fe->dai_link->name,
+ stream ? "<-" : "->", dsp_params->be->dai_link->name);
+
+#ifdef CONFIG_DEBUG_FS
+ debugfs_remove(dsp_params->debugfs_state);
+#endif
+
+ list_del(&dsp_params->list_be);
+ list_del(&dsp_params->list_fe);
+ kfree(dsp_params);
+ }
+ }
+}
+
+/*
+ * Find the corresponding BE DAIs that source or sink audio to this
+ * FE substream.
+ */
+static int dsp_add_new_paths(struct snd_soc_pcm_runtime *fe, int stream,
+ int pending)
+{
+ struct snd_soc_dai *cpu_dai = fe->cpu_dai;
+ struct snd_soc_card *card = fe->card;
+ int i, num, count = 0, err;
+ const char *fe_aif = NULL, *be_aif;
+ enum snd_soc_dapm_type fe_type, be_type;
+
+ dev_dbg(&fe->dev, "scan for new %s %s streams\n", fe->dai_link->name,
+ stream ? "capture" : "playback");
+
+ if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
+ fe_type = snd_soc_dapm_aif_in;
+ be_type = snd_soc_dapm_aif_out;
+ } else {
+ fe_type = snd_soc_dapm_aif_out;
+ be_type = snd_soc_dapm_aif_in;
+ }
+
+ /* search card for valid FE AIF that matches our DAI */
+ for (i = 0; i < card->num_links; i++) {
+ struct snd_soc_pcm_runtime *be = &card->rtd[i];
+
+ /* is this a BE DAI link ? */
+ if (be->dai_link->dynamic)
+ continue;
+
+ /* does this DAI have a AIF that matches ours ? */
+ fe_aif = snd_soc_dapm_get_aif(&be->platform->dapm,
+ cpu_dai->driver->name, fe_type);
+ if (fe_aif)
+ break;
+ }
+
+ if (fe_aif == NULL)
+ return 0;
+
+ /* search card for valid BE AIFs */
+ for (i = 0; i < card->num_links; i++) {
+ struct snd_soc_pcm_runtime *be = &card->rtd[i];
+
+ /* is this a BE DAI link ? */
+ if (be->dai_link->dynamic)
+ continue;
+
+ /* BEs must belong to this FE */
+ if (!be->dai_link->no_pcm)
+ continue;
+
+ /* BE must be supported by machine driver */
+ if (!is_be_supported(fe, be->dai_link->name))
+ continue;
+
+ /* get BE AIF */
+ be_aif = snd_soc_dapm_get_aif(&be->platform->dapm,
+ be->dai_link->stream_name, be_type);
+ if (be_aif == NULL)
+ continue;
+
+ /* check for valid dsp_params */
+ num = snd_soc_dapm_query_path(&be->platform->dapm,
+ fe_aif, be_aif, stream);
+
+ dev_dbg(&fe->dev, " scanned %s paths BE %s for stream %s num %d",
+ stream ? "capture" : "playback", be_aif,
+ be->dai_link->stream_name, num);
+
+ /* add backend if we have space */
+ if (num <= 0)
+ continue;
+
+ err = be_connect(fe, be, stream);
+ if (err < 0)
+ break;
+ else if (err == 0)
+ continue;
+
+ be->dsp[stream].runtime_update = pending;
+ count++;
+ }
+
+ /* the number of new paths created */
+ return count;
+}
+
+/*
+ * Find the corresponding BE DAIs that source or sink audio to this
+ * FE substream.
+ */
+static int dsp_prune_old_paths(struct snd_soc_pcm_runtime *fe, int stream,
+ int pending)
+{
+ struct snd_soc_dai *cpu_dai = fe->cpu_dai;
+ struct snd_soc_card *card = fe->card;
+ struct snd_soc_dsp_params *dsp_params;
+ int i, num, count = 0;
+ const char *fe_aif = NULL, *be_aif;
+ enum snd_soc_dapm_type fe_type, be_type;
+
+ dev_dbg(&fe->dev, "scan for old %s %s streams\n", fe->dai_link->name,
+ stream ? "capture" : "playback");
+
+ if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
+ fe_type = snd_soc_dapm_aif_in;
+ be_type = snd_soc_dapm_aif_out;
+ } else {
+ fe_type = snd_soc_dapm_aif_out;
+ be_type = snd_soc_dapm_aif_in;
+ }
+
+ /* search card for valid FE AIF that matches our DAI */
+ for (i = 0; i < card->num_links; i++) {
+ struct snd_soc_pcm_runtime *be = &card->rtd[i];
+
+ /* check for frontend */
+ if (be->dai_link->dynamic)
+ continue;
+
+ /* does this DAI have a AIF that matches ours ? */
+ fe_aif = snd_soc_dapm_get_aif(&be->platform->dapm,
+ cpu_dai->driver->name, fe_type);
+ if (fe_aif)
+ break;
+ }
+
+ if (fe_aif == NULL)
+ return 0;
+
+ /* search card for valid BE AIFs */
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+
+ /* get BE AIF */
+ be_aif = snd_soc_dapm_get_aif(&dsp_params->be->platform->dapm,
+ dsp_params->be->dai_link->stream_name, be_type);
+ if (be_aif == NULL) {
+ continue;
+ }
+
+ /* check for valid dsp_params */
+ num = snd_soc_dapm_query_path(&dsp_params->be->platform->dapm,
+ fe_aif, be_aif, stream);
+
+ dev_dbg(&fe->dev, " scanned %s paths BE %s for stream %s num %d",
+ stream ? "capture" : "playback", be_aif,
+ dsp_params->be->dai_link->stream_name, num);
+
+ /* prune backend if no longer used */
+ if (num > 0)
+ continue;
+
+ dsp_params->state = SND_SOC_DSP_LINK_STATE_FREE;
+ dsp_params->be->dsp[stream].runtime_update = pending;
+ count++;
+ }
+
+ /* the number of old paths pruned */
+ return count;
+}
+
+/*
+ * Update the state of all BE's with state old to state new.
+ */
+static void be_state_update(struct snd_soc_pcm_runtime *fe, int stream,
+ enum snd_soc_dsp_link_state old, enum snd_soc_dsp_link_state new)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+ if (dsp_params->state == old)
+ dsp_params->state = new;
+ }
+}
+
+/*
+ * Update the state of all BE's to new regardless of current state.
+ */
+static void fe_state_update(struct snd_soc_pcm_runtime *fe, int stream,
+ enum snd_soc_dsp_link_state new)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be)
+ dsp_params->state = new;
+}
+
+/*
+ * Clear the runtime pending state of all BE's.
+ */
+static void fe_clear_pending(struct snd_soc_pcm_runtime *fe, int stream)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be)
+ dsp_params->be->dsp[stream].runtime_update = 0;
+}
+
+/* Unwind the BE startup */
+static void soc_dsp_be_dai_startup_unwind(struct snd_soc_pcm_runtime *fe, int stream)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ /* disable any enabled and non active backends */
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+
+ struct snd_pcm_substream *be_substream =
+ snd_soc_dsp_get_substream(dsp_params->be, stream);
+
+ if (--dsp_params->be->dsp[stream].users != 0)
+ continue;
+
+ if (dsp_params->state != SND_SOC_DSP_LINK_STATE_NEW)
+ continue;
+
+ soc_pcm_close(be_substream);
+ be_substream->runtime = NULL;
+ }
+}
+
+/* Startup all new BE */
+static int soc_dsp_be_dai_startup(struct snd_soc_pcm_runtime *fe, int stream)
+{
+ struct snd_soc_dsp_params *dsp_params;
+ int err, count = 0;
+
+ /* only startup BE DAIs that are either sinks or sources to this FE DAI */
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+
+ struct snd_pcm_substream *be_substream =
+ snd_soc_dsp_get_substream(dsp_params->be, stream);
+
+ /* is this op for this BE ? */
+ if (fe->dsp[stream].runtime_update &&
+ !dsp_params->be->dsp[stream].runtime_update)
+ continue;
+
+ /* first time the dsp_params is open ? */
+ if (dsp_params->be->dsp[stream].users++ != 0)
+ continue;
+
+ /* only open and ref count new links */
+ if (dsp_params->state != SND_SOC_DSP_LINK_STATE_NEW)
+ continue;
+
+ dev_dbg(&dsp_params->be->dev, "dsp: open BE %s\n",
+ dsp_params->be->dai_link->name);
+
+ be_substream->runtime = dsp_params->be->dsp[stream].runtime;
+ err = soc_pcm_open(be_substream);
+ if (err < 0)
+ goto unwind;
+ count++;
+ }
+
+ /* update BE state */
+ be_state_update(fe, stream,
+ SND_SOC_DSP_LINK_STATE_NEW, SND_SOC_DSP_LINK_STATE_HW_PARAMS);
+ return count;
+
+unwind:
+ /* disable any enabled and non active backends */
+ list_for_each_entry_continue_reverse(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+
+ struct snd_pcm_substream *be_substream =
+ snd_soc_dsp_get_substream(dsp_params->be, stream);
+
+ if (fe->dsp[stream].runtime_update &&
+ !dsp_params->be->dsp[stream].runtime_update)
+ continue;
+
+ if (--dsp_params->be->dsp[stream].users != 0)
+ continue;
+
+ if (dsp_params->state != SND_SOC_DSP_LINK_STATE_NEW)
+ continue;
+
+ soc_pcm_close(be_substream);
+ be_substream->runtime = NULL;
+ }
+
+ /* update BE state for disconnect */
+ be_state_update(fe, stream,
+ SND_SOC_DSP_LINK_STATE_NEW, SND_SOC_DSP_LINK_STATE_FREE);
+ return err;
+}
+
+void soc_dsp_set_dynamic_runtime(struct snd_pcm_substream *substream)
+{
+ struct snd_pcm_runtime *runtime = substream->runtime;
+ struct snd_soc_pcm_runtime *rtd = substream->private_data;
+ struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
+ struct snd_soc_dai_driver *cpu_dai_drv = cpu_dai->driver;
+
+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+ runtime->hw.rate_min = cpu_dai_drv->playback.rate_min;
+ runtime->hw.rate_max = cpu_dai_drv->playback.rate_max;
+ runtime->hw.channels_min = cpu_dai_drv->playback.channels_min;
+ runtime->hw.channels_max = cpu_dai_drv->playback.channels_max;
+ runtime->hw.formats &= cpu_dai_drv->playback.formats;
+ runtime->hw.rates = cpu_dai_drv->playback.rates;
+ } else {
+ runtime->hw.rate_min = cpu_dai_drv->capture.rate_min;
+ runtime->hw.rate_max = cpu_dai_drv->capture.rate_max;
+ runtime->hw.channels_min = cpu_dai_drv->capture.channels_min;
+ runtime->hw.channels_max = cpu_dai_drv->capture.channels_max;
+ runtime->hw.formats &= cpu_dai_drv->capture.formats;
+ runtime->hw.rates = cpu_dai_drv->capture.rates;
+ }
+}
+
+static int soc_dsp_fe_dai_startup(struct snd_pcm_substream *fe_substream)
+{
+ struct snd_soc_pcm_runtime *fe = fe_substream->private_data;
+ struct snd_pcm_runtime *runtime = fe_substream->runtime;
+ int ret = 0;
+
+ mutex_lock(&fe->card->dsp_mutex);
+
+ ret = soc_dsp_be_dai_startup(fe, fe_substream->stream);
+ if (ret < 0)
+ goto be_err;
+
+ dev_dbg(&fe->dev, "dsp: open FE %s\n", fe->dai_link->name);
+
+ /* start the DAI frontend */
+ ret = soc_pcm_open(fe_substream);
+ if (ret < 0) {
+ dev_err(&fe->dev,"dsp: failed to start FE %d\n", ret);
+ goto unwind;
+ }
+
+ soc_dsp_set_dynamic_runtime(fe_substream);
+ snd_pcm_limit_hw_rates(runtime);
+
+ mutex_unlock(&fe->card->dsp_mutex);
+ return 0;
+
+unwind:
+ soc_dsp_be_dai_startup_unwind(fe, fe_substream->stream);
+be_err:
+ mutex_unlock(&fe->card->dsp_mutex);
+ return ret;
+}
+
+/* BE shutdown - called on DAPM sync updates (i.e. FE is already running)*/
+static int soc_dsp_be_dai_shutdown(struct snd_soc_pcm_runtime *fe, int stream)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ /* only shutdown backends that are either sinks or sources to this frontend DAI */
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+
+ struct snd_pcm_substream *be_substream =
+ snd_soc_dsp_get_substream(dsp_params->be, stream);
+
+ /* is this op for this BE ? */
+ if (fe->dsp[stream].runtime_update &&
+ !dsp_params->be->dsp[stream].runtime_update)
+ continue;
+
+ if (--dsp_params->be->dsp[stream].users != 0)
+ continue;
+
+ if (dsp_params->state != SND_SOC_DSP_LINK_STATE_FREE)
+ continue;
+
+ dev_dbg(&dsp_params->be->dev, "dsp: close BE %s\n",
+ dsp_params->fe->dai_link->name);
+
+ soc_pcm_close(be_substream);
+ be_substream->runtime = NULL;
+ }
+ return 0;
+}
+
+/* FE +BE shutdown - called on FE PCM ops */
+static int soc_dsp_fe_dai_shutdown(struct snd_pcm_substream *substream)
+{
+ struct snd_soc_pcm_runtime *fe = substream->private_data;
+ int stream = substream->stream;
+
+ mutex_lock(&fe->card->dsp_mutex);
+
+ /* shutdown the BEs */
+ soc_dsp_be_dai_shutdown(fe, substream->stream);
+
+ dev_dbg(&fe->dev, "dsp: close FE %s\n", fe->dai_link->name);
+
+ /* now shutdown the frontend */
+ soc_pcm_close(substream);
+
+ /* run the stream event for each BE */
+ if (stream == SNDRV_PCM_STREAM_PLAYBACK)
+ soc_dsp_dapm_stream_event(fe, stream,
+ fe->cpu_dai->driver->playback.stream_name,
+ SND_SOC_DAPM_STREAM_STOP);
+ else
+ soc_dsp_dapm_stream_event(fe, stream,
+ fe->cpu_dai->driver->capture.stream_name,
+ SND_SOC_DAPM_STREAM_STOP);
+
+ mutex_unlock(&fe->card->dsp_mutex);
+ return 0;
+}
+
+static int soc_dsp_be_dai_hw_params(struct snd_soc_pcm_runtime *fe, int stream)
+{
+ struct snd_soc_dsp_params *dsp_params;
+ int ret;
+
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+
+ struct snd_pcm_substream *be_substream =
+ snd_soc_dsp_get_substream(dsp_params->be, stream);
+
+ /* is this op for this BE ? */
+ if (fe->dsp[stream].runtime_update &&
+ !dsp_params->be->dsp[stream].runtime_update)
+ continue;
+
+ if (dsp_params->state != SND_SOC_DSP_LINK_STATE_HW_PARAMS)
+ continue;
+
+ /* first time the dsp_params is open ? */
+ if (dsp_params->be->dsp[stream].users != 1)
+ continue;
+
+ dev_dbg(&dsp_params->be->dev, "dsp: hw_params BE %s\n",
+ dsp_params->fe->dai_link->name);
+
+ /* copy params for each dsp_params */
+ memcpy(&dsp_params->params, &fe->dsp[stream].params,
+ sizeof(struct snd_pcm_hw_params));
+
+ /* perform any hw_params fixups */
+ if (dsp_params->be->dai_link->be_hw_params_fixup) {
+ ret = dsp_params->be->dai_link->be_hw_params_fixup(dsp_params->be,
+ &dsp_params->params);
+ if (ret < 0) {
+ dev_err(&dsp_params->be->dev,
+ "dsp: hw_params BE fixup failed %d\n", ret);
+ return ret;
+ }
+ }
+
+ ret = soc_pcm_hw_params(be_substream, &dsp_params->params);
+ if (ret < 0) {
+ dev_err(&dsp_params->be->dev, "dsp: hw_params BE failed %d\n", ret);
+ return ret;
+ }
+ }
+ return 0;
+}
+
+int soc_dsp_fe_dai_hw_params(struct snd_pcm_substream *substream,
+ struct snd_pcm_hw_params *params)
+{
+ struct snd_soc_pcm_runtime *fe = substream->private_data;
+ int ret;
+
+ mutex_lock(&fe->card->dsp_mutex);
+
+ memcpy(&fe->dsp[substream->stream].params, params,
+ sizeof(struct snd_pcm_hw_params));
+ ret = soc_dsp_be_dai_hw_params(fe, substream->stream);
+ if (ret < 0)
+ goto out;
+
+ dev_dbg(&fe->dev, "dsp: hw_params FE %s\n", fe->dai_link->name);
+
+ /* call hw_params on the frontend */
+ ret = soc_pcm_hw_params(substream, params);
+ if (ret < 0)
+ dev_err(&fe->dev,"dsp: hw_params FE failed %d\n", ret);
+
+out:
+ mutex_unlock(&fe->card->dsp_mutex);
+ return ret;
+}
+
+static int dsp_do_trigger(struct snd_soc_dsp_params *dsp_params,
+ struct snd_pcm_substream *substream, int cmd)
+{
+ int ret;
+
+ dev_dbg(&dsp_params->be->dev, "dsp: trigger BE %s cmd %d\n",
+ dsp_params->fe->dai_link->name, cmd);
+
+ ret = soc_pcm_trigger(substream, cmd);
+ if (ret < 0)
+ dev_err(&dsp_params->be->dev,"dsp: trigger BE failed %d\n", ret);
+
+ return ret;
+}
+
+int soc_dsp_be_dai_trigger(struct snd_soc_pcm_runtime *fe, int stream, int cmd)
+{
+ struct snd_soc_dsp_params *dsp_params;
+ int ret = 0;
+
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+
+ struct snd_pcm_substream *be_substream =
+ snd_soc_dsp_get_substream(dsp_params->be, stream);
+
+ /* is this op for this BE ? */
+ if (fe->dsp[stream].runtime_update &&
+ !dsp_params->be->dsp[stream].runtime_update)
+ continue;
+
+ switch (cmd) {
+ case SNDRV_PCM_TRIGGER_START:
+ /* only start BEs that are not triggered */
+ if (dsp_params->state == SND_SOC_DSP_LINK_STATE_PREPARE) {
+ ret = dsp_do_trigger(dsp_params, be_substream, cmd);
+ if (ret == 0)
+ dsp_params->state = SND_SOC_DSP_LINK_STATE_START;
+ }
+ break;
+ case SNDRV_PCM_TRIGGER_STOP:
+ /* only stop BEs that are being shutdown */
+ if (dsp_params->state == SND_SOC_DSP_LINK_STATE_FREE &&
+ dsp_params->be->dsp[stream].users == 1)
+ ret = dsp_do_trigger(dsp_params, be_substream, cmd);
+ break;
+ case SNDRV_PCM_TRIGGER_SUSPEND:
+ case SNDRV_PCM_TRIGGER_RESUME:
+ /* suspend and resume all BEs */
+ ret = dsp_do_trigger(dsp_params, be_substream, cmd);
+ break;
+ case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+ /* only release Paused BEs */
+ if (dsp_params->state == SND_SOC_DSP_LINK_STATE_PAUSED) {
+ ret = dsp_do_trigger(dsp_params, be_substream, cmd);
+ if (ret == 0)
+ dsp_params->state = SND_SOC_DSP_LINK_STATE_START;
+ }
+ break;
+ case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+ /* only pause active BEs */
+ if (dsp_params->state == SND_SOC_DSP_LINK_STATE_START) {
+ ret = dsp_do_trigger(dsp_params, be_substream, cmd);
+ if (ret == 0)
+ dsp_params->state = SND_SOC_DSP_LINK_STATE_PAUSED;
+ }
+ break;
+ }
+ if (ret < 0)
+ return ret;
+ }
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(soc_dsp_be_dai_trigger);
+
+int soc_dsp_fe_dai_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+ struct snd_soc_pcm_runtime *fe = substream->private_data;
+ struct snd_soc_dsp_link *dsp_link = fe->dai_link->dsp_link;
+ int stream = substream->stream, ret;
+
+ switch (dsp_link->trigger[stream]) {
+ case SND_SOC_DSP_TRIGGER_PRE:
+ /* call trigger on the frontend before the backend. */
+
+ dev_dbg(&fe->dev, "dsp: pre trigger FE %s cmd %d\n",
+ fe->dai_link->name, cmd);
+
+ ret = soc_pcm_trigger(substream, cmd);
+ if (ret < 0) {
+ dev_err(&fe->dev,"dsp: trigger FE failed %d\n", ret);
+ return ret;
+ }
+
+ ret = soc_dsp_be_dai_trigger(fe, substream->stream, cmd);
+ break;
+ case SND_SOC_DSP_TRIGGER_POST:
+ /* call trigger on the frontend after the backend. */
+
+ ret = soc_dsp_be_dai_trigger(fe, substream->stream, cmd);
+ if (ret < 0) {
+ dev_err(&fe->dev,"dsp: trigger FE failed %d\n", ret);
+ return ret;
+ }
+
+ dev_dbg(&fe->dev, "dsp: post trigger FE %s cmd %d\n",
+ fe->dai_link->name, cmd);
+
+ ret = soc_pcm_trigger(substream, cmd);
+ break;
+ case SND_SOC_DSP_TRIGGER_BESPOKE:
+ /* bespoke trigger() - handles both FE and BEs */
+
+ dev_dbg(&fe->dev, "dsp: bespoke trigger FE %s cmd %d\n",
+ fe->dai_link->name, cmd);
+
+ ret = soc_pcm_bespoke_trigger(substream, cmd);
+ if (ret < 0) {
+ dev_err(&fe->dev,"dsp: trigger FE failed %d\n", ret);
+ return ret;
+ }
+ break;
+ default:
+ dev_err(&fe->dev, "dsp: invalid trigger cmd %d for %s\n", cmd,
+ fe->dai_link->name);
+ return -EINVAL;
+ }
+
+ return ret;
+}
+
+static int soc_dsp_be_dai_prepare(struct snd_soc_pcm_runtime *fe, int stream)
+{
+ struct snd_soc_dsp_params *dsp_params;
+ int ret = 0;
+
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+
+ struct snd_pcm_substream *be_substream =
+ snd_soc_dsp_get_substream(dsp_params->be, stream);
+
+ /* is this op for this BE ? */
+ if (fe->dsp[stream].runtime_update &&
+ !dsp_params->be->dsp[stream].runtime_update)
+ continue;
+
+ /* only prepare ACTIVE or READY BE's */
+ if (dsp_params->state == SND_SOC_DSP_LINK_STATE_NEW ||
+ dsp_params->state == SND_SOC_DSP_LINK_STATE_FREE)
+ continue;
+
+ dev_dbg(&dsp_params->be->dev, "dsp: prepare BE %s\n",
+ dsp_params->fe->dai_link->name);
+
+ ret = soc_pcm_prepare(be_substream);
+ if (ret < 0) {
+ dev_err(&dsp_params->be->dev,"dsp: backend prepare failed %d\n",
+ ret);
+ break;
+ }
+
+ /* mark the BE as active */
+ be_state_update(fe, stream, SND_SOC_DSP_LINK_STATE_HW_PARAMS,
+ SND_SOC_DSP_LINK_STATE_PREPARE);
+ }
+ return ret;
+}
+
+int soc_dsp_fe_dai_prepare(struct snd_pcm_substream *substream)
+{
+ struct snd_soc_pcm_runtime *fe = substream->private_data;
+ int stream = substream->stream, ret = 0;
+
+ mutex_lock(&fe->card->dsp_mutex);
+
+ dev_dbg(&fe->dev, "dsp: prepare FE %s\n", fe->dai_link->name);
+
+ /* there is no point preparing this FE if there are no BEs */
+ if (list_empty(&fe->dsp[stream].be_clients)) {
+ dev_err(&fe->dev, "dsp: no backend DAIs enabled for %s\n",
+ fe->dai_link->name);
+ ret = -EINVAL;
+ goto out;
+ }
+
+ ret = soc_dsp_be_dai_prepare(fe, substream->stream);
+ if (ret < 0)
+ goto out;
+
+ /* mark the BE as active */
+ fe_state_update(fe, stream, SND_SOC_DSP_LINK_STATE_PREPARE);
+
+ /* call prepare on the frontend */
+ ret = soc_pcm_prepare(substream);
+ if (ret < 0) {
+ dev_err(&fe->dev,"dsp: prepare FE %s failed\n", fe->dai_link->name);
+ goto out;
+ }
+
+ /* run the stream event for each BE */
+ if (stream == SNDRV_PCM_STREAM_PLAYBACK)
+ soc_dsp_dapm_stream_event(fe, stream,
+ fe->cpu_dai->driver->playback.stream_name,
+ SNDRV_PCM_TRIGGER_START);
+ else
+ soc_dsp_dapm_stream_event(fe, stream,
+ fe->cpu_dai->driver->capture.stream_name,
+ SNDRV_PCM_TRIGGER_START);
+
+out:
+ mutex_unlock(&fe->card->dsp_mutex);
+ return ret;
+}
+
+static int soc_dsp_be_dai_hw_free(struct snd_soc_pcm_runtime *fe, int stream)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ /* only hw_params backends that are either sinks or sources
+ * to this frontend DAI */
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+
+ struct snd_pcm_substream *be_substream =
+ snd_soc_dsp_get_substream(dsp_params->be, stream);
+
+ /* is this op for this BE ? */
+ if (fe->dsp[stream].runtime_update &&
+ !dsp_params->be->dsp[stream].runtime_update)
+ continue;
+
+ if (dsp_params->state != SND_SOC_DSP_LINK_STATE_FREE)
+ continue;
+
+ /* only free hw when no longer used */
+ if (dsp_params->be->dsp[stream].users != 1)
+ continue;
+
+ dev_dbg(&dsp_params->be->dev, "dsp: hw_free BE %s\n",
+ dsp_params->fe->dai_link->name);
+
+ soc_pcm_hw_free(be_substream);
+ }
+
+ return 0;
+}
+
+int soc_dsp_fe_dai_hw_free(struct snd_pcm_substream *substream)
+{
+ struct snd_soc_pcm_runtime *fe = substream->private_data;
+ int ret, stream = substream->stream;
+
+ mutex_lock(&fe->card->dsp_mutex);
+
+ fe_state_update(fe, stream, SND_SOC_DSP_LINK_STATE_FREE);
+
+ dev_dbg(&fe->dev, "dsp: hw_free FE %s\n", fe->dai_link->name);
+
+ /* call hw_free on the frontend */
+ ret = soc_pcm_hw_free(substream);
+ if (ret < 0)
+ dev_err(&fe->dev,"dsp: hw_free FE %s failed\n", fe->dai_link->name);
+
+ /* only hw_params backends that are either sinks or sources
+ * to this frontend DAI */
+ ret = soc_dsp_be_dai_hw_free(fe, stream);
+
+ mutex_unlock(&fe->card->dsp_mutex);
+ return ret;
+}
+
+/*
+ * FE stream event, send event to all active BEs.
+ */
+int soc_dsp_dapm_stream_event(struct snd_soc_pcm_runtime *fe,
+ int dir, const char *stream, int event)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ /* resume for playback */
+ list_for_each_entry(dsp_params, &fe->dsp[dir].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+
+ dev_dbg(&be->dev, "pm: BE %s stream %s event %d dir %d\n",
+ be->dai_link->name, stream, event, dir);
+
+ snd_soc_dapm_stream_event(be, stream, event);
+ }
+
+ return 0;
+}
+
+static int dsp_run_update_shutdown(struct snd_soc_pcm_runtime *fe, int stream)
+{
+ struct snd_soc_dsp_link *dsp_link = fe->dai_link->dsp_link;
+ struct snd_pcm_substream *substream = snd_soc_dsp_get_substream(fe, stream);
+ struct snd_soc_dsp_params *dsp_params;
+ int ret;
+
+ dev_dbg(&fe->dev, "runtime %s close on FE %s\n",
+ stream ? "capture" : "playback", fe->dai_link->name);
+
+ if (dsp_link->trigger[stream] == SND_SOC_DSP_TRIGGER_BESPOKE) {
+ /* call bespoke trigger - FE takes care of all BE triggers */
+ dev_dbg(&fe->dev, "dsp: bespoke trigger FE %s cmd stop\n",
+ fe->dai_link->name);
+
+ ret = soc_pcm_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_STOP);
+ if (ret < 0) {
+ dev_err(&fe->dev,"dsp: trigger FE failed %d\n", ret);
+ return ret;
+ }
+ } else {
+
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+
+ dev_dbg(&fe->dev, "dsp: trigger FE %s cmd stop\n",
+ fe->dai_link->name);
+
+ ret = soc_dsp_be_dai_trigger(fe, stream, SNDRV_PCM_TRIGGER_STOP);
+ if (ret < 0)
+ return ret;
+ }
+ }
+
+ ret = soc_dsp_be_dai_hw_free(fe, stream);
+ if (ret < 0)
+ return ret;
+
+ ret = soc_dsp_be_dai_shutdown(fe, stream);
+ if (ret < 0)
+ return ret;
+
+ /* run the stream event for each BE */
+ if (stream == SNDRV_PCM_STREAM_PLAYBACK)
+ soc_dsp_dapm_stream_event(fe, stream,
+ fe->cpu_dai->driver->playback.stream_name,
+ SNDRV_PCM_TRIGGER_STOP);
+ else
+ soc_dsp_dapm_stream_event(fe, stream,
+ fe->cpu_dai->driver->capture.stream_name,
+ SNDRV_PCM_TRIGGER_STOP);
+
+ return 0;
+}
+
+/* check for running FEs */
+static int dsp_get_be_trigger_cmd(struct snd_soc_pcm_runtime *fe, int stream)
+{
+ struct snd_soc_dsp_params *dsp_be_params, *dsp_fe_params;
+
+ /* get the FEs for each BE */
+ list_for_each_entry(dsp_be_params, &fe->dsp[stream].be_clients, list_be) {
+ struct snd_soc_pcm_runtime *be = dsp_be_params->be;
+
+ /* get the FEs for this BE */
+ list_for_each_entry(dsp_fe_params, &be->dsp[stream].fe_clients, list_fe) {
+
+ if (dsp_fe_params->state == SND_SOC_DSP_LINK_STATE_START)
+ return SND_SOC_DSP_LINK_STATE_START;
+ }
+ }
+ return SND_SOC_DSP_LINK_STATE_PAUSED;
+}
+
+/* check for running BEs */
+static int dsp_get_fe_trigger_cmd(struct snd_soc_pcm_runtime *fe, int stream)
+{
+ struct snd_soc_dsp_params *dsp_be_params;
+
+ /* get the FEs for each BE */
+ list_for_each_entry(dsp_be_params, &fe->dsp[stream].be_clients, list_be) {
+
+ if (dsp_be_params->state == SND_SOC_DSP_LINK_STATE_START)
+ return SND_SOC_DSP_LINK_STATE_START;
+ }
+ return SND_SOC_DSP_LINK_STATE_PAUSED;
+}
+
+static int dsp_run_update_startup(struct snd_soc_pcm_runtime *fe, int stream)
+{
+ struct snd_soc_dsp_link *dsp_link = fe->dai_link->dsp_link;
+ struct snd_pcm_substream *substream = snd_soc_dsp_get_substream(fe, stream);
+ struct snd_soc_dsp_params *dsp_params;
+ int ret, cmd;
+
+ dev_dbg(&fe->dev, "runtime %s open on FE %s\n",
+ stream ? "capture" : "playback", fe->dai_link->name);
+
+ ret = soc_dsp_be_dai_startup(fe, stream);
+ if (ret < 0)
+ return ret;
+
+ ret = soc_dsp_be_dai_hw_params(fe, stream);
+ if (ret < 0)
+ return ret;
+
+ ret = soc_dsp_be_dai_prepare(fe, stream);
+ if (ret < 0)
+ return ret;
+
+ /* run the stream event for each BE */
+ if (stream == SNDRV_PCM_STREAM_PLAYBACK)
+ soc_dsp_dapm_stream_event(fe, stream,
+ fe->cpu_dai->driver->playback.stream_name,
+ SNDRV_PCM_TRIGGER_START);
+ else
+ soc_dsp_dapm_stream_event(fe, stream,
+ fe->cpu_dai->driver->capture.stream_name,
+ SNDRV_PCM_TRIGGER_START);
+
+ if (dsp_link->trigger[stream] == SND_SOC_DSP_TRIGGER_BESPOKE) {
+
+ /* there is no point in triggering START iff all BEs are PAUSED */
+ cmd = dsp_get_fe_trigger_cmd(fe, stream);
+
+ /* call trigger on the frontend - FE takes care of all BE triggers */
+ dev_dbg(&fe->dev, "dsp: bespoke trigger FE %s cmd start\n",
+ fe->dai_link->name);
+
+ ret = soc_pcm_bespoke_trigger(substream, cmd);
+ if (ret < 0) {
+ dev_err(&fe->dev,"dsp: trigger FE failed %d\n", ret);
+ return ret;
+ }
+
+ /* successful trigger so update BE trigger status */
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+
+ /* is this op for this BE ? */
+ if (fe->dsp[stream].runtime_update &&
+ !dsp_params->be->dsp[stream].runtime_update)
+ continue;
+
+ switch (cmd) {
+ case SNDRV_PCM_TRIGGER_START:
+ case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+ case SNDRV_PCM_TRIGGER_RESUME:
+ dsp_params->state = SND_SOC_DSP_LINK_STATE_START;
+ break;
+ case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+ case SNDRV_PCM_TRIGGER_STOP:
+ case SNDRV_PCM_TRIGGER_SUSPEND:
+ dsp_params->state = SND_SOC_DSP_LINK_STATE_PAUSED;
+ break;
+ }
+ }
+ } else {
+
+ list_for_each_entry(dsp_params, &fe->dsp[stream].be_clients, list_be) {
+
+ /* there is no point in triggering start iff all FEs are PAUSED */
+ cmd = dsp_get_be_trigger_cmd(fe, stream);
+
+ dev_dbg(&fe->dev, "dsp: trigger FE %s cmd start\n",
+ fe->dai_link->name);
+
+ ret = soc_dsp_be_dai_trigger(fe, stream, cmd);
+ if (ret < 0)
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static int dsp_run_update(struct snd_soc_pcm_runtime *fe, int stream,
+ int start, int stop)
+{
+ int ret = 0;
+
+ fe->dsp[stream].runtime_update = 1;
+
+ /* startup any new BEs */
+ if (start) {
+ ret = dsp_run_update_startup(fe, stream);
+ if (ret < 0)
+ dev_err(&fe->dev, "failed to startup BEs\n");
+ }
+
+ /* close down old BEs */
+ if (stop) {
+ ret = dsp_run_update_shutdown(fe, stream);
+ if (ret < 0)
+ dev_err(&fe->dev, "failed to shutdown BEs\n");
+ }
+
+ fe->dsp[stream].runtime_update = 0;
+
+ return ret;
+}
+
+/* called when any mixer updates change FE -> BE the stream */
+int soc_dsp_runtime_update(struct snd_soc_dapm_widget *widget)
+{
+ struct snd_soc_card *card;
+ int i, ret = 0, start, stop;
+
+ if (widget->codec)
+ card = widget->codec->card;
+ else if (widget->platform)
+ card = widget->platform->card;
+ else
+ return -EINVAL;
+
+ mutex_lock(&widget->dapm->card->dsp_mutex);
+
+ for (i = 0; i < card->num_rtd; i++) {
+ struct snd_soc_pcm_runtime *fe = &card->rtd[i];
+
+ /* make sure link is BE */
+ if (!fe->dai_link->dsp_link)
+ continue;
+
+ /* only check active links */
+ if (!fe->cpu_dai->active) {
+ continue;
+ }
+
+ /* DAPM sync will call this to update DSP paths */
+ dev_dbg(card->dev, "DSP runtime update for FE %s\n", fe->dai_link->name);
+
+ /* update any playback paths */
+ start = dsp_add_new_paths(fe, SNDRV_PCM_STREAM_PLAYBACK, 1);
+ stop = dsp_prune_old_paths(fe, SNDRV_PCM_STREAM_PLAYBACK, 1);
+ if (!(start || stop))
+ goto capture;
+
+ /* run PCM ops on new/old playback paths */
+ ret = dsp_run_update(fe, SNDRV_PCM_STREAM_PLAYBACK, start, stop);
+ if (ret < 0) {
+ dev_err(&fe->dev, "failed to update playback FE stream %s\n",
+ fe->dai_link->stream_name);
+ }
+
+ /* free old playback links */
+ be_disconnect(fe, SNDRV_PCM_STREAM_PLAYBACK);
+ fe_clear_pending(fe, SNDRV_PCM_STREAM_PLAYBACK);
+
+capture:
+ /* update any capture paths */
+ start = dsp_add_new_paths(fe, SNDRV_PCM_STREAM_CAPTURE, 1);
+ stop = dsp_prune_old_paths(fe, SNDRV_PCM_STREAM_CAPTURE, 1);
+ if (!(start || stop))
+ continue;
+
+ /* run PCM ops on new/old capture paths */
+ ret = dsp_run_update(fe, SNDRV_PCM_STREAM_CAPTURE, start, stop);
+ if (ret < 0) {
+ dev_err(&fe->dev, "failed to update capture FE stream %s\n",
+ fe->dai_link->stream_name);
+ }
+
+ /* free old capture links */
+ be_disconnect(fe, SNDRV_PCM_STREAM_CAPTURE);
+ fe_clear_pending(fe, SNDRV_PCM_STREAM_CAPTURE);
+ }
+
+ mutex_unlock(&widget->dapm->card->dsp_mutex);
+ return ret;
+}
+
+int soc_dsp_be_digital_mute(struct snd_soc_pcm_runtime *fe, int mute)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_PLAYBACK].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_dai *dai = be->codec_dai;
+ struct snd_soc_dai_driver *drv = dai->driver;
+
+ dev_dbg(&be->dev, "BE digital mute %s\n", be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->ops->digital_mute && dai->playback_active)
+ drv->ops->digital_mute(dai, mute);
+ }
+
+ return 0;
+}
+
+int soc_dsp_be_cpu_dai_suspend(struct snd_soc_pcm_runtime *fe)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ /* suspend for playback */
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_PLAYBACK].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_dai *dai = be->cpu_dai;
+ struct snd_soc_dai_driver *drv = dai->driver;
+
+ dev_dbg(&be->dev, "pm: BE CPU DAI playback suspend %s\n",
+ be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->suspend && !drv->ac97_control)
+ drv->suspend(dai);
+ }
+
+ /* suspend for capture */
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_CAPTURE].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_dai *dai = be->cpu_dai;
+ struct snd_soc_dai_driver *drv = dai->driver;
+
+ dev_dbg(&be->dev, "pm: BE CPU DAI capture suspend %s\n",
+ be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->suspend && !drv->ac97_control)
+ drv->suspend(dai);
+ }
+
+ return 0;
+}
+
+int soc_dsp_be_ac97_cpu_dai_suspend(struct snd_soc_pcm_runtime *fe)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ /* suspend for playback */
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_PLAYBACK].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_dai *dai = be->cpu_dai;
+ struct snd_soc_dai_driver *drv = dai->driver;
+
+ dev_dbg(&be->dev, "pm: BE CPU DAI playback suspend %s\n",
+ be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->suspend && drv->ac97_control)
+ drv->suspend(dai);
+ }
+
+ /* suspend for capture */
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_CAPTURE].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_dai *dai = be->cpu_dai;
+ struct snd_soc_dai_driver *drv = dai->driver;
+
+ dev_dbg(&be->dev, "pm: BE CPU DAI capture suspend %s\n",
+ be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->suspend && drv->ac97_control)
+ drv->suspend(dai);
+ }
+
+ return 0;
+}
+
+int soc_dsp_be_platform_suspend(struct snd_soc_pcm_runtime *fe)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ /* suspend for playback */
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_PLAYBACK].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_platform *platform = be->platform;
+ struct snd_soc_platform_driver *drv = platform->driver;
+ struct snd_soc_dai *dai = be->cpu_dai;
+
+ dev_dbg(&be->dev, "pm: BE platform playback suspend %s\n",
+ be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->suspend && !platform->suspended) {
+ drv->suspend(dai);
+ platform->suspended = 1;
+ }
+ }
+
+ /* suspend for capture */
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_CAPTURE].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_platform *platform = be->platform;
+ struct snd_soc_platform_driver *drv = platform->driver;
+ struct snd_soc_dai *dai = be->cpu_dai;
+
+ dev_dbg(&be->dev, "pm: BE platform capture suspend %s\n",
+ be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->suspend && !platform->suspended) {
+ drv->suspend(dai);
+ platform->suspended = 1;
+ }
+ }
+
+ return 0;
+}
+
+int soc_dsp_be_cpu_dai_resume(struct snd_soc_pcm_runtime *fe)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ /* resume for playback */
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_PLAYBACK].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_dai *dai = be->cpu_dai;
+ struct snd_soc_dai_driver *drv = dai->driver;
+
+ dev_dbg(&be->dev, "pm: BE CPU DAI playback resume %s\n",
+ be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->resume && !drv->ac97_control)
+ drv->resume(dai);
+ }
+
+ /* suspend for capture */
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_CAPTURE].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_dai *dai = be->cpu_dai;
+ struct snd_soc_dai_driver *drv = dai->driver;
+
+ dev_dbg(&be->dev, "pm: BE CPU DAI capture resume %s\n",
+ be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->resume && !drv->ac97_control)
+ drv->resume(dai);
+ }
+
+ return 0;
+}
+
+int soc_dsp_be_ac97_cpu_dai_resume(struct snd_soc_pcm_runtime *fe)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ /* resume for playback */
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_PLAYBACK].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_dai *dai = be->cpu_dai;
+ struct snd_soc_dai_driver *drv = dai->driver;
+
+ dev_dbg(&be->dev, "pm: BE CPU DAI playback resume %s\n",
+ be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->resume && drv->ac97_control)
+ drv->resume(dai);
+ }
+
+ /* suspend for capture */
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_CAPTURE].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_dai *dai = be->cpu_dai;
+ struct snd_soc_dai_driver *drv = dai->driver;
+
+ dev_dbg(&be->dev, "pm: BE CPU DAI capture resume %s\n",
+ be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->resume && drv->ac97_control)
+ drv->resume(dai);
+ }
+
+ return 0;
+}
+
+int soc_dsp_be_platform_resume(struct snd_soc_pcm_runtime *fe)
+{
+ struct snd_soc_dsp_params *dsp_params;
+
+ /* resume for playback */
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_PLAYBACK].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_platform *platform = be->platform;
+ struct snd_soc_platform_driver *drv = platform->driver;
+ struct snd_soc_dai *dai = be->cpu_dai;
+
+ dev_dbg(&be->dev, "pm: BE platform playback resume %s\n",
+ be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->resume && platform->suspended) {
+ drv->resume(dai);
+ platform->suspended = 0;
+ }
+ }
+
+ /* resume for capture */
+ list_for_each_entry(dsp_params,
+ &fe->dsp[SNDRV_PCM_STREAM_CAPTURE].be_clients, list_be) {
+
+ struct snd_soc_pcm_runtime *be = dsp_params->be;
+ struct snd_soc_platform *platform = be->platform;
+ struct snd_soc_platform_driver *drv = platform->driver;
+ struct snd_soc_dai *dai = be->cpu_dai;
+
+ dev_dbg(&be->dev, "pm: BE platform capture resume %s\n",
+ be->dai_link->name);
+
+ if (be->dai_link->ignore_suspend)
+ continue;
+
+ if (drv->resume && platform->suspended) {
+ drv->resume(dai);
+ platform->suspended = 0;
+ }
+ }
+
+ return 0;
+}
+
+/* called when opening FE stream */
+int soc_dsp_fe_dai_open(struct snd_pcm_substream *fe_substream)
+{
+ struct snd_soc_pcm_runtime *fe = fe_substream->private_data;
+ int err;
+
+ fe->dsp[fe_substream->stream].runtime = fe_substream->runtime;
+
+ /* calculate valid and active FE <-> BE dsp_paramss */
+ err = dsp_add_new_paths(fe, fe_substream->stream, 0);
+ if (err <= 0) {
+ dev_warn(&fe->dev, "asoc: %s no valid %s route from source to sink\n",
+ fe->dai_link->name, fe_substream->stream ? "capture" : "playback");
+ }
+
+ return soc_dsp_fe_dai_startup(fe_substream);
+}
+
+/* called when closing FE stream */
+int soc_dsp_fe_dai_close(struct snd_pcm_substream *fe_substream)
+{
+ struct snd_soc_pcm_runtime *fe = fe_substream->private_data;
+ int ret;
+
+ ret = soc_dsp_fe_dai_shutdown(fe_substream);
+
+ be_disconnect(fe, fe_substream->stream);
+
+ return ret;
+}
+
+#ifdef CONFIG_DEBUG_FS
+int soc_dsp_debugfs_add(struct snd_soc_pcm_runtime *rtd)
+{
+ rtd->debugfs_dsp_root = debugfs_create_dir(rtd->dai_link->name,
+ rtd->card->debugfs_card_root);
+ if (!rtd->debugfs_dsp_root) {
+ dev_dbg(&rtd->dev,
+ "ASoC: Failed to create dsp debugfs directory %s\n",
+ rtd->dai_link->name);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+#endif
+
+/* Module information */
+MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
+MODULE_DESCRIPTION("ALSA SoC DSP Core");
+MODULE_LICENSE("GPL");