Tools: Testbench: Change file IPC3 init to be process compatible

This change is needed to change file component type to
SOF_COMP_MODULE_ADAPTER to be able to handle the file
configuration without exceptions in comp_specific_builder().

Signed-off-by: Seppo Ingalsuo <[email protected]>

src/include/ipc/topology.h

@@ -241,26 +241,6 @@ struct sof_ipc_comp_process {
 	unsigned char data[];
 } __attribute__((packed, aligned(4)));
 
-/* IPC file component used by testbench only */
-struct sof_ipc_comp_file {
-	/* These need to be the same as in above sof_ipc_comp_process */
-	struct sof_ipc_comp comp;
-	struct sof_ipc_comp_config config;
-	uint32_t size;	/**< size of bespoke data section in bytes */
-	uint32_t type;	/**< sof_ipc_process_type */
-
-	/* reserved for future use */
-	uint32_t reserved[7];
-
-	/* These are additional parameters for file */
-	uint32_t rate;
-	uint32_t channels;
-	char *fn;
-	uint32_t mode;
-	uint32_t frame_fmt;
-	uint32_t direction;	/**< SOF_IPC_STREAM_ */
-} __attribute__((packed, aligned(4)));
-
 /* frees components, buffers and pipelines
  * SOF_IPC_TPLG_COMP_FREE, SOF_IPC_TPLG_PIPE_FREE, SOF_IPC_TPLG_BUFFER_FREE
  */

src/ipc/ipc3/helper.c

@@ -200,9 +200,6 @@ union ipc_config_specific {
 static int comp_specific_builder(struct sof_ipc_comp *comp,
 				 union ipc_config_specific *config)
 {
-#if CONFIG_LIBRARY
-	struct sof_ipc_comp_file *file = (struct sof_ipc_comp_file *)comp;
-#endif
 	struct sof_ipc_comp_host *host = (struct sof_ipc_comp_host *)comp;
 	struct sof_ipc_comp_dai *dai = (struct sof_ipc_comp_dai *)comp;
 	struct sof_ipc_comp_volume *vol = (struct sof_ipc_comp_volume *)comp;
@@ -214,27 +211,6 @@ static int comp_specific_builder(struct sof_ipc_comp *comp,
 	memset(config, 0, sizeof(*config));
 
 	switch (comp->type) {
-#if CONFIG_LIBRARY
-	/* test bench maps host and DAIs to a file */
-	case SOF_COMP_FILEREAD:
-	case SOF_COMP_FILEWRITE:
-		if (IPC_TAIL_IS_SIZE_INVALID(*file))
-			return -EBADMSG;
-
-		config->file.channels = file->channels;
-		config->file.fn = file->fn;
-		config->file.frame_fmt = file->frame_fmt;
-		config->file.mode = file->mode;
-		config->file.rate = file->rate;
-		config->file.direction = file->direction;
-
-		/* For module_adapter_init_data() ipc_module_adapter compatibility */
-		config->file.module_header.type = proc->type;
-		config->file.module_header.size = proc->size;
-		config->file.module_header.data = (uint8_t *)proc->data -
-			sizeof(struct ipc_config_process);
-		break;
-#endif
 	case SOF_COMP_HOST:
 	case SOF_COMP_SG_HOST:
 		if (IPC_TAIL_IS_SIZE_INVALID(*host))
@@ -299,6 +275,8 @@ static int comp_specific_builder(struct sof_ipc_comp *comp,
 	case SOF_COMP_SMART_AMP:
 	case SOF_COMP_MODULE_ADAPTER:
 	case SOF_COMP_NONE:
+	case SOF_COMP_FILEREAD:
+	case SOF_COMP_FILEWRITE:
 		if (IPC_TAIL_IS_SIZE_INVALID(*proc))
 			return -EBADMSG;
 

tools/testbench/file.c

@@ -585,18 +585,19 @@ static int file_init(struct processing_module *mod)
 {
 	struct comp_dev *dev = mod->dev;
 	struct module_data *mod_data = &mod->priv;
+	struct module_config *cfg = &mod_data->cfg;
 	struct copier_data *ccd;
 	struct file_comp_data *cd;
 	int ret;
 
 #if CONFIG_IPC_MAJOR_4
 	const struct ipc4_file_module_cfg *module_cfg =
-		(const struct ipc4_file_module_cfg *)mod_data->cfg.init_data;
-
-	const struct ipc4_file_config *ipc_file = &module_cfg->config;
+		(const struct ipc4_file_module_cfg *)cfg->init_data;
+	const struct sof_file_config *ipc_file = &module_cfg->config;
+	const size_t init_data_size = sizeof(struct ipc4_file_module_cfg);
 #else
-	const struct ipc_comp_file *ipc_file =
-		(const struct ipc_comp_file *)mod_data->cfg.init_data;
+	const struct sof_file_config *ipc_file = (const struct sof_file_config *)cfg->init_data;
+	const size_t init_data_size = sizeof(struct sof_file_config);
 #endif
 
 	tb_debug_print("file_init()\n");
@@ -605,6 +606,11 @@ static int file_init(struct processing_module *mod)
 	if (!ccd)
 		return -ENOMEM;
 
+	if (cfg->size != init_data_size) {
+		fprintf(stderr, "error: missing file setup from init IPC.\n");
+		return -EINVAL;
+	}
+
 	mod_data->private = ccd;
 
 	/* File component data is placed to copier's ipcgtw_data */
@@ -616,6 +622,8 @@ static int file_init(struct processing_module *mod)
 
 	file_set_comp_data(ccd, cd);
 
+	memcpy_s(&cd->config, sizeof(cd->config), ipc_file, sizeof(*ipc_file));
+
 	/* default function for processing samples */
 	cd->file_func = file_default;
 
@@ -631,11 +639,8 @@ static int file_init(struct processing_module *mod)
 	cd->fs.f_format = get_file_format(cd->fs.fn);
 
 	/* set file comp mode */
-	cd->fs.mode = ipc_file->mode;
-	cd->rate = ipc_file->rate;
-	cd->channels = ipc_file->channels;
-	cd->frame_fmt = ipc_file->frame_fmt;
-	dev->direction = ipc_file->direction;
+	cd->fs.mode = cd->config.mode;
+	dev->direction = cd->config.direction;
 	dev->direction_set = true;
 
 	/* open file handle(s) depending on mode */
@@ -859,10 +864,10 @@ static int file_get_hw_params(struct comp_dev *dev,
 
 	tb_debug_print("file_hw_params()");
 	params->direction = dir;
-	params->rate = cd->rate;
-	params->channels = cd->channels;
+	params->rate = cd->config.rate;
+	params->channels = cd->config.channels;
 	params->buffer_fmt = 0;
-	params->frame_fmt = cd->frame_fmt;
+	params->frame_fmt = cd->config.frame_fmt;
 	return 0;
 }
 

tools/testbench/include/testbench/file.h

@@ -45,14 +45,21 @@ struct file_state {
 	bool copy_timeout;
 };
 
+struct sof_file_config {
+	uint32_t rate;
+	uint32_t channels;
+	char *fn;
+	uint32_t mode;
+	uint32_t frame_fmt;
+	uint32_t direction;	/**< SOF_IPC_STREAM_ */
+} __attribute__((packed, aligned(4)));
+
 struct file_comp_data;
 
 /* file comp data */
 struct file_comp_data {
+	struct sof_file_config config;
 	struct file_state fs;
-	enum sof_ipc_frame frame_fmt;
-	uint32_t channels;
-	uint32_t rate;
 	int sample_container_bytes;
 	int (*file_func)(struct file_comp_data *cd, struct audio_stream *sink,
 			 struct audio_stream *source, uint32_t frames);

tools/testbench/include/testbench/file_ipc4.h

@@ -8,19 +8,11 @@
 
 #include <ipc/topology.h>
 #include <ipc4/base-config.h>
-
-struct ipc4_file_config {
-	uint32_t rate;
-	uint32_t channels;
-	char *fn;
-	uint32_t mode;
-	uint32_t frame_fmt;
-	uint32_t direction;	/**< SOF_IPC_STREAM_ */
-};
+#include "file.h"
 
 struct ipc4_file_module_cfg {
 	struct ipc4_base_module_cfg base_cfg;
-	struct ipc4_file_config config;
+	struct sof_file_config config;
 } __packed __aligned(8);
 
 #endif /*  __TESTBENCH_FILE_IPC4_H_ */

tools/testbench/topology_ipc3.c

@@ -251,7 +251,7 @@ static int tb_register_src(struct testbench_prm *tp, struct tplg_context *ctx)
 
 /* load fileread component */
 static int tb_new_fileread(struct tplg_context *ctx,
-			   struct sof_ipc_comp_file *fileread)
+			   struct sof_ipc_comp_process *fileread)
 {
 	struct snd_soc_tplg_vendor_array *array = &ctx->widget->priv.array[0];
 	size_t total_array_size = 0;
@@ -292,14 +292,13 @@ static int tb_new_fileread(struct tplg_context *ctx,
 	}
 
 	/* configure fileread */
-	fileread->mode = FILE_READ;
 	fileread->comp.id = comp_id;
 
 	/* use fileread comp as scheduling comp */
-	fileread->size = sizeof(struct ipc_comp_file);
+	fileread->size = sizeof(*fileread);
 	fileread->comp.core = ctx->core_id;
-	fileread->comp.hdr.size = sizeof(struct sof_ipc_comp_file) + UUID_SIZE;
-	fileread->comp.type = SOF_COMP_FILEREAD;
+	fileread->comp.hdr.size = sizeof(*fileread) + UUID_SIZE;
+	fileread->comp.type = SOF_COMP_MODULE_ADAPTER;
 	fileread->comp.pipeline_id = ctx->pipeline_id;
 	fileread->config.hdr.size = sizeof(struct sof_ipc_comp_config);
 	fileread->comp.ext_data_length = UUID_SIZE;
@@ -308,7 +307,7 @@ static int tb_new_fileread(struct tplg_context *ctx,
 
 /* load filewrite component */
 static int tb_new_filewrite(struct tplg_context *ctx,
-			    struct sof_ipc_comp_file *filewrite)
+			    struct sof_ipc_comp_process *filewrite)
 {
 	struct snd_soc_tplg_vendor_array *array = &ctx->widget->priv.array[0];
 	size_t total_array_size = 0;
@@ -349,10 +348,9 @@ static int tb_new_filewrite(struct tplg_context *ctx,
 	/* configure filewrite */
 	filewrite->comp.core = ctx->core_id;
 	filewrite->comp.id = comp_id;
-	filewrite->mode = FILE_WRITE;
 	filewrite->size = sizeof(struct ipc_comp_file);
-	filewrite->comp.hdr.size = sizeof(struct sof_ipc_comp_file) + UUID_SIZE;
-	filewrite->comp.type = SOF_COMP_FILEWRITE;
+	filewrite->comp.hdr.size = sizeof(*filewrite) + UUID_SIZE;
+	filewrite->comp.type = SOF_COMP_MODULE_ADAPTER;
 	filewrite->comp.pipeline_id = ctx->pipeline_id;
 	filewrite->config.hdr.size = sizeof(struct sof_ipc_comp_config);
 	filewrite->comp.ext_data_length = UUID_SIZE;
@@ -364,7 +362,8 @@ static int tb_register_fileread(struct testbench_prm *tp,
 				struct tplg_context *ctx, int dir)
 {
 	struct sof *sof = ctx->sof;
-	struct sof_ipc_comp_file *fileread;
+	struct sof_ipc_comp_process *fileread;
+	struct sof_file_config *config;
 	struct sof_uuid *file_uuid;
 	int ret;
 
@@ -378,43 +377,46 @@ static int tb_register_fileread(struct testbench_prm *tp,
 	if (ret < 0)
 		return ret;
 
+	file_uuid = (struct sof_uuid *)(fileread + 1);
+	memcpy(file_uuid, &tb_file_uuid, sizeof(*file_uuid));
+
 	/* configure fileread */
-	fileread->fn = strdup(tp->input_file[tp->input_file_index]);
+	config = (struct sof_file_config *)(file_uuid + 1);
+	config->fn = strdup(tp->input_file[tp->input_file_index]);
 	tp->fr[tp->input_file_index].id = ctx->comp_id;
 	tp->fr[tp->input_file_index].instance_id = ctx->comp_id;
 	tp->fr[tp->input_file_index].pipeline_id = ctx->pipeline_id;
 	tp->input_file_index++;
+	fileread->size = sizeof(*config);
 
 	/* use fileread comp as scheduling comp */
 	ctx->sched_id = ctx->comp_id;
 
 	/* Set format from testbench command line*/
-	fileread->rate = tp->fs_in;
-	fileread->channels = tp->channels_in;
-	fileread->frame_fmt = tp->frame_fmt;
-	fileread->direction = dir;
-
-	file_uuid = (struct sof_uuid *)((uint8_t *)fileread + sizeof(struct sof_ipc_comp_file));
-	memcpy(file_uuid, &tb_file_uuid, sizeof(*file_uuid));
+	config->rate = tp->fs_in;
+	config->channels = tp->channels_in;
+	config->frame_fmt = tp->frame_fmt;
+	config->direction = dir;
+	config->mode = FILE_READ;
 
 	/* create fileread component */
 	if (ipc_comp_new(sof->ipc, ipc_to_comp_new(fileread)) < 0) {
 		fprintf(stderr, "error: file read\n");
-		free(fileread->fn);
-		return -EINVAL;
+		ret = -EINVAL;
 	}
 
-	free(fileread->fn);
+	free(config->fn);
 	free(fileread);
-	return 0;
+	return ret;
 }
 
 /* load filewrite component */
 static int tb_register_filewrite(struct testbench_prm *tp,
 				 struct tplg_context *ctx, int dir)
 {
 	struct sof *sof = ctx->sof;
-	struct sof_ipc_comp_file *filewrite;
+	struct sof_ipc_comp_process *filewrite;
+	struct sof_file_config *config;
 	struct sof_uuid *file_uuid;
 	int ret;
 
@@ -426,37 +428,40 @@ static int tb_register_filewrite(struct testbench_prm *tp,
 	if (ret < 0)
 		return ret;
 
+	file_uuid = (struct sof_uuid *)(filewrite + 1);
+	memcpy(file_uuid, &tb_file_uuid, sizeof(*file_uuid));
+
 	/* configure filewrite (multiple output files are supported.) */
+	config = (struct sof_file_config *)(file_uuid + 1);
+	filewrite->size = sizeof(*config);
 	if (!tp->output_file[tp->output_file_index]) {
 		fprintf(stderr, "error: output[%d] file name is null\n",
 			tp->output_file_index);
 		return -EINVAL;
 	}
-	filewrite->fn = strdup(tp->output_file[tp->output_file_index]);
+
+	config->fn = strdup(tp->output_file[tp->output_file_index]);
 	tp->fw[tp->output_file_index].id = ctx->comp_id;
 	tp->fw[tp->output_file_index].instance_id = ctx->comp_id;
 	tp->fw[tp->output_file_index].pipeline_id = ctx->pipeline_id;
 	tp->output_file_index++;
 
 	/* Set format from testbench command line*/
-	filewrite->rate = tp->fs_out;
-	filewrite->channels = tp->channels_out;
-	filewrite->frame_fmt = tp->frame_fmt;
-	filewrite->direction = dir;
-
-	file_uuid = (struct sof_uuid *)((uint8_t *)filewrite + sizeof(struct sof_ipc_comp_file));
-	memcpy(file_uuid, &tb_file_uuid, sizeof(*file_uuid));
+	config->rate = tp->fs_out;
+	config->channels = tp->channels_out;
+	config->frame_fmt = tp->frame_fmt;
+	config->direction = dir;
+	config->mode = FILE_WRITE;
 
 	/* create filewrite component */
 	if (ipc_comp_new(sof->ipc, ipc_to_comp_new(filewrite)) < 0) {
 		fprintf(stderr, "error: new file write\n");
-		free(filewrite->fn);
-		return -EINVAL;
+		ret = -EINVAL;
 	}
 
-	free(filewrite->fn);
+	free(config->fn);
 	free(filewrite);
-	return 0;
+	return ret;
 }
 
 static int tb_register_aif_in_out(struct testbench_prm *tb,