module: Add support for saving and retrieving the base config extension

Modules are bound with one another with a buffer in between. Today,
this buffer's size is based on the source module's base config obs and
sink module's base config ibs. But this is incorrect because this
assumes that the connection is always from output pin 0 of the source
module and input pin 0 of the sink module.

To determine the buffer size correctly, the buffer size should be based on
the pin-based obs/ibs of the source/sink module. To allow this, save the
base config extension for the module during init so that it can be
retrieved during module binding to get the obs/ibs based on the
source/sink pin ID.

Modify the google rtc and smart amp modules to save the base config
extension during their init.

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

Marcin: google AEC merge
Signed-off-by: Marcin Szkudlinski <marcin.szkudlinski@intel.com>

Author: ranj063

src/audio/google/google_rtc_audio_processing.c

@@ -324,19 +324,36 @@ static int google_rtc_audio_processing_init(struct processing_module *mod)
 	struct module_config *cfg = &md->cfg;
 	const struct ipc4_base_module_extended_cfg *base_cfg = md->cfg.init_data;
 	struct ipc4_input_pin_format reference_fmt, output_fmt;
-	const size_t size = sizeof(struct ipc4_input_pin_format);
+	size_t in_fmt_size = sizeof(struct ipc4_input_pin_format);
+	size_t out_fmt_size = sizeof(struct ipc4_output_pin_format);
+	size_t size;
 
 	cd->config.base_cfg = base_cfg->base_cfg;
 
 	/* Copy the reference format from input pin 1 format */
-	memcpy_s(&reference_fmt, size,
-		 &base_cfg->base_cfg_ext.pin_formats[size], size);
-	memcpy_s(&output_fmt, size,
-		 &base_cfg->base_cfg_ext.pin_formats[size * GOOGLE_RTC_NUM_INPUT_PINS], size);
+	memcpy_s(&reference_fmt, in_fmt_size,
+		 &base_cfg->base_cfg_ext.pin_formats[in_fmt_size], in_fmt_size);
+	memcpy_s(&output_fmt, in_fmt_size,
+		 &base_cfg->base_cfg_ext.pin_formats[in_fmt_size * GOOGLE_RTC_NUM_INPUT_PINS],
+		 in_fmt_size);
 
 	cd->config.reference_fmt = reference_fmt.audio_fmt;
 	cd->config.output_fmt = output_fmt.audio_fmt;
-	cd->config = *(const struct sof_ipc4_aec_config *)cfg->init_data;
+
+	/* save the base config extension */
+	size = base_cfg->base_cfg_ext.nb_input_pins * in_fmt_size +
+		base_cfg->base_cfg_ext.nb_output_pins * out_fmt_size;
+
+	md->cfg.basecfg_ext = rzalloc(SOF_MEM_ZONE_RUNTIME, 0, SOF_MEM_CAPS_RAM,
+				      sizeof(struct ipc4_base_module_cfg_ext) + size);
+	if (!md->cfg.basecfg_ext) {
+		ret = -ENOMEM;
+		goto fail;
+	}
+
+	memcpy_s(md->cfg.basecfg_ext, size + sizeof(struct ipc4_base_module_cfg_ext),
+		 &base_cfg->base_cfg_ext,
+		 size + sizeof(struct ipc4_base_module_cfg_ext));
 
 	cd->tuning_handler = comp_data_blob_handler_new(dev);
 	if (!cd->tuning_handler) {
@@ -434,6 +451,7 @@ static int google_rtc_audio_processing_init(struct processing_module *mod)
 		}
 		GoogleRtcAudioProcessingDetachMemoryBuffer();
 		rfree(cd->memory_buffer);
+		rfree(md->cfg.basecfg_ext);
 		rfree(cd->process_buffer);
 		comp_data_blob_handler_free(cd->tuning_handler);
 		rfree(cd);
@@ -445,6 +463,7 @@ static int google_rtc_audio_processing_init(struct processing_module *mod)
 static int google_rtc_audio_processing_free(struct processing_module *mod)
 {
 	struct google_rtc_audio_processing_comp_data *cd = module_get_private_data(mod);
+	struct module_data *md = &mod->priv;
 
 	comp_dbg(mod->dev, "google_rtc_audio_processing_free()");
 
@@ -455,6 +474,7 @@ static int google_rtc_audio_processing_free(struct processing_module *mod)
 	rfree(cd->memory_buffer);
 	rfree(cd->process_buffer);
 	comp_data_blob_handler_free(cd->tuning_handler);
+	rfree(md->cfg.basecfg_ext);
 	rfree(cd);
 	return 0;
 }

src/audio/module_adapter/module_adapter_ipc4.c

@@ -147,6 +147,22 @@ int module_adapter_get_attribute(struct comp_dev *dev, uint32_t type, void *valu
 		memcpy_s(value, sizeof(struct ipc4_base_module_cfg),
 			 &mod->priv.cfg.base_cfg, sizeof(mod->priv.cfg.base_cfg));
 		break;
+	case COMP_ATTR_BASE_CONFIG_EXT:
+	{
+		struct ipc4_base_module_cfg_ext *basecfg_ext = mod->priv.cfg.basecfg_ext;
+		size_t size;
+
+		if (!basecfg_ext) {
+			comp_err(mod->dev, "No base config extn set for module");
+			return -EINVAL;
+		}
+
+		size = basecfg_ext->nb_input_pins * sizeof(struct ipc4_input_pin_format) +
+				basecfg_ext->nb_output_pins * sizeof(struct ipc4_output_pin_format);
+		memcpy_s(value, sizeof(*basecfg_ext) + size,
+			 basecfg_ext, sizeof(*basecfg_ext) + size);
+		break;
+	}
 	default:
 		return -EINVAL;
 	}

src/include/module/module/base.h

@@ -30,6 +30,7 @@ struct module_config {
 	const void *init_data; /**< Initial IPC configuration. */
 #if CONFIG_IPC_MAJOR_4
 	struct ipc4_base_module_cfg base_cfg;
+	struct ipc4_base_module_cfg_ext *basecfg_ext;
 #endif
 };
 

src/include/sof/audio/component.h

@@ -117,6 +117,7 @@ enum {
 #define COMP_ATTR_COPY_DIR	2	/**< Comp copy direction */
 #define COMP_ATTR_VDMA_INDEX	3	/**< Comp index of the virtual DMA at the gateway. */
 #define COMP_ATTR_BASE_CONFIG	4	/**< Component base config */
+#define COMP_ATTR_BASE_CONFIG_EXT 5	/**< Component base config extension */
 /** @}*/
 
 /** \name Trace macros

src/include/sof/audio/component_ext.h

@@ -16,6 +16,7 @@
 #ifndef __SOF_AUDIO_COMPONENT_INT_H__
 #define __SOF_AUDIO_COMPONENT_INT_H__
 
+#include <sof/audio/module_adapter/module/generic.h>
 #include <sof/audio/component.h>
 #include <ipc/topology.h>
 
@@ -216,31 +217,59 @@ struct get_attribute_remote_payload {
 static inline int comp_ipc4_get_attribute_remote(struct comp_dev *dev, uint32_t type,
 						 void *value)
 {
+	struct ipc4_base_module_cfg_ext *basecfg_ext;
 	struct ipc4_base_module_cfg *base_cfg;
 	struct get_attribute_remote_payload payload = {};
 	struct idc_msg msg = { IDC_MSG_GET_ATTRIBUTE,
 		IDC_EXTENSION(dev->ipc_config.id), dev->ipc_config.core,
 		sizeof(payload), &payload};
+	size_t size = MODULE_MAX_SINKS * sizeof(struct ipc4_output_pin_format) +
+			MODULE_MAX_SOURCES * sizeof(struct ipc4_input_pin_format);
 	int ret;
 
-	/* Only COMP_ATTR_BASE_CONFIG is supported for remote access */
-	if (type != COMP_ATTR_BASE_CONFIG)
-		return -EINVAL;
+	payload.type = type;
 
-	base_cfg = rzalloc(SOF_MEM_ZONE_RUNTIME_SHARED, 0, SOF_MEM_CAPS_RAM, sizeof(*base_cfg));
-	if (!base_cfg)
-		return -ENOMEM;
+	/*
+	 * Only COMP_ATTR_BASE_CONFIG and COMP_ATTR_BASE_CONFIG_EXT are supported for
+	 * remote access
+	 */
+	switch (type) {
+	case COMP_ATTR_BASE_CONFIG:
+		base_cfg = rzalloc(SOF_MEM_ZONE_RUNTIME_SHARED, 0, SOF_MEM_CAPS_RAM,
+				   sizeof(*base_cfg));
+		if (!base_cfg)
+			return -ENOMEM;
+
+		payload.value = base_cfg;
+		break;
+	case COMP_ATTR_BASE_CONFIG_EXT:
+		basecfg_ext = rzalloc(SOF_MEM_ZONE_RUNTIME_SHARED, 0, SOF_MEM_CAPS_RAM,
+					  sizeof(*basecfg_ext) + size);
+		if (!basecfg_ext)
+			return -ENOMEM;
 
-	payload.type = type;
-	payload.value = base_cfg;
+		payload.value = basecfg_ext;
+		break;
+	default:
+		return -EINVAL;
+	}
 
 	ret = idc_send_msg(&msg, IDC_BLOCKING);
 
-	if (ret == 0)
-		memcpy_s(value, sizeof(struct ipc4_base_module_cfg),
-			 base_cfg, sizeof(struct ipc4_base_module_cfg));
+	if (!ret) {
+		switch (type) {
+		case COMP_ATTR_BASE_CONFIG:
+			memcpy_s(value, sizeof(struct ipc4_base_module_cfg),
+				 base_cfg, sizeof(struct ipc4_base_module_cfg));
+			rfree(base_cfg);
+			break;
+		case COMP_ATTR_BASE_CONFIG_EXT:
+			memcpy_s(value, size, basecfg_ext, size);
+			rfree(basecfg_ext);
+			break;
+		}
+	}
 
-	rfree(base_cfg);
 	return ret;
 }
 #endif	/* CONFIG_IPC_MAJOR_4 */

src/include/sof/audio/module_adapter/module/generic.h

@@ -31,6 +31,7 @@
 
 #define MAX_BLOB_SIZE 8192
 #define MODULE_MAX_SOURCES 8
+#define MODULE_MAX_SINKS 8
 
 #define API_CALL(cd, cmd, sub_cmd, value, ret) \
 	do { \

src/ipc/ipc4/helper.c

@@ -8,6 +8,7 @@
 #include <sof/audio/buffer.h>
 #include <sof/audio/component.h>
 #include <sof/audio/component_ext.h>
+#include <sof/audio/module_adapter/module/generic.h>
 #include <sof/audio/pipeline.h>
 #include <sof/common.h>
 #include <rtos/interrupt.h>
@@ -424,15 +425,20 @@ static int ll_wait_finished_on_core(struct comp_dev *dev)
 
 int ipc_comp_connect(struct ipc *ipc, ipc_pipe_comp_connect *_connect)
 {
+	struct ipc4_base_module_cfg_ext *src_basecfg_ext, *sink_basecfg_ext;
 	struct ipc4_module_bind_unbind *bu;
 	struct comp_buffer *buffer;
 	struct comp_dev *source;
 	struct comp_dev *sink;
 	struct ipc4_base_module_cfg source_src_cfg;
 	struct ipc4_base_module_cfg sink_src_cfg;
 	uint32_t flags;
+	uint32_t ibs = 0;
+	uint32_t obs = 0;
+	uint32_t buf_size;
 	int src_id, sink_id;
 	int ret;
+	size_t size;
 
 	bu = (struct ipc4_module_bind_unbind *)_connect;
 	src_id = IPC4_COMP_ID(bu->primary.r.module_id, bu->primary.r.instance_id);
@@ -453,32 +459,88 @@ int ipc_comp_connect(struct ipc *ipc, ipc_pipe_comp_connect *_connect)
 	if (!cpu_is_me(source->ipc_config.core) && !cross_core_bind)
 		return ipc4_process_on_core(source->ipc_config.core, false);
 
-	/* these might call comp_ipc4_get_attribute_remote() if necessary */
-	ret = comp_get_attribute(source, COMP_ATTR_BASE_CONFIG, &source_src_cfg);
-	if (ret < 0) {
-		tr_err(&ipc_tr, "failed to get base config for module %#x", dev_comp_id(source));
-		return IPC4_FAILURE;
+	size = MODULE_MAX_SINKS * sizeof(struct ipc4_output_pin_format) +
+		MODULE_MAX_SOURCES * sizeof(struct ipc4_input_pin_format);
+
+	/* get obs from the base config extension if the src queue ID is non-zero */
+	if (bu->extension.r.src_queue) {
+		struct ipc4_output_pin_format *out_fmt;
+		size_t output_fmt_offset;
+
+		src_basecfg_ext = rzalloc(SOF_MEM_ZONE_RUNTIME, 0, SOF_MEM_CAPS_RAM,
+					  sizeof(*src_basecfg_ext) + size);
+		if (!src_basecfg_ext)
+			return IPC4_OUT_OF_MEMORY;
+
+		ret = comp_get_attribute(source, COMP_ATTR_BASE_CONFIG_EXT, src_basecfg_ext);
+		if (!ret) {
+			size_t in_fmt_size = sizeof(struct ipc4_input_pin_format);
+			size_t out_fmt_size = sizeof(struct ipc4_output_pin_format);
+
+			/*
+			 * offset of the format for the output pin with ID 'src_queue' within the
+			 * base config extension.
+			 */
+			output_fmt_offset =
+				src_basecfg_ext->nb_input_pins * in_fmt_size +
+				bu->extension.r.src_queue * out_fmt_size;
+			out_fmt = (struct ipc4_output_pin_format *)&sink_basecfg_ext->pin_formats[output_fmt_offset];
+			obs = out_fmt->obs;
+		}
+		rfree(src_basecfg_ext);
 	}
 
-	ret = comp_get_attribute(sink, COMP_ATTR_BASE_CONFIG, &sink_src_cfg);
-	if (ret < 0) {
-		tr_err(&ipc_tr, "failed to get base config for module %#x", dev_comp_id(sink));
-		return IPC4_FAILURE;
+	/* get obs from base config if src queue ID is 0 or if base config extn is missing */
+	if (!obs) {
+		/* these might call comp_ipc4_get_attribute_remote() if necessary */
+		ret = comp_get_attribute(source, COMP_ATTR_BASE_CONFIG, &source_src_cfg);
+
+		if (ret < 0) {
+			tr_err(&ipc_tr, "failed to get base config for src module %#x",
+			       dev_comp_id(source));
+			return IPC4_FAILURE;
+		}
+		obs = source_src_cfg.obs;
 	}
 
-	/* create a buffer
-	 * in case of LL -> LL or LL->DP
-	 *	size = 2*obs of source module (obs is single buffer size)
-	 * in case of DP -> LL
-	 *	size = 2*ibs of destination (LL) module. DP queue will handle obs of DP module
-	 */
-	uint32_t buf_size;
+	/* get ibs from the base config extension if the sink queue ID is non-zero */
+	if (bu->extension.r.dst_queue) {
+		struct ipc4_input_pin_format *in_fmt;
+		size_t input_fmt_offset;
+
+		sink_basecfg_ext = rzalloc(SOF_MEM_ZONE_RUNTIME, 0, SOF_MEM_CAPS_RAM,
+					   sizeof(*sink_basecfg_ext) + size);
+		if (!sink_basecfg_ext)
+			return IPC4_OUT_OF_MEMORY;
+
+		ret = comp_get_attribute(sink, COMP_ATTR_BASE_CONFIG_EXT, sink_basecfg_ext);
+		if (!ret) {
+			/*
+			 * offset of the format for the input pin with ID 'dst_queue' within the
+			 * base config extension.
+			 */
+			input_fmt_offset =
+				bu->extension.r.dst_queue * sizeof(struct ipc4_input_pin_format);
+			in_fmt = (struct ipc4_input_pin_format *)&sink_basecfg_ext->pin_formats[input_fmt_offset];
+			ibs = in_fmt->ibs;
+		}
+		rfree(sink_basecfg_ext);
+	}
 
-	if (source->ipc_config.proc_domain == COMP_PROCESSING_DOMAIN_LL)
-		buf_size = source_src_cfg.obs * 2;
-	else
-		buf_size = sink_src_cfg.ibs * 2;
+	/* get ibs from base config if sink queue ID is 0 or if base config extn is missing */
+	if (!ibs) {
+		ret = comp_get_attribute(sink, COMP_ATTR_BASE_CONFIG, &sink_src_cfg);
+		if (ret < 0) {
+			tr_err(&ipc_tr, "failed to get base config for sink module %#x",
+			       dev_comp_id(sink));
+			return IPC4_FAILURE;
+		}
+
+		ibs = sink_src_cfg.ibs;
+	}
 
+	/* allocate buffer with size large enough to fit ibs of the sink or obs of the source */
+	buf_size = MAX(ibs * 2, obs * 2);
 	buffer = ipc4_create_buffer(source, cross_core_bind, buf_size, bu->extension.r.src_queue,
 				    bu->extension.r.dst_queue);
 	if (!buffer) {
@@ -496,8 +558,8 @@ int ipc_comp_connect(struct ipc *ipc, ipc_pipe_comp_connect *_connect)
 	 *	sink_module needs to set its IBS (input buffer size)
 	 *		as min_available in buffer's source ifc
 	 */
-	sink_set_min_free_space(audio_stream_get_sink(&buffer->stream), source_src_cfg.obs);
-	source_set_min_available(audio_stream_get_source(&buffer->stream), sink_src_cfg.ibs);
+	sink_set_min_free_space(audio_stream_get_sink(&buffer->stream), obs);
+	source_set_min_available(audio_stream_get_source(&buffer->stream), ibs);
 
 	/*
 	 * Connect and bind the buffer to both source and sink components with LL processing been

src/samples/audio/smart_amp_test_ipc4.c

@@ -66,9 +66,13 @@ static struct smart_amp_data smart_amp_priv;
 static int smart_amp_init(struct processing_module *mod)
 {
 	struct smart_amp_data *sad;
+	struct comp_dev *dev = mod->dev;
 	struct module_data *mod_data = &mod->priv;
+	const size_t in_size = sizeof(struct ipc4_input_pin_format) * SMART_AMP_NUM_IN_PINS;
+	const size_t out_size = sizeof(struct ipc4_output_pin_format) * SMART_AMP_NUM_OUT_PINS;
 	int ret;
 	const struct ipc4_base_module_extended_cfg *base_cfg = mod_data->cfg.init_data;
+	size_t size;
 
 	LOG_DBG("smart_amp_init()");
 
@@ -96,6 +100,16 @@ static int smart_amp_init(struct processing_module *mod)
 		*(struct ipc4_output_pin_format *)(base_cfg->base_cfg_ext.pin_formats
 			+ sizeof(sad->ipc4_cfg.input_pins));
 
+	/* save the base config extension */
+	size = sizeof(struct ipc4_base_module_cfg_ext) + in_size + out_size;
+	mod_data->cfg.basecfg_ext = rzalloc(SOF_MEM_ZONE_RUNTIME, 0, SOF_MEM_CAPS_RAM, size);
+	if (!mod_data->cfg.basecfg_ext) {
+		ret = -ENOMEM;
+		goto sad_fail;
+	}
+
+	memcpy_s(mod_data->cfg.basecfg_ext, size, &base_cfg->base_cfg_ext, size);
+
 	return 0;
 
 sad_fail:
@@ -155,7 +169,10 @@ static int smart_amp_free(struct processing_module *mod)
 
 #ifndef __SOF_MODULE_SERVICE_BUILD__
 	struct smart_amp_data *sad = module_get_private_data(mod);
+	struct module_data *mod_data = &mod->priv;
+	struct comp_dev *dev = mod->dev;
 
+	rfree(mod_data->cfg.basecfg_ext);
 	rfree(sad);
 #endif