diff --git a/tools/testbench/README.md b/tools/testbench/README.md
index 258888211888..ffe160881244 100644
--- a/tools/testbench/README.md
+++ b/tools/testbench/README.md
@@ -64,6 +64,37 @@ directions, use -p 1,2,3,4 and provide multiple input and output
 files separated with comma. Use e.g. -i i1.raw,i2.raw
 -o o1.raw,o2.raw.
 
+### Apply controls to simulation
+
+The testbench supports shell script like amixer and sleep commands for
+the controls. Create e.g. this script file as controls.sh:
+
+```
+#!/bin/sh
+
+# Example test sequence for DRC and volume components
+
+amixer -c0 cset name='Post Mixer Analog Playback DRC switch' off
+amixer -c0 cset name='Post Mixer Analog Playback Volume' 40,30
+sleep 1
+amixer -c0 cset name='Post Mixer Analog Playback Volume' 0
+sleep 1
+amixer -c0 cset name='Post Mixer Analog Playback Volume' 45
+```
+
+Then generarate sine wave (997 Hz, -3 dB level, 3 seconds) with sox
+and check the impact to processed signal with next commands:
+
+```
+sox -n --encoding signed-integer -L -r 48000 -c 2 -b 32 in.raw synth 3 sine 997 norm -3
+
+tools/testbench/build_testbench/install/bin/sof-testbench4 -r 48000 -c 2 -b S32_LE   -p 1,2 \
+ -t tools/build_tools/topology/topology2/production/sof-hda-generic.tplg \
+-i in.raw -o out.raw -s controls.sh
+
+sox --encoding signed-integer -L -r 48000 -c 2 -b 32 out.raw out.wav
+```
+
 ### Run testbench with helper script
 
 The scripts/sof-testbench-helper.sh simplifies the task. See the help
diff --git a/tools/testbench/file.c b/tools/testbench/file.c
index 99c3f475a011..a6a768cf7355 100644
--- a/tools/testbench/file.c
+++ b/tools/testbench/file.c
@@ -632,8 +632,8 @@ static int file_init(struct processing_module *mod)
 
 	/* set file comp mode */
 	cd->fs.mode = ipc_file->mode;
-	cd->rate = ipc_file->rate;
-	cd->channels = ipc_file->channels;
+	cd->fs.rate = ipc_file->rate;
+	cd->fs.channels = ipc_file->channels;
 	cd->frame_fmt = ipc_file->frame_fmt;
 	dev->direction = ipc_file->direction;
 	dev->direction_set = true;
@@ -859,8 +859,8 @@ static int file_get_hw_params(struct comp_dev *dev,
 
 	tb_debug_print("file_hw_params()\n");
 	params->direction = dir;
-	params->rate = cd->rate;
-	params->channels = cd->channels;
+	params->rate = cd->fs.rate;
+	params->channels = cd->fs.channels;
 	params->buffer_fmt = 0;
 	params->frame_fmt = cd->frame_fmt;
 	return 0;
diff --git a/tools/testbench/include/testbench/file.h b/tools/testbench/include/testbench/file.h
index 889649094429..c9552c5a4425 100644
--- a/tools/testbench/include/testbench/file.h
+++ b/tools/testbench/include/testbench/file.h
@@ -42,6 +42,8 @@ struct file_state {
 	FILE *rfh, *wfh; /* read/write file handle */
 	char *fn;
 	int copy_count;
+	int channels;
+	int rate;
 	int n;
 	enum file_mode mode;
 	enum file_format f_format;
@@ -56,8 +58,6 @@ struct file_comp_data;
 struct file_comp_data {
 	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);
diff --git a/tools/testbench/include/testbench/topology_ipc4.h b/tools/testbench/include/testbench/topology_ipc4.h
index 4a3d9ec96826..0f5d0699e08f 100644
--- a/tools/testbench/include/testbench/topology_ipc4.h
+++ b/tools/testbench/include/testbench/topology_ipc4.h
@@ -48,6 +48,10 @@ int tb_new_process(struct testbench_prm *tp);
 int tb_pipelines_set_state(struct testbench_prm *tp, int state, int dir);
 int tb_send_bytes_data(struct tb_mq_desc *ipc_tx, struct tb_mq_desc *ipc_rx,
 		       uint32_t module_id, uint32_t instance_id, struct sof_abi_hdr *abi);
+int tb_send_volume_control(struct tb_mq_desc *ipc_tx, struct tb_mq_desc *ipc_rx,
+			   struct tb_ctl *ctl, int *control_values, int num_values);
+int tb_send_alsa_control(struct tb_mq_desc *ipc_tx, struct tb_mq_desc *ipc_rx, struct tb_ctl *ctl,
+			 int *control_values, int num_values, int param_id);
 int tb_set_reset_state(struct testbench_prm *tp);
 int tb_set_running_state(struct testbench_prm *tp);
 int tb_set_up_pipeline(struct testbench_prm *tp, struct tplg_pipeline_info *pipe_info);
diff --git a/tools/testbench/include/testbench/utils.h b/tools/testbench/include/testbench/utils.h
index 9d11dcab2641..1d6df8faeeab 100644
--- a/tools/testbench/include/testbench/utils.h
+++ b/tools/testbench/include/testbench/utils.h
@@ -19,6 +19,10 @@
 #define TB_MAX_INPUT_FILE_NUM		16
 #define TB_MAX_OUTPUT_FILE_NUM		16
 #define TB_MAX_PIPELINES_NUM		16
+#define TB_MAX_CMD_CHARS		256
+#define TB_MAX_CTL_NAME_CHARS		128
+#define TB_MAX_VOLUME_SIZE		120
+#define TB_MAX_BYTES_DATA_SIZE		8192
 
 /* number of widgets types supported in testbench */
 #define TB_NUM_WIDGETS_SUPPORTED	16
@@ -32,13 +36,34 @@ struct file_comp_lookup {
 	struct file_state *state;
 };
 
+struct tb_ctl {
+	struct tplg_comp_info *comp_info;
+	unsigned int module_id;
+	unsigned int instance_id;
+	unsigned int type;
+	unsigned int volume_table[TB_MAX_VOLUME_SIZE];
+	unsigned int index;
+	char *data;
+	char name[TB_MAX_CTL_NAME_CHARS];
+	union {
+		struct snd_soc_tplg_mixer_control mixer_ctl;
+		struct snd_soc_tplg_enum_control enum_ctl;
+		struct snd_soc_tplg_bytes_control bytes_ctl;
+	};
+};
+
+struct tb_glb_state {
+	char magic[8];			/* SOF_MAGIC */
+	uint32_t num_ctls;		/* number of ctls */
+	size_t size;			/* size of this structure in bytes */
+	struct tb_ctl *ctl;
+};
+
 #if CONFIG_IPC_MAJOR_4
 
 #define TB_NAME_SIZE		256
 #define TB_MAX_CONFIG_COUNT	2
 #define TB_MAX_CONFIG_NAME_SIZE	64
-#define TB_MAX_VOLUME_SIZE	120
-#define TB_MAX_DATA_SIZE	512
 #define TB_MAX_CTLS		16
 
 struct tb_mq_desc {
@@ -55,27 +80,6 @@ struct tb_config {
 	int channels;
 	unsigned long format;
 };
-
-struct tb_ctl {
-	unsigned int module_id;
-	unsigned int instance_id;
-	unsigned int type;
-	unsigned int volume_table[TB_MAX_VOLUME_SIZE];
-	unsigned int index;
-	char data[TB_MAX_DATA_SIZE];
-	union {
-		struct snd_soc_tplg_mixer_control mixer_ctl;
-		struct snd_soc_tplg_enum_control enum_ctl;
-		struct snd_soc_tplg_bytes_control bytes_ctl;
-	};
-};
-
-struct tb_glb_state {
-	char magic[8];			/* SOF_MAGIC */
-	uint32_t num_ctls;		/* number of ctls */
-	size_t size;			/* size of this structure in bytes */
-	struct tb_ctl *ctl;
-};
 #endif
 
 /*
@@ -93,6 +97,7 @@ struct testbench_prm {
 	char *output_file[TB_MAX_OUTPUT_FILE_NUM]; /* output file names */
 	char *tplg_file; /* topology file to use */
 	char *bits_in; /* input bit format */
+	char *control_file;
 	int input_file_num; /* number of input files */
 	int output_file_num; /* number of output files */
 	int pipeline_num;
@@ -100,8 +105,6 @@ struct testbench_prm {
 	bool copy_check;
 	int trace_level;
 	int dynamic_pipeline_iterations;
-	int tick_period_us;
-	int pipeline_duration_ms;
 	char *pipeline_string;
 	int output_file_index;
 	int input_file_index;
@@ -125,6 +128,9 @@ struct testbench_prm {
 	/* topology */
 	struct tplg_context tplg;
 
+	FILE *control_fh;
+	struct tb_glb_state glb_ctx;
+
 #if CONFIG_IPC_MAJOR_4
 	struct list_item widget_list;
 	struct list_item route_list;
@@ -138,12 +144,12 @@ struct testbench_prm {
 	struct tb_config config[TB_MAX_CONFIG_COUNT];
 	int num_configs;
 	int period_frames;
-	struct tb_glb_state glb_ctx;
 #endif
 };
 
 extern int debug;
 
+int tb_decode_enum(struct snd_soc_tplg_enum_control *enum_ctl, char *token);
 int tb_find_file_components(struct testbench_prm *tp);
 int tb_free_all_pipelines(struct testbench_prm *tp);
 int tb_load_topology(struct testbench_prm *tp);
@@ -152,7 +158,10 @@ int tb_pipeline_params(struct testbench_prm *tp, struct ipc *ipc, struct pipelin
 int tb_pipeline_reset(struct ipc *ipc, struct pipeline *p);
 int tb_pipeline_start(struct ipc *ipc, struct pipeline *p);
 int tb_pipeline_stop(struct ipc *ipc, struct pipeline *p);
+int tb_read_controls(struct testbench_prm *tp, int64_t *sleep_ns);
+int tb_set_enum_control(struct testbench_prm *tp, struct tb_ctl *ctl, char *control_params);
 int tb_set_reset_state(struct testbench_prm *tp);
+int tb_set_mixer_control(struct testbench_prm *tp, struct tb_ctl *ctl, char *control_params);
 int tb_set_running_state(struct testbench_prm *tp);
 int tb_set_up_all_pipelines(struct testbench_prm *tp);
 int tb_setup(struct sof *sof, struct testbench_prm *tp);
diff --git a/tools/testbench/testbench.c b/tools/testbench/testbench.c
index be3e77ec918c..45c5c8843494 100644
--- a/tools/testbench/testbench.c
+++ b/tools/testbench/testbench.c
@@ -128,9 +128,8 @@ static void print_usage(char *executable)
 	printf("     4 shows debug traces and previous, plus other testbench  debug messages\n");
 	printf("  -p <pipeline1,pipeline2,...>\n");
 	printf("  -C <number of copy() iterations>\n");
-	printf("  -D <pipeline duration in ms>\n");
 	printf("  -P <number of dynamic pipeline iterations>\n");
-	printf("  -T <microseconds for tick, 0 for batch mode>\n\n");
+	printf("  -s <script file to set controls, with amixer and sleep commands>\n\n");
 	printf("Options for input and output format override:\n");
 	printf("  -b <input_format>, S16_LE, S24_LE, or S32_LE\n");
 	printf("  -c <input channels>\n");
@@ -148,7 +147,7 @@ static int parse_input_args(int argc, char **argv, struct testbench_prm *tp)
 	int option = 0;
 	int ret = 0;
 
-	while ((option = getopt(argc, argv, "hd:i:o:t:b:r:R:c:n:C:P:p:T:D:")) != -1) {
+	while ((option = getopt(argc, argv, "hd:i:o:t:b:r:R:c:n:C:P:p:s:")) != -1) {
 		switch (option) {
 		/* input sample file */
 		case 'i':
@@ -218,14 +217,9 @@ static int parse_input_args(int argc, char **argv, struct testbench_prm *tp)
 			ret = parse_pipelines(optarg, tp);
 			break;
 
-		/* Microseconds for tick, 0 = batch (tickless) */
-		case 'T':
-			tp->tick_period_us = atoi(optarg);
-			break;
-
-		/* pipeline duration in millisec, 0 = realtime (tickless) */
-		case 'D':
-			tp->pipeline_duration_ms = atoi(optarg);
+		/* control script file name */
+		case 's':
+			tp->control_file = strdup(optarg);
 			break;
 
 		/* print usage */
@@ -314,13 +308,14 @@ static void test_pipeline_stats(struct testbench_prm *tp, long long delta_t)
  */
 static int pipline_test(struct testbench_prm *tp)
 {
+	float samples_to_ns;
 	int dp_count = 0;
-	struct timespec ts;
 	struct timespec td0, td1;
+	struct file_state *out_stat;
 	long long delta_t;
+	int64_t next_control_ns;
+	int64_t time_ns;
 	int err;
-	int nsleep_time;
-	int nsleep_limit;
 
 	/* build, run and teardown pipelines */
 	while (dp_count < tp->dynamic_pipeline_iterations) {
@@ -356,37 +351,42 @@ static int pipline_test(struct testbench_prm *tp)
 			break;
 		}
 
+		/* Use first file writer to create simulation time. Calculate coefficient
+		 * to calculate current time from file write samples count
+		 */
+		out_stat = tp->fw[0].state;
+		samples_to_ns = 1.0e9 / ((float)out_stat->channels * out_stat->rate);
+
+		/* Apply initial controls time to call again controls handler */
+		err = tb_read_controls(tp, &next_control_ns);
+		if (err) {
+			fprintf(stderr, "error: failed to read control commands.\n");
+			goto out;
+		}
+
 		tb_gettime(&td0);
 
-		/* sleep to let the pipeline work - we exit at timeout OR
-		 * if copy iterations OR max_samples is reached (whatever first)
-		 */
-		nsleep_time = 0;
-		ts.tv_sec = tp->tick_period_us / 1000000;
-		ts.tv_nsec = (tp->tick_period_us % 1000000) * 1000;
-		if (!tp->copy_check)
-			nsleep_limit = INT_MAX;
-		else
-			nsleep_limit = tp->copy_iterations *
-				       tp->pipeline_duration_ms;
-
-		while (nsleep_time < nsleep_limit) {
-#if defined __XCC__
-			err = 0;
-#else
-			/* wait for next tick */
-			err = nanosleep(&ts, &ts);
-#endif
-			if (err == 0) {
-				nsleep_time += tp->tick_period_us; /* sleep fully completed */
-				if (tb_schedule_pipeline_check_state(tp))
-					break;
-			} else {
-				if (err == EINTR) {
-					continue; /* interrupted - keep going */
-				} else {
-					printf("error: sleep failed: %s\n", strerror(err));
+		while (true) {
+			if (tp->copy_check) {
+				if (tp->copy_iterations-- <= 0)
 					break;
+			}
+
+			if (tb_schedule_pipeline_check_state(tp))
+				break;
+
+			if (next_control_ns) {
+				time_ns = (int64_t)(samples_to_ns * out_stat->n);
+				if (time_ns >= next_control_ns) {
+					err = tb_read_controls(tp, &next_control_ns);
+					if (err) {
+						fprintf(stderr,
+							"error: failed to read control commands.\n");
+						goto out;
+					}
+
+					if (next_control_ns)
+						next_control_ns += time_ns;
 				}
 			}
 		}
@@ -395,6 +395,7 @@ static int pipline_test(struct testbench_prm *tp)
 
 		tb_gettime(&td1);
 
+out:
 		err = tb_set_reset_state(tp);
 		if (err < 0) {
 			fprintf(stderr, "error: pipeline reset %d failed %d\n",
@@ -438,7 +439,6 @@ int main(int argc, char **argv)
 	tp->pipeline_string = calloc(1, TB_DEBUG_MSG_LEN);
 	tp->pipelines[0] = 1;
 	tp->pipeline_num = 1;
-	tp->pipeline_duration_ms = 5000;
 	tp->copy_iterations = 1;
 	tp->trace_level = LOG_LEVEL_INFO;
 
@@ -489,6 +489,16 @@ int main(int argc, char **argv)
 		goto out;
 	}
 
+	if (tp->control_file) {
+		tp->control_fh = fopen(tp->control_file, "r");
+		if (!tp->control_fh) {
+			fprintf(stderr, "error: opening script %s (%s).\n",
+				tp->control_file, strerror(errno));
+			ret = -errno;
+			goto out;
+		}
+	}
+
 	/* build, run and teardown pipelines */
 	pipline_test(tp);
 
@@ -500,6 +510,10 @@ int main(int argc, char **argv)
 	/* free all other data */
 	free(tp->bits_in);
 	free(tp->tplg_file);
+	free(tp->control_file);
+	if (tp->control_fh)
+		fclose(tp->control_fh);
+
 	for (i = 0; i < tp->output_file_num; i++)
 		free(tp->output_file[i]);
 
diff --git a/tools/testbench/topology_ipc4.c b/tools/testbench/topology_ipc4.c
index 4e93eea6ae45..5917da8cb64e 100644
--- a/tools/testbench/topology_ipc4.c
+++ b/tools/testbench/topology_ipc4.c
@@ -1316,6 +1316,8 @@ static int tb_kcontrol_cb_new(struct snd_soc_tplg_ctl_hdr *tplg_ctl,
 		ctl->type = tplg_ctl->type;
 		tlv = &tplg_ctl->tlv;
 		scale = &tlv->scale;
+		ctl->comp_info = comp_info;
+		strncpy(ctl->name, tplg_ctl->name, TB_MAX_CTL_NAME_CHARS);
 
 		/* populate the volume table */
 		for (i = 0; i < tplg_mixer->max + 1 ; i++) {
@@ -1338,6 +1340,8 @@ static int tb_kcontrol_cb_new(struct snd_soc_tplg_ctl_hdr *tplg_ctl,
 		ctl->enum_ctl = *tplg_enum;
 		ctl->index = index;
 		ctl->type = tplg_ctl->type;
+		ctl->comp_info = comp_info;
+		strncpy(ctl->name, tplg_ctl->name, TB_MAX_CTL_NAME_CHARS);
 		break;
 	case SND_SOC_TPLG_CTL_BYTES:
 	{
@@ -1349,7 +1353,14 @@ static int tb_kcontrol_cb_new(struct snd_soc_tplg_ctl_hdr *tplg_ctl,
 		ctl->bytes_ctl = *tplg_bytes;
 		ctl->index = index;
 		ctl->type = tplg_ctl->type;
-		memcpy(ctl->data, tplg_bytes->priv.data, tplg_bytes->priv.size);
+		if (tplg_bytes->priv.size > TB_MAX_BYTES_DATA_SIZE) {
+			fprintf(stderr, "Error: Too large bytes data size %d\n",
+				tplg_bytes->priv.size);
+			return -EINVAL;
+		}
+		ctl->data = tplg_bytes->priv.data;
+		ctl->comp_info = comp_info;
+		strncpy(ctl->name, tplg_ctl->name, TB_MAX_CTL_NAME_CHARS);
 		break;
 	}
 	default:
@@ -1735,4 +1746,146 @@ int tb_send_bytes_data(struct tb_mq_desc *ipc_tx, struct tb_mq_desc *ipc_rx,
 	return ret;
 }
 
+int tb_send_volume_control(struct tb_mq_desc *ipc_tx, struct tb_mq_desc *ipc_rx,
+			   struct tb_ctl *ctl, int *control_values, int num_values)
+{
+	struct ipc4_module_large_config config = {{ 0 }};
+	struct ipc4_peak_volume_config volume;
+	struct ipc4_message_reply reply;
+	struct ipc4_peak_volume_config *volume_config;
+	void *msg;
+	bool all_channels_equal = true;
+	int max_val;
+	int size;
+	int ret;
+	int val;
+	int i;
+
+	volume_config = ctl->comp_info->ipc_payload + sizeof(struct ipc4_base_module_cfg);
+	max_val = ctl->mixer_ctl.max;
+	val = control_values[0];
+	for (i = 0; i < num_values; i++) {
+		if (i > 0 && control_values[i] != val)
+			all_channels_equal = false;
+
+		if (control_values[i] < 0 || control_values[i] > max_val) {
+			fprintf(stderr, "error: control value %d is illegal.\n", control_values[i]);
+			return -EINVAL;
+		}
+	}
+
+	for (i = 0; i < num_values; i++) {
+		if (all_channels_equal) {
+			volume.channel_id = IPC4_ALL_CHANNELS_MASK;
+			volume.target_volume = ctl->volume_table[val];
+		} else {
+			volume.channel_id = i;
+			volume.target_volume = ctl->volume_table[control_values[i]];
+		}
+
+		/* get curve duration and type from topology */
+		volume.curve_type = volume_config->curve_type;
+		volume.curve_duration = volume_config->curve_duration;
+
+		/* configure the IPC message */
+		tb_ctl_ipc_message(&config, IPC4_VOLUME, sizeof(volume), ctl->module_id,
+				   ctl->instance_id, SOF_IPC4_MOD_LARGE_CONFIG_SET);
+		config.extension.r.final_block = 1;
+		config.extension.r.init_block = 1;
+
+		size = sizeof(config) + sizeof(volume);
+		msg = calloc(size, 1);
+		if (!msg)
+			return -ENOMEM;
+
+		memcpy(msg, &config, sizeof(config));
+		memcpy(msg + sizeof(config), &volume, sizeof(volume));
+
+		/* send the message and check status */
+		ret = tb_mq_cmd_tx_rx(ipc_tx, ipc_rx, msg, size, &reply, sizeof(reply));
+		free(msg);
+		if (ret < 0) {
+			fprintf(stderr, "failed to set volume control %s\n", ctl->name);
+			return ret;
+		}
+
+		if (reply.primary.r.status != IPC4_SUCCESS) {
+			fprintf(stderr, "volume control %s set failed with status %d\n",
+				ctl->name, reply.primary.r.status);
+			return -EINVAL;
+		}
+
+		if (all_channels_equal)
+			break;
+	}
+
+	return 0;
+}
+
+int tb_send_alsa_control(struct tb_mq_desc *ipc_tx, struct tb_mq_desc *ipc_rx,
+			 struct tb_ctl *ctl, int *control_values, int num_values, int param_id)
+{
+	struct ipc4_module_large_config config = {{ 0 }};
+	struct sof_ipc4_control_msg_payload *data;
+	struct ipc4_message_reply reply;
+	void *msg;
+	int data_size;
+	int msg_size;
+	int ret;
+	int i;
+
+	/* size of control data */
+	data_size = num_values * sizeof(struct sof_ipc4_ctrl_value_chan) + sizeof(*data);
+
+	/* allocate memory for control data */
+	data = calloc(data_size, 1);
+	if (!data)
+		return -ENOMEM;
+
+	/* set param ID and number of channels */
+	data->id = ctl->index;
+	data->num_elems = num_values;
+
+	/* set the enum values */
+	for (i = 0; i < data->num_elems; i++) {
+		data->chanv[i].channel = i;
+		data->chanv[i].value = control_values[i];
+	}
+
+	/* configure the IPC message */
+	tb_ctl_ipc_message(&config, param_id, data_size, ctl->module_id, ctl->instance_id,
+			   SOF_IPC4_MOD_LARGE_CONFIG_SET);
+	config.extension.r.final_block = 1;
+	config.extension.r.init_block = 1;
+
+	/* allocate memory for IPC message */
+	msg_size = sizeof(config) + data_size;
+	msg = calloc(msg_size, 1);
+	if (!msg) {
+		free(data);
+		return -ENOMEM;
+	}
+
+	/* set the IPC message data */
+	memcpy(msg, &config, sizeof(config));
+	memcpy(msg + sizeof(config), data, data_size);
+	free(data);
+
+	/* send the message and check status */
+	ret = tb_mq_cmd_tx_rx(ipc_tx, ipc_rx, msg, msg_size, &reply, sizeof(reply));
+	free(msg);
+	if (ret < 0) {
+		fprintf(stderr, "error: failed to set control %s\n", ctl->name);
+		return ret;
+	}
+
+	if (reply.primary.r.status != IPC4_SUCCESS) {
+		fprintf(stderr, "error: control %s set failed with status %d\n",
+			ctl->name, reply.primary.r.status);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
 #endif /* CONFIG_IPC_MAJOR_4 */
diff --git a/tools/testbench/utils.c b/tools/testbench/utils.c
index 6af8fbd73b2d..71122b8a83af 100644
--- a/tools/testbench/utils.c
+++ b/tools/testbench/utils.c
@@ -8,6 +8,7 @@
 #include <sof/ipc/topology.h>
 #include <sof/lib/notifier.h>
 
+#include <ctype.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -256,3 +257,179 @@ void tb_getcycles(uint64_t *cycles)
 	*cycles = 0;
 #endif
 }
+
+static void tb_trim_line(char *new, char *line)
+{
+	int i = 0;
+	int j = 0;
+	int n = strlen(line);
+	bool in_quotes = false;
+
+	/* Trim begin */
+	while (isspace((int)line[i]) && i < n)
+		i++;
+
+	/* Copy line with multiple blanks removed, change single quotes to
+	 * double quotes, don't remove blanks from inside quotes.
+	 */
+	while (i < n) {
+		if (!isspace((int)line[i])) {
+			if (line[i] == '\'')
+				new[j] = '\"';
+			else
+				new[j] = line[i];
+			if (new[j] == '\"')
+				in_quotes = !in_quotes;
+			j++;
+			i++;
+		} else if (in_quotes || ((i + 1) < n && !isspace((int)line[i + 1]))) {
+			new[j] = ' ';
+			j++;
+			i++;
+		} else {
+			i++;
+		}
+	}
+	new[j] = 0;
+}
+
+static int tb_parse_sleep(char *line, int64_t *sleep_ns)
+{
+	char *token = strtok(line, "sleep ");
+
+	*sleep_ns = (int64_t)(atof(token) * 1e9);
+	printf("Info: Next control will be applied after %lld ns.\n", (long long)*sleep_ns);
+	return 0;
+}
+
+int tb_decode_enum(struct snd_soc_tplg_enum_control *enum_ctl, char *token)
+{
+	int enum_items = enum_ctl->items;
+	int i;
+
+	for (i = 0; i < enum_items; i++) {
+		if (strcmp(enum_ctl->texts[i], token) == 0)
+			return i;
+	}
+
+	return -EINVAL;
+}
+
+static struct tb_ctl *tb_find_control_by_name(struct testbench_prm *tp, char *name)
+{
+	struct tb_glb_state *glb = &tp->glb_ctx;
+	struct tb_ctl *ctl;
+	int i;
+
+	for (i = 0; i <  glb->num_ctls; i++) {
+		ctl = &glb->ctl[i];
+		if (strcmp(ctl->name, name) == 0)
+			return ctl;
+	}
+
+	return NULL;
+}
+
+static int tb_parse_amixer(struct testbench_prm *tp, char *line)
+{
+	char *line_end;
+	char *name_str;
+	char *end_str;
+	char control_name[TB_MAX_CTL_NAME_CHARS] = {0};
+	char control_params[TB_MAX_CTL_NAME_CHARS] = {0};
+	char *find_cset_name_str = "cset name=\"";
+	char *find_end_str = "\" ";
+	int find_len = strlen(find_cset_name_str);
+	int find_end_len = strlen(find_end_str);
+	int len;
+	struct tb_ctl *ctl;
+	int ret;
+
+	name_str = strstr(line, find_cset_name_str);
+	if (!name_str) {
+		fprintf(stderr, "error: no control name in script line: %s\n", line);
+		return -EINVAL;
+	}
+
+	end_str = strstr(&name_str[find_len], find_end_str);
+	if (!end_str) {
+		fprintf(stderr, "error: no control name end quote in script line: %s\n", line);
+		return -EINVAL;
+	}
+
+	len = end_str - name_str - find_len;
+	memcpy(control_name, name_str + find_len, len);
+
+	line_end = line + strlen(line);
+	len = line_end - end_str - find_end_len;
+	memcpy(control_params, &end_str[find_end_len], len);
+
+	printf("Info: Setting control name '%s' to value (%s)\n", control_name, control_params);
+
+	ctl = tb_find_control_by_name(tp, control_name);
+	if (!ctl) {
+		fprintf(stderr, "error: control %s not found in topology.\n", control_name);
+		return -EINVAL;
+	}
+
+	switch (ctl->type) {
+	case SND_SOC_TPLG_TYPE_MIXER:
+		ret = tb_set_mixer_control(tp, ctl, control_params);
+		break;
+	case SND_SOC_TPLG_TYPE_ENUM:
+		ret = tb_set_enum_control(tp, ctl, control_params);
+		break;
+	default:
+		fprintf(stderr, "error: control %s type %d is not supported.\n",
+			control_name, ctl->type);
+		ret = -EINVAL;
+	}
+
+	return ret;
+}
+
+int tb_read_controls(struct testbench_prm *tp, int64_t *sleep_ns)
+{
+	char *sleep_cmd = "sleep ";
+	char *amixer_cmd = "amixer ";
+	char *raw_line;
+	char *line;
+	int ret = 0;
+
+	*sleep_ns = 0;
+	if (!tp->control_fh)
+		return 0;
+
+	raw_line = malloc(TB_MAX_CMD_CHARS);
+	assert(raw_line);
+
+	line = malloc(TB_MAX_CMD_CHARS);
+	assert(line);
+
+	while (fgets(raw_line, TB_MAX_CMD_CHARS, tp->control_fh)) {
+		tb_trim_line(line, raw_line);
+		if (line[0] == '#' || strlen(line) == 0)
+			continue;
+
+		if (strncmp(line, sleep_cmd, sizeof(*sleep_cmd)) == 0) {
+			ret = tb_parse_sleep(line, sleep_ns);
+			if (ret) {
+				fprintf(stderr, "error: failed parse of sleep command.\n");
+				break;
+			}
+			break;
+		}
+
+		if (strncmp(line, amixer_cmd, sizeof(*amixer_cmd)) == 0) {
+			ret = tb_parse_amixer(tp, line);
+			if (ret) {
+				fprintf(stderr, "error: failed parse of amixer command.\n");
+				break;
+			}
+		}
+	}
+
+	free(line);
+	free(raw_line);
+	return ret;
+}
diff --git a/tools/testbench/utils_ipc3.c b/tools/testbench/utils_ipc3.c
index ca98a5f0baf4..3e9749f4a0dd 100644
--- a/tools/testbench/utils_ipc3.c
+++ b/tools/testbench/utils_ipc3.c
@@ -24,8 +24,6 @@ int tb_setup(struct sof *sof, struct testbench_prm *tp)
 {
 	struct ll_schedule_domain domain = {0};
 
-	domain.next_tick = tp->tick_period_us;
-
 	/* init components */
 	sys_comp_init(sof);
 	sys_comp_selector_init();
@@ -426,4 +424,15 @@ int tb_set_up_all_pipelines(struct testbench_prm *tp)
 	return 0;
 }
 
+/* No support in IPC3 version */
+int tb_set_enum_control(struct testbench_prm *tp, struct tb_ctl *ctl, char *control_params)
+{
+	return 0;
+}
+
+int tb_set_mixer_control(struct testbench_prm *tp, struct tb_ctl *ctl, char *control_params)
+{
+	return 0;
+}
+
 #endif /* CONFIG_IPC_MAJOR_3 */
diff --git a/tools/testbench/utils_ipc4.c b/tools/testbench/utils_ipc4.c
index 83bc3d36af94..1418e2b9d69c 100644
--- a/tools/testbench/utils_ipc4.c
+++ b/tools/testbench/utils_ipc4.c
@@ -38,8 +38,6 @@ int tb_setup(struct sof *sof, struct testbench_prm *tp)
 	int bits;
 	int krate;
 
-	domain.next_tick = tp->tick_period_us;
-
 	/* init components */
 	sys_comp_init(sof);
 
@@ -629,4 +627,67 @@ void tb_free_topology(struct testbench_prm *tp)
 	tb_debug_print("freed all pipelines, widgets, routes and pcms\n");
 }
 
+int tb_set_enum_control(struct testbench_prm *tp, struct tb_ctl *ctl, char *control_params)
+{
+	int control_values[PLATFORM_MAX_CHANNELS];
+	char *token, *rest;
+	int ret = 0;
+	int n = 0;
+
+	rest = control_params;
+	while ((token = strtok_r(rest, ",", &rest))) {
+		if (n == PLATFORM_MAX_CHANNELS) {
+			fprintf(stderr,
+				"error: number of control values exceeds max channels count.\n");
+			return -EINVAL;
+		}
+
+		control_values[n] = tb_decode_enum(&ctl->enum_ctl, token);
+		if (control_values[n] < 0) {
+			fprintf(stderr,
+				"error: not able to decode enum %s.\n", token);
+			return -EINVAL;
+		}
+		n++;
+	}
+
+	ret = tb_send_alsa_control(&tp->ipc_tx, &tp->ipc_rx, ctl, control_values, n,
+				   SOF_IPC4_ENUM_CONTROL_PARAM_ID);
+	return ret;
+}
+
+int tb_set_mixer_control(struct testbench_prm *tp, struct tb_ctl *ctl, char *control_params)
+{
+	int control_values[PLATFORM_MAX_CHANNELS];
+	char *token, *rest;
+	int n = 0;
+	int ret;
+
+	rest = control_params;
+	while ((token = strtok_r(rest, ",", &rest))) {
+		if (n == PLATFORM_MAX_CHANNELS) {
+			fprintf(stderr,
+				"error: number of control values exceeds max channels count.\n");
+			return -EINVAL;
+		}
+
+		if (strcmp(token, "on") == 0)
+			control_values[n] = 1;
+		else if (strcmp(token, "off") == 0)
+			control_values[n] = 0;
+		else
+			control_values[n] = atoi(token);
+
+		n++;
+	}
+
+	if (ctl->mixer_ctl.max == 1)
+		ret = tb_send_alsa_control(&tp->ipc_tx, &tp->ipc_rx, ctl, control_values, n,
+					   SOF_IPC4_SWITCH_CONTROL_PARAM_ID);
+	else
+		ret = tb_send_volume_control(&tp->ipc_tx, &tp->ipc_rx, ctl, control_values, n);
+
+	return ret;
+}
+
 #endif /* CONFIG_IPC_MAJOR_4 */
diff --git a/tools/tplg_parser/control.c b/tools/tplg_parser/control.c
index e8e8048b4939..c2deddf61a4f 100644
--- a/tools/tplg_parser/control.c
+++ b/tools/tplg_parser/control.c
@@ -141,8 +141,13 @@ int tplg_create_controls(struct tplg_context *ctx, int num_kcontrols,
 			return -EINVAL;
 		}
 
-		if (ctx->ctl_cb && object)
-			ctx->ctl_cb(ctl_hdr, object, ctx->ctl_arg, index);
+		if (ctx->ctl_cb && object) {
+			ret = ctx->ctl_cb(ctl_hdr, object, ctx->ctl_arg, index);
+			if (ret) {
+				fprintf(stderr, "error: failed control callback\n");
+				goto err;
+			}
+		}
 	}
 
 	if (rctl && ctl_hdr) {