ASoC: soc: pcm: add support for DPCM BE to BE connection

Some FEs can connect BE capture audio interfaces to BE playback audio
interfaces. This is accomplished by adding the dpcm_loopback flag in the
snd_soc_dai_link structure, allowing the machine driver to mention that the
FE (dynamic set) has loopback capability (capture->playback).
The FE will have its callbacks called twice, once for capture stream and
once for playback stream. The HW parameters for FE will not be set, since
the HW parameters are on the BEs.
The transfers are executed with minimal to none CPU intervention.

Signed-off-by: Codrin Ciubotariu <codrin.ciubotariu@microchip.com>

Author: Codrin Ciubotariu

include/sound/soc.h

@@ -694,6 +694,7 @@ struct snd_soc_dai_link {
 
 	/* This DAI link can route to other DAI links at runtime (Frontend)*/
 	unsigned int dynamic:1;
+	unsigned int dpcm_loopback:1;
 
 	/* DPCM capture and Playback support */
 	unsigned int dpcm_capture:1;

sound/soc/soc-dapm.c

@@ -4014,6 +4014,108 @@ static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
 	return ret;
 }
 
+static int
+snd_soc_dai_link_loopback_event_pre_pmu(struct snd_soc_dapm_widget *w,
+					struct snd_pcm_substream *substream)
+{
+	struct snd_soc_dapm_path *path;
+	struct snd_soc_dai *source, *sink;
+	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
+	int ret = 0;
+
+	rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].state = SND_SOC_DPCM_STATE_START;
+	rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].state = SND_SOC_DPCM_STATE_START;
+
+	substream->stream = SNDRV_PCM_STREAM_CAPTURE;
+	snd_soc_dapm_widget_for_each_source_path(w, path) {
+		source = path->source->priv;
+		snd_soc_dai_activate(source, substream->stream);
+	}
+
+	substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
+	snd_soc_dapm_widget_for_each_sink_path(w, path) {
+		sink = path->sink->priv;
+		snd_soc_dai_activate(sink, substream->stream);
+	}
+
+	return ret;
+}
+
+static int snd_soc_dai_link_loopback_event(struct snd_soc_dapm_widget *w,
+					   struct snd_kcontrol *kcontrol, int event)
+{
+	struct snd_soc_dapm_path *path;
+	struct snd_soc_dai *source, *sink;
+	struct snd_pcm_substream *substream = w->priv;
+	int ret = 0, saved_stream = substream->stream;
+	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
+
+	if (WARN_ON(list_empty(&w->edges[SND_SOC_DAPM_DIR_OUT]) ||
+		    list_empty(&w->edges[SND_SOC_DAPM_DIR_IN])))
+		return -EINVAL;
+
+	switch (event) {
+	case SND_SOC_DAPM_PRE_PMU:
+		ret = snd_soc_dai_link_loopback_event_pre_pmu(w, substream);
+		if (ret < 0)
+			goto out;
+
+		break;
+
+	case SND_SOC_DAPM_POST_PMU:
+		snd_soc_dapm_widget_for_each_sink_path(w, path) {
+			sink = path->sink->priv;
+
+			ret = snd_soc_dai_digital_mute(sink, 0,
+						       SNDRV_PCM_STREAM_PLAYBACK);
+			if (ret != 0 && ret != -EOPNOTSUPP)
+				dev_warn(sink->dev,
+					 "ASoC: Failed to unmute: %d\n", ret);
+			ret = 0;
+		}
+		break;
+
+	case SND_SOC_DAPM_PRE_PMD:
+		snd_soc_dapm_widget_for_each_sink_path(w, path) {
+			sink = path->sink->priv;
+
+			ret = snd_soc_dai_digital_mute(sink, 1,
+						       SNDRV_PCM_STREAM_PLAYBACK);
+			if (ret != 0 && ret != -EOPNOTSUPP)
+				dev_warn(sink->dev,
+					 "ASoC: Failed to mute: %d\n", ret);
+			ret = 0;
+		}
+
+		substream->stream = SNDRV_PCM_STREAM_CAPTURE;
+		snd_soc_dapm_widget_for_each_source_path(w, path) {
+			source = path->source->priv;
+			snd_soc_dai_deactivate(source, substream->stream);
+		}
+
+		substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
+		snd_soc_dapm_widget_for_each_sink_path(w, path) {
+			sink = path->sink->priv;
+			snd_soc_dai_deactivate(sink, substream->stream);
+		}
+		break;
+
+	case SND_SOC_DAPM_POST_PMD:
+		rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].state = SND_SOC_DPCM_STATE_CLOSE;
+		rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].state = SND_SOC_DPCM_STATE_CLOSE;
+		break;
+
+	default:
+		WARN(1, "Unknown event %d\n", event);
+		ret = -EINVAL;
+	}
+
+out:
+	/* Restore the substream direction */
+	substream->stream = saved_stream;
+	return ret;
+}
+
 static int snd_soc_dapm_dai_link_get(struct snd_kcontrol *kcontrol,
 			  struct snd_ctl_elem_value *ucontrol)
 {
@@ -4132,6 +4234,47 @@ snd_soc_dapm_alloc_kcontrol(struct snd_soc_card *card,
 	return NULL;
 }
 
+static struct snd_soc_dapm_widget *
+snd_soc_dapm_new_loopback_dai(struct snd_soc_card *card, struct snd_pcm_substream *substream,
+			      char *id)
+{
+	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
+	struct snd_soc_dapm_widget template;
+	struct snd_soc_dapm_widget *w;
+	char *link_name;
+	int ret;
+
+	link_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s-%s",
+				   rtd->dai_link->name, id);
+	if (!link_name)
+		return ERR_PTR(-ENOMEM);
+
+	memset(&template, 0, sizeof(template));
+	template.reg = SND_SOC_NOPM;
+	template.id = snd_soc_dapm_dai_link;
+	template.name = link_name;
+	template.event = snd_soc_dai_link_loopback_event;
+	template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
+		SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD;
+	template.kcontrol_news = NULL;
+
+	w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
+	if (IS_ERR(w)) {
+		ret = PTR_ERR(w);
+		dev_err(rtd->dev, "ASoC: Failed to create %s widget: %d\n",
+			link_name, ret);
+		goto outfree_link_name;
+	}
+
+	w->priv = substream;
+
+	return w;
+
+outfree_link_name:
+	devm_kfree(card->dev, link_name);
+	return ERR_PTR(ret);
+}
+
 static struct snd_soc_dapm_widget *
 snd_soc_dapm_new_dai(struct snd_soc_card *card,
 		     struct snd_pcm_substream *substream,
@@ -4337,14 +4480,30 @@ static void dapm_connect_dai_pair(struct snd_soc_card *card,
 	struct snd_pcm_substream *substream;
 	struct snd_pcm_str *streams = rtd->pcm->streams;
 
-	if (dai_link->params) {
+	if (dai_link->params || (rtd->dai_link->dynamic && rtd->dai_link->dpcm_loopback)) {
 		playback_cpu = cpu_dai->capture_widget;
 		capture_cpu = cpu_dai->playback_widget;
 	} else {
 		playback_cpu = cpu_dai->playback_widget;
 		capture_cpu = cpu_dai->capture_widget;
 	}
 
+	if (rtd->dai_link->dynamic && rtd->dai_link->dpcm_loopback) {
+		if (!rtd->playback_widget && !rtd->capture_widget) {
+			streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
+			streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
+			substream = streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
+			dai = snd_soc_dapm_new_loopback_dai(card, substream, "hostless");
+			if (IS_ERR(dai))
+				return;
+			rtd->playback_widget = dai;
+			rtd->capture_widget = dai;
+		}
+		dapm_connect_dai_routes(&card->dapm, cpu_dai, playback_cpu,
+					dai,
+					cpu_dai, capture_cpu);
+		return;
+	}
 	/* connect BE DAI playback if widgets are valid */
 	codec = codec_dai->playback_widget;
 
@@ -4431,13 +4590,19 @@ void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card)
 		 * dynamic FE links have no fixed DAI mapping.
 		 * CODEC<->CODEC links have no direct connection.
 		 */
-		if (rtd->dai_link->dynamic)
+		if (rtd->dai_link->dynamic && !rtd->dai_link->dpcm_loopback)
 			continue;
 
 		if (rtd->num_cpus == 1) {
-			for_each_rtd_codec_dais(rtd, i, codec_dai)
-				dapm_connect_dai_pair(card, rtd, codec_dai,
+			/* connect FE to FE */
+			if (rtd->dai_link->dynamic && rtd->dai_link->dpcm_loopback) {
+				dapm_connect_dai_pair(card, rtd, asoc_rtd_to_cpu(rtd, 0),
 						      asoc_rtd_to_cpu(rtd, 0));
+			} else {
+				for_each_rtd_codec_dais(rtd, i, codec_dai)
+					dapm_connect_dai_pair(card, rtd, codec_dai,
+							      asoc_rtd_to_cpu(rtd, 0));
+			}
 		} else if (rtd->num_codecs == rtd->num_cpus) {
 			for_each_rtd_codec_dais(rtd, i, codec_dai)
 				dapm_connect_dai_pair(card, rtd, codec_dai,