// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)//// This file is provided under a dual BSD/GPLv2 license.  When using or// redistributing this file, you may do so under either license.//// Copyright(c) 2019 Intel Corporation//// Author: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>// #include <linux/bitfield.h>#include <trace/events/sof.h>#include "sof-audio.h"#include "ops.h" /* * Check if a DAI widget is an aggregated DAI. Aggregated DAI's have names ending in numbers * starting with 0. For example: in the case of a SDW speaker with 2 amps, the topology contains * 2 DAI's names alh-copier.SDW1.Playback.0 and alh-copier-SDW1.Playback.1. In this case, only the * DAI alh-copier.SDW1.Playback.0 is set up in the firmware. The other DAI, * alh-copier.SDW1.Playback.1 in topology is for the sake of completeness to show aggregation for * the speaker amp and does not need any firmware configuration. */static bool is_aggregated_dai(struct snd_sof_widget *swidget){	return (WIDGET_IS_DAI(swidget->id) &&		isdigit(swidget->widget->name[strlen(swidget->widget->name) - 1]) &&		swidget->widget->name[strlen(swidget->widget->name) - 1] != '0');} static bool is_virtual_widget(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *widget,			      const char *func){	switch (widget->id) {	case snd_soc_dapm_out_drv:	case snd_soc_dapm_output:	case snd_soc_dapm_input:		dev_dbg(sdev->dev, "%s: %s is a virtual widget\n", func, widget->name);		return true;	default:		return false;	}} static void sof_reset_route_setup_status(struct snd_sof_dev *sdev, struct snd_sof_widget *widget){	const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);	struct snd_sof_route *sroute; 	list_for_each_entry(sroute, &sdev->route_list, list)		if (sroute->src_widget == widget || sroute->sink_widget == widget) {			if (sroute->setup && tplg_ops && tplg_ops->route_free)				tplg_ops->route_free(sdev, sroute); 			sroute->setup = false;		}} static int sof_widget_free_unlocked(struct snd_sof_dev *sdev,				    struct snd_sof_widget *swidget){	const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);	struct snd_sof_pipeline *spipe = swidget->spipe;	int err = 0;	int ret; 	if (!swidget->private)		return 0; 	trace_sof_widget_free(swidget); 	/* only free when use_count is 0 */	if (--swidget->use_count)		return 0; 	/* reset route setup status for all routes that contain this widget */	sof_reset_route_setup_status(sdev, swidget); 	/* free DAI config and continue to free widget even if it fails */	if (WIDGET_IS_DAI(swidget->id)) {		struct snd_sof_dai_config_data data;		unsigned int flags = SOF_DAI_CONFIG_FLAGS_HW_FREE; 		data.dai_data = DMA_CHAN_INVALID; 		if (tplg_ops && tplg_ops->dai_config) {			err = tplg_ops->dai_config(sdev, swidget, flags, &data);			if (err < 0)				dev_err(sdev->dev, "failed to free config for widget %s\n",					swidget->widget->name);		}	} 	/* continue to disable core even if IPC fails */	if (tplg_ops && tplg_ops->widget_free) {		ret = tplg_ops->widget_free(sdev, swidget);		if (ret < 0 && !err)			err = ret;	} 	/*	 * decrement ref count for cores associated with all modules in the pipeline and clear	 * the complete flag	 */	if (swidget->id == snd_soc_dapm_scheduler) {		int i; 		for_each_set_bit(i, &spipe->core_mask, sdev->num_cores) {			ret = snd_sof_dsp_core_put(sdev, i);			if (ret < 0) {				dev_err(sdev->dev, "failed to disable target core: %d for pipeline %s\n",					i, swidget->widget->name);				if (!err)					err = ret;			}		}		swidget->spipe->complete = 0;	} 	/*	 * free the scheduler widget (same as pipe_widget) associated with the current swidget.	 * skip for static pipelines	 */	if (swidget->spipe && swidget->dynamic_pipeline_widget &&	    swidget->id != snd_soc_dapm_scheduler) {		ret = sof_widget_free_unlocked(sdev, swidget->spipe->pipe_widget);		if (ret < 0 && !err)			err = ret;	} 	if (!err)		dev_dbg(sdev->dev, "widget %s freed\n", swidget->widget->name); 	return err;} int sof_widget_free(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget){	guard(mutex)(&swidget->setup_mutex);	return sof_widget_free_unlocked(sdev, swidget);}EXPORT_SYMBOL(sof_widget_free); static int sof_widget_setup_unlocked(struct snd_sof_dev *sdev,				     struct snd_sof_widget *swidget){	const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);	struct snd_sof_pipeline *spipe = swidget->spipe;	int ret;	int i; 	/* skip if there is no private data */	if (!swidget->private)		return 0; 	trace_sof_widget_setup(swidget); 	/* widget already set up */	if (++swidget->use_count > 1)		return 0; 	/*	 * The scheduler widget for a pipeline is not part of the connected DAPM	 * widget list and it needs to be set up before the widgets in the pipeline	 * are set up. The use_count for the scheduler widget is incremented for every	 * widget in a given pipeline to ensure that it is freed only after the last	 * widget in the pipeline is freed. Skip setting up scheduler widget for static pipelines.	 */	if (swidget->dynamic_pipeline_widget && swidget->id != snd_soc_dapm_scheduler) {		if (!swidget->spipe || !swidget->spipe->pipe_widget) {			dev_err(sdev->dev, "No pipeline set for %s\n", swidget->widget->name);			ret = -EINVAL;			goto use_count_dec;		} 		ret = sof_widget_setup_unlocked(sdev, swidget->spipe->pipe_widget);		if (ret < 0)			goto use_count_dec;	} 	/* update ref count for cores associated with all modules in the pipeline */	if (swidget->id == snd_soc_dapm_scheduler) {		for_each_set_bit(i, &spipe->core_mask, sdev->num_cores) {			ret = snd_sof_dsp_core_get(sdev, i);			if (ret < 0) {				dev_err(sdev->dev, "failed to enable target core %d for pipeline %s\n",					i, swidget->widget->name);				goto pipe_widget_free;			}		}	} 	/* setup widget in the DSP */	if (tplg_ops && tplg_ops->widget_setup) {		ret = tplg_ops->widget_setup(sdev, swidget);		if (ret < 0)			goto pipe_widget_free;	} 	/* send config for DAI components */	if (WIDGET_IS_DAI(swidget->id)) {		unsigned int flags = SOF_DAI_CONFIG_FLAGS_HW_PARAMS; 		/*		 * The config flags saved during BE DAI hw_params will be used for IPC3. IPC4 does		 * not use the flags argument.		 */		if (tplg_ops && tplg_ops->dai_config) {			ret = tplg_ops->dai_config(sdev, swidget, flags, NULL);			if (ret < 0)				goto widget_free;		}	} 	/* restore kcontrols for widget */	if (tplg_ops && tplg_ops->control && tplg_ops->control->widget_kcontrol_setup) {		ret = tplg_ops->control->widget_kcontrol_setup(sdev, swidget);		if (ret < 0)			goto widget_free;	} 	dev_dbg(sdev->dev, "widget %s setup complete\n", swidget->widget->name); 	return 0; widget_free:	/* widget use_count and core_put handled by sof_widget_free() */	sof_widget_free_unlocked(sdev, swidget);	return ret; pipe_widget_free:	if (swidget->id != snd_soc_dapm_scheduler) {		sof_widget_free_unlocked(sdev, swidget->spipe->pipe_widget);	} else {		int j; 		/* decrement ref count for all cores that were updated previously */		for_each_set_bit(j, &spipe->core_mask, sdev->num_cores) {			if (j >= i)				break;			snd_sof_dsp_core_put(sdev, j);		}	}use_count_dec:	swidget->use_count--; 	return ret;} int sof_widget_setup(struct snd_sof_dev *sdev, struct snd_sof_widget *swidget){	guard(mutex)(&swidget->setup_mutex);	return sof_widget_setup_unlocked(sdev, swidget);}EXPORT_SYMBOL(sof_widget_setup); int sof_route_setup(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *wsource,		    struct snd_soc_dapm_widget *wsink){	const struct sof_ipc_tplg_ops *tplg_ops = sof_ipc_get_ops(sdev, tplg);	struct snd_sof_widget *src_widget = wsource->dobj.private;	struct snd_sof_widget *sink_widget = wsink->dobj.private;	struct snd_sof_route *sroute;	bool route_found = false; 	/* ignore routes involving virtual widgets in topology */	if (is_virtual_widget(sdev, src_widget->widget, __func__) ||	    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) {			route_found = true;			break;		} 	if (!route_found) {		dev_err(sdev->dev, "error: cannot find SOF route for source %s -> %s sink\n",			wsource->name, wsink->name);		return -EINVAL;	} 	/* nothing to do if route is already set up */	if (sroute->setup)		return 0; 	if (tplg_ops && tplg_ops->route_setup) {		int ret = tplg_ops->route_setup(sdev, sroute); 		if (ret < 0)			return ret;	} 	sroute->setup = true;	return 0;} static bool sof_widget_in_same_direction(struct snd_sof_widget *swidget, int dir){	return swidget->spipe->direction == dir;} static int sof_set_up_same_dir_widget_routes(struct snd_sof_dev *sdev,					     struct snd_soc_dapm_widget *wsource,					     struct snd_soc_dapm_widget *wsink){	struct snd_sof_widget *src_widget = wsource->dobj.private;	struct snd_sof_widget *sink_widget = wsink->dobj.private; 	/*	 * skip setting up route 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 && sink_widget->spipe->direction_valid &&	    !sof_widget_in_same_direction(sink_widget, src_widget->spipe->direction))		return 0; 	return sof_route_setup(sdev, wsource, wsink);} static int sof_setup_pipeline_connections(struct snd_sof_dev *sdev,					  struct snd_soc_dapm_widget_list *list, int dir){	struct snd_soc_dapm_widget *widget;	struct snd_sof_route *sroute;	struct snd_soc_dapm_path *p;	int ret = 0;	int i; 	/*	 * Set up connections between widgets in the sink/source paths based on direction.	 * Some non-SOF widgets exist in topology either for compatibility or for the	 * purpose of connecting a pipeline from a host to a DAI in order to receive the DAPM	 * events. But they are not handled by the firmware. So ignore them.	 */	if (dir == SNDRV_PCM_STREAM_PLAYBACK) {		for_each_dapm_widgets(list, i, widget) {			if (!widget->dobj.private)				continue; 			snd_soc_dapm_widget_for_each_sink_path(widget, p) {				if (!widget_in_list(list, p->sink))					continue; 				if (p->sink->dobj.private) {					ret = sof_set_up_same_dir_widget_routes(sdev, widget,										p->sink);					if (ret < 0)						return ret;				}			}		}	} else {		for_each_dapm_widgets(list, i, widget) {			if (!widget->dobj.private)				continue; 			snd_soc_dapm_widget_for_each_source_path(widget, p) {				if (!widget_in_list(list, p->source))					continue; 				if (p->source->dobj.private) {					ret = sof_set_up_same_dir_widget_routes(sdev, p->source,										widget);					if (ret < 0)						return ret;				}			}		}	} 	/*	 * The above loop handles connections between widgets that belong to the DAPM widget list.	 * This is not sufficient to handle loopback cases between pipelines configured with	 * different directions, e.g. a sidetone or an amplifier feedback connected to a speaker	 * protection module.	 */	list_for_each_entry(sroute, &sdev->route_list, list) {		bool src_widget_in_dapm_list, sink_widget_in_dapm_list; 		if (sroute->setup)			continue; 		src_widget_in_dapm_list = widget_in_list(list, sroute->src_widget->widget);		sink_widget_in_dapm_list = widget_in_list(list, sroute->sink_widget->widget); 		/*		 * 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)			continue; 		/*		 * 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 && sink_widget_in_dapm_list) {			struct snd_sof_widget *src_widget, *sink_widget; 			src_widget = sroute->src_widget->widget->dobj.private;			sink_widget = sroute->sink_widget->widget->dobj.private; 			/*			 * 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 && 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 voidsof_unprepare_widgets_in_path(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *widget,			      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; 	if (is_virtual_widget(sdev, widget, __func__))		return; 	if (!swidget)		goto sink_unprepare; 	if (swidget->spipe && 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;	if (widget_ops && widget_ops[widget->id].ipc_unprepare)		/* unprepare the source widget */		widget_ops[widget->id].ipc_unprepare(swidget); 	swidget->prepared = false; sink_unprepare:	/* unprepare all widgets in the sink paths */	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, dir);			p->walking = false;		}	}} static intsof_prepare_widgets_in_path(struct snd_sof_dev *sdev, struct snd_soc_dapm_widget *widget,			    struct snd_pcm_hw_params *fe_params,			    struct snd_sof_platform_stream_params *platform_params,			    struct snd_pcm_hw_params *pipeline_params, int dir,			    struct snd_soc_dapm_widget_list *list){	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;	int ret; 	if (is_virtual_widget(sdev, widget, __func__))		return 0; 	if (!swidget)		goto sink_prepare; 	widget_ops = tplg_ops ? tplg_ops->widget : NULL;	if (!widget_ops)		return 0; 	if (swidget->spipe && swidget->spipe->direction_valid &&

Lines 1–500 of 1052. Load more