ASoC: SOF: sof-audio: Add support for hostless/dailess pipelines

This patch add supports for hostless/dailess pipelines in the SOF
topology.

An example of hostless pipeline is a pipeline that's completely
internal to the DSP with the tone generator as the source. In order to
support this with DPCM, we make use of a virtual widget of type
snd_soc_dapm_input as the source widget with the pipeline as follows:

virtual widget (snd_soc_dapm_input) -> tone generator (effect) -> gain
-> DAI

As far as the SOF driver is concerned, any widget of type
snd_soc_dapm_input is not handled and is treated as a virtual widget but
the previoius path allows traversing the list of widgets past this
widget to set up the rest of the widgets in the pipeline. This patch
also amends the logic for finding the source widget for this pipeline to
include the type snd_soc_dapm_input in order to walk from the source to
the sink DAI widget when the pipeline is started.

An example of a DAI-less pipeline would be the echo reference capture in
the speaker playback path. This pipeline is set up as follows:

Host(Playback) -> mixin -> mixout -> gain -> module-copier -> DAI
						|
						V
		Host(Capture) <-  Process module <- virtual DAI

In the above example, the virtual DAI exploits the concept of an
aggregated DAI (one with a non-zero DAI ID) in topology to enable this
pipeline to work with DPCM. A virtual DAI is a DAI widget with a
non-zero DAI ID and hence is skipped when traversing the list of DAPM
widgets during widget prepare/set/up/free/unprepare. The process module
in the above pipeline generates 0's that are captured by the echo
reference PCM.  When the playback path is active, the process module acts
as a passthrough module to allow the playback samples to be passthrough
to the capture host.

In order for these pipelines to work properly, the logic for
setting/preparing/freeing/unpreparing the widgets needs to be amended to
make sure that only the widgets that are in the pipeline in the same
direction as the PCM being started are set up. For example, when the
playback PCM is started, the capture pipeline widgets also show up in
the list of connected DAPM widgets but they shouldn't be set up yet
because the echo reference capture PCM hasn't been started yet.
Alternatively, when the echo reference capture PCM is started, the
playback pipeline widgets should not be setup.

Finally, the last step needed to put this all together is the set the
routes for widgets connecting the playback and the capture pipelines
when both are active.

Signed-off-by: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>

Author: ranj063

sound/soc/sof/sof-audio.c

@@ -269,6 +269,10 @@ int sof_route_setup(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *wsourc
 	    is_virtual_widget(sdev, sink_widget->widget, __func__))
 		return 0;
 
+	/* skip route if source/sink widget is not set up */
+	if (!src_widget->use_count || !sink_widget->use_count)
+		return 0;
+
 	/* find route matching source and sink widgets */
 	list_for_each_entry(sroute, &sdev->route_list, list)
 		if (sroute->src_widget == src_widget && sroute->sink_widget == sink_widget) {
@@ -297,10 +301,10 @@ int sof_route_setup(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *wsourc
 	return 0;
 }
 
+static bool sof_widget_in_same_direction(struct snd_sof_widget *swidget, int dir);
 static int sof_setup_pipeline_connections(struct snd_sof_dev *sdev,
 					  struct snd_soc_dapm_widget_list *list, int dir)
 {
-	const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);
 	struct snd_soc_dapm_widget *widget;
 	struct snd_sof_route *sroute;
 	struct snd_soc_dapm_path *p;
@@ -315,14 +319,30 @@ static int sof_setup_pipeline_connections(struct snd_sof_dev *sdev,
 	 */
 	if (dir == SNDRV_PCM_STREAM_PLAYBACK) {
 		for_each_dapm_widgets(list, i, widget) {
+			struct snd_sof_widget *src_widget, *sink_widget;
+
 			if (!widget->dobj.private)
 				continue;
 
 			snd_soc_dapm_widget_for_each_sink_path(widget, p) {
 				if (!widget_in_list(list, p->sink))
 					continue;
+				src_widget = widget->dobj.private;
 
 				if (p->sink->dobj.private) {
+					sink_widget = p->sink->dobj.private;
+
+					/*
+					 * skip if source and sink are in different directions
+					 * (ex. playback and echo ref) if the direction is set in
+					 * topology. These will be set up later. It is enough to
+					 * check if the direction_valid is set for one of the
+					 * widgets as all widgets will have the direction set
+					 * in topology if one is set.
+					 */
+					if (sink_widget->spipe->direction_valid &&
+					    !sof_widget_in_same_direction(sink_widget, src_widget->spipe->direction))
+						continue;
 					ret = sof_route_setup(sdev, widget, p->sink);
 					if (ret < 0)
 						return ret;
@@ -331,14 +351,32 @@ static int sof_setup_pipeline_connections(struct snd_sof_dev *sdev,
 		}
 	} else {
 		for_each_dapm_widgets(list, i, widget) {
+			struct snd_sof_widget *src_widget, *sink_widget;
+
 			if (!widget->dobj.private)
 				continue;
 
 			snd_soc_dapm_widget_for_each_source_path(widget, p) {
 				if (!widget_in_list(list, p->source))
 					continue;
 
+				sink_widget = widget->dobj.private;
+
 				if (p->source->dobj.private) {
+					src_widget = p->source->dobj.private;
+
+					/*
+					 * skip if source and sink are in different directions
+					 * (ex. playback and echo ref) if the direction is set in
+					 * topology. These will be set up later. It is enough to
+					 * check if the direction_valid is set for one of the
+					 * widgets as all widgets will have the direction set
+					 * in topology if one is set.
+					 */
+					if (sink_widget->spipe->direction_valid &&
+					    !sof_widget_in_same_direction(sink_widget, src_widget->spipe->direction))
+						continue;
+
 					ret = sof_route_setup(sdev, p->source, widget);
 					if (ret < 0)
 						return ret;
@@ -355,7 +393,6 @@ static int sof_setup_pipeline_connections(struct snd_sof_dev *sdev,
 	 */
 	list_for_each_entry(sroute, &sdev->route_list, list) {
 		bool src_widget_in_dapm_list, sink_widget_in_dapm_list;
-		struct snd_sof_widget *swidget;
 
 		if (sroute->setup)
 			continue;
@@ -364,63 +401,69 @@ static int sof_setup_pipeline_connections(struct snd_sof_dev *sdev,
 		sink_widget_in_dapm_list = widget_in_list(list, sroute->sink_widget->widget);
 
 		/*
-		 * if both source and sink are in the DAPM list, the route must already have been
-		 * set up above. And if neither are in the DAPM list, the route shouldn't be
-		 * handled now.
+		 * no need to set up the route if both the source and sink widgets are not in the
+		 * DAPM list
 		 */
-		if (src_widget_in_dapm_list == sink_widget_in_dapm_list)
+		if (!src_widget_in_dapm_list && !sink_widget_in_dapm_list)
 			continue;
 
 		/*
-		 * At this point either the source widget or the sink widget is in the DAPM list
-		 * with a route that might need to be set up. Check the use_count of the widget
-		 * that is not in the DAPM list to confirm if it is in use currently before setting
-		 * up the route.
+		 * set up the route only if both the source and sink widgets are in the DAPM list
+		 * but are in different directions. The ones in the same direction would already
+		 * have been set up in the previous loop.
 		 */
-		if (src_widget_in_dapm_list)
-			swidget = sroute->sink_widget;
-		else
-			swidget = sroute->src_widget;
+		if (src_widget_in_dapm_list && sink_widget_in_dapm_list) {
+			struct snd_sof_widget *src_widget, *sink_widget;
 
-		scoped_guard(mutex, &swidget->setup_mutex) {
-			if (!swidget->use_count)
-				continue;
+			src_widget = sroute->src_widget->widget->dobj.private;
+			sink_widget = sroute->sink_widget->widget->dobj.private;
 
-			if (tplg_ops && tplg_ops->route_setup) {
-				/*
-				 * this route will get freed when either the
-				 * source widget or the sink widget is freed
-				 * during hw_free
-				 */
-				ret = tplg_ops->route_setup(sdev, sroute);
-				if (!ret)
-					sroute->setup = true;
-			}
+			/*
+			 * it is enough to check if the direction_valid is set for one of the
+			 * widgets as all widgets will have the direction set in topology if one
+			 * is set.
+			 */
+			if (src_widget && sink_widget &&
+			    src_widget->spipe->direction_valid &&
+			    sof_widget_in_same_direction(sink_widget, src_widget->spipe->direction))
+				continue;
 		}
 
+		ret = sof_route_setup(sdev, sroute->src_widget->widget,
+				      sroute->sink_widget->widget);
+
 		if (ret < 0)
 			return ret;
 	}
 
 	return 0;
 }
 
+static bool sof_widget_in_same_direction(struct snd_sof_widget *swidget, int dir)
+{
+	if (swidget->spipe->direction == dir)
+		return true;
+
+	return false;
+}
+
 static void
 sof_unprepare_widgets_in_path(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *widget,
-			      struct snd_soc_dapm_widget_list *list)
+			      struct snd_soc_dapm_widget_list *list, int dir)
 {
 	const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);
 	struct snd_sof_widget *swidget = widget->dobj.private;
 	const struct sof_ipc_tplg_widget_ops *widget_ops;
 	struct snd_soc_dapm_path *p;
 
-	/* skip if the widget is in use or if it is already unprepared */
-	if (!swidget || !swidget->prepared || swidget->use_count > 0 ||
-	    is_virtual_widget(sdev, widget, __func__))
+	if (!swidget || is_virtual_widget(sdev, widget, __func__))
 		goto sink_unprepare;
 
-	/* skip aggregated DAIs */
-	if(is_aggregated_dai(swidget))
+	if (swidget->spipe->direction_valid && !sof_widget_in_same_direction(swidget, dir))
+		return;
+
+	/* skip widgets in use, those already unprepared or aggregated DAIs */
+	if (!swidget->prepared || swidget->use_count > 0 || is_aggregated_dai(swidget))
 		goto sink_unprepare;
 
 	widget_ops = tplg_ops ? tplg_ops->widget : NULL;
@@ -435,9 +478,10 @@ sof_unprepare_widgets_in_path(struct snd_sof_dev *sdev, struct snd_soc_dapm_widg
 	snd_soc_dapm_widget_for_each_sink_path(widget, p) {
 		if (!widget_in_list(list, p->sink))
 			continue;
+
 		if (!p->walking && p->sink->dobj.private) {
 			p->walking = true;
-			sof_unprepare_widgets_in_path(sdev, p->sink, list);
+			sof_unprepare_widgets_in_path(sdev, p->sink, list, dir);
 			p->walking = false;
 		}
 	}
@@ -456,18 +500,21 @@ sof_prepare_widgets_in_path(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget
 	struct snd_soc_dapm_path *p;
 	int ret;
 
-	if (is_virtual_widget(sdev, widget, __func__))
+	dev_dbg(sdev->dev, "%s: preparing widget %s id %d\n",
+		__func__, widget->name, widget->id);
+
+	if (is_virtual_widget(sdev, widget, __func__) || !swidget)
 		goto sink_prepare;
 
 	widget_ops = tplg_ops ? tplg_ops->widget : NULL;
 	if (!widget_ops)
 		return 0;
 
-	if (!swidget || !widget_ops[widget->id].ipc_prepare || swidget->prepared)
-		goto sink_prepare;
+	if (swidget->spipe->direction_valid && !sof_widget_in_same_direction(swidget, dir))
+		return 0;
 
-	/* skip aggregated DAIs */
-	if(is_aggregated_dai(swidget))
+	if (!widget_ops[widget->id].ipc_prepare || swidget->prepared ||
+	    is_aggregated_dai(swidget))
 		goto sink_prepare;
 
 	/* prepare the source widget */
@@ -485,6 +532,7 @@ sof_prepare_widgets_in_path(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget
 	snd_soc_dapm_widget_for_each_sink_path(widget, p) {
 		if (!widget_in_list(list, p->sink))
 			continue;
+
 		if (!p->walking && p->sink->dobj.private) {
 			p->walking = true;
 			ret = sof_prepare_widgets_in_path(sdev, p->sink,  fe_params,
@@ -514,23 +562,25 @@ static int sof_free_widgets_in_path(struct snd_sof_dev *sdev, struct snd_soc_dap
 				    int dir, struct snd_sof_pcm *spcm)
 {
 	struct snd_soc_dapm_widget_list *list = spcm->stream[dir].list;
-	struct snd_sof_widget *swidget;
+	struct snd_sof_widget *swidget = widget->dobj.private;
 	struct snd_soc_dapm_path *p;
 	int err;
 	int ret = 0;
 
-	if (is_virtual_widget(sdev, widget, __func__))
+	if (is_virtual_widget(sdev, widget, __func__) || !swidget)
 		goto sink_free;
 
-	swidget = widget->dobj.private;
+	/* skip aggregated DAIs */
+	if (swidget->spipe->direction_valid && !sof_widget_in_same_direction(swidget, dir))
+		return 0;
 
-	/* no need to free aggregated DAI widgets */
-	if (swidget && !is_aggregated_dai(swidget)) {
-		err = sof_widget_free(sdev, swidget);
-		if (err < 0)
-			ret = err;
-	}
+	if (is_aggregated_dai(swidget))
+		goto sink_free;
 
+	err = sof_widget_free(sdev, widget->dobj.private);
+	if (err < 0)
+		ret = err;
+sink_free:
 	/* free all widgets in the sink paths even in case of error to keep use counts balanced */
 	snd_soc_dapm_widget_for_each_sink_path(widget, p) {
 		if (!p->walking) {
@@ -570,6 +620,10 @@ static int sof_set_up_widgets_in_path(struct snd_sof_dev *sdev, struct snd_soc_d
 	if (swidget) {
 		int i;
 
+		/* skip aggregated DAIs */
+		if (swidget->spipe->direction_valid && !sof_widget_in_same_direction(swidget, dir))
+			return 0;
+
 		if(is_aggregated_dai(swidget))
 			goto sink_setup;
 
@@ -635,15 +689,14 @@ sof_walk_widgets_in_order(struct snd_sof_dev *sdev, struct snd_sof_pcm *spcm,
 		return 0;
 
 	for_each_dapm_widgets(list, i, widget) {
-		if (is_virtual_widget(sdev, widget, __func__))
-			continue;
-
-		/* starting widget for playback is AIF type */
-		if (dir == SNDRV_PCM_STREAM_PLAYBACK && widget->id != snd_soc_dapm_aif_in)
+		/* starting widget for playback is of AIF or snd_soc_dapm_input type */
+		if (dir == SNDRV_PCM_STREAM_PLAYBACK && (widget->id != snd_soc_dapm_aif_in &&
+		    widget->id != snd_soc_dapm_input))
 			continue;
 
 		/* starting widget for capture is DAI type */
-		if (dir == SNDRV_PCM_STREAM_CAPTURE && widget->id != snd_soc_dapm_dai_out)
+		if (dir == SNDRV_PCM_STREAM_CAPTURE && widget->id != snd_soc_dapm_dai_out &&
+		    widget->id != snd_soc_dapm_output)
 			continue;
 
 		switch (op) {
@@ -673,7 +726,7 @@ sof_walk_widgets_in_order(struct snd_sof_dev *sdev, struct snd_sof_pcm *spcm,
 			break;
 		}
 		case SOF_WIDGET_UNPREPARE:
-			sof_unprepare_widgets_in_path(sdev, widget, list);
+			sof_unprepare_widgets_in_path(sdev, widget, list, dir);
 			break;
 		default:
 			dev_err(sdev->dev, "Invalid widget op %d\n", op);
@@ -920,29 +973,41 @@ struct snd_sof_widget *snd_sof_find_swidget(struct snd_soc_component *scomp,
 	return NULL;
 }
 
-/* find widget by stream name and direction */
-struct snd_sof_widget *
-snd_sof_find_swidget_sname(struct snd_soc_component *scomp,
-			   const char *pcm_name, int dir)
+static struct snd_sof_widget *snd_sof_find_swidget_sname_type(struct snd_soc_component *scomp,
+							      const char *sname,
+							      enum snd_soc_dapm_type type)
 {
 	struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(scomp);
 	struct snd_sof_widget *swidget;
-	enum snd_soc_dapm_type type;
-
-	if (dir == SNDRV_PCM_STREAM_PLAYBACK)
-		type = snd_soc_dapm_aif_in;
-	else
-		type = snd_soc_dapm_aif_out;
 
 	list_for_each_entry(swidget, &sdev->widget_list, list) {
-		if (!strcmp(pcm_name, swidget->widget->sname) &&
-		    swidget->id == type)
+		if (!strcmp(sname, swidget->widget->sname) && swidget->id == type)
 			return swidget;
 	}
 
 	return NULL;
 }
 
+/* find widget by stream name and direction */
+struct snd_sof_widget *
+snd_sof_find_swidget_sname(struct snd_soc_component *scomp,
+			   const char *pcm_name, int dir)
+{
+	if (dir == SNDRV_PCM_STREAM_PLAYBACK) {
+		struct snd_sof_widget *swidget;
+
+		/* first look for an aif_in type widget */
+		swidget = snd_sof_find_swidget_sname_type(scomp, pcm_name, snd_soc_dapm_aif_in);
+		if (swidget)
+			return swidget;
+
+		/* if not found, look for an input type widget */
+		return snd_sof_find_swidget_sname_type(scomp, pcm_name, snd_soc_dapm_input);
+	}
+
+	return snd_sof_find_swidget_sname_type(scomp, pcm_name, snd_soc_dapm_aif_out);
+}
+
 struct snd_sof_dai *snd_sof_find_dai(struct snd_soc_component *scomp,
 				     const char *name)
 {