Add support for byte controls in the SOF plugin

tools/ctl/ctl.c

@@ -508,6 +508,8 @@ static int ctl_set_get(struct ctl_data *ctl_data)
  fprintf(stdout, "Retrieving configuration for ");
  fprintf(stdout, "device %s control %s.\n",
  ctl_data->dev, ctl_data->cname);
+ /* set the ABI header to pass the param ID */
+ header_init(ctl_data);
  ctl_data->buffer[BUFFER_SIZE_OFFSET] = ctl_data->ctrl_size;
  ret = snd_ctl_elem_tlv_read(ctl_data->ctl, ctl_data->id,
  ctl_data->buffer,

tools/plugin/README.md

@@ -79,7 +79,21 @@ or
 ```
 amixer -Dsof:plugin cset numid=1 20
 ```
-Right now, only volume controls are supported. Support for bytes and enum controls is pending.
+Bytes control data can be set using sof-ctl as follows:
+
+```
+./sof-ctl -Dsof:plugin -n 4 -r -i 4 -p 2 -s ~/data.txt
+```
+where -n is the numid of the kcontrol, -i is the IPC version, -p is the param ID and -s specifies
+the data in csv format.
+
+Bytes control data can be read using sof-ctl as follows:
+```
+./sof-ctl -Dsof:plugin -n 4 -i 4 -p 2
+```
+where -n is the numid of the kcontrol, -i is the IPC version and -p is the param ID.
+
+Note: Bytes controls must have tlv_read/tlv_write and tlv_callback access.
 
 # Instructions for testing OpenVino noise suppression model with the SOF plugin:
 1. Fetch the model from the Open Model zoo repository ex: noise-suppression-poconetlike-0001.xml

tools/plugin/alsaplug/ctl.c

@@ -145,10 +145,9 @@ static int plug_ctl_get_attribute(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
  // TODO: ??
  break;
 	case SND_SOC_TPLG_CTL_BYTES:
- printf("%s %d\n", __func__, __LINE__);
  bytes_ctl = (struct snd_soc_tplg_bytes_control *)hdr;
  *type = SND_CTL_ELEM_TYPE_BYTES;
- *count = bytes_ctl->size; // Not sure if size is correct
+ *count = bytes_ctl->max;
  break;
 	}
 
@@ -198,20 +197,6 @@ static int plug_ctl_get_integer_info(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
 	return err;
 }
 
-static void plug_ctl_ipc_message(struct ipc4_module_large_config *config, int param_id,
- size_t size, uint32_t module_id, uint32_t instance_id,
- uint32_t type)
-{
-	config->primary.r.type = type;
-	config->primary.r.msg_tgt = SOF_IPC4_MESSAGE_TARGET_MODULE_MSG;
-	config->primary.r.rsp = SOF_IPC4_MESSAGE_DIR_MSG_REQUEST;
-	config->primary.r.module_id = module_id;
-	config->primary.r.instance_id = instance_id;
-
-	config->extension.r.data_off_size = size;
-	config->extension.r.large_param_id = param_id;
-}
-
 static int plug_ctl_read_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, long *value)
 {
 	snd_sof_ctl_t *ctl = ext->private_data;
@@ -550,36 +535,147 @@ static int plug_ctl_write_enumerated(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
 /*
  * Bytes ops
  */
+static int plug_ctl_get_bytes_data(snd_sof_ctl_t *ctl, snd_ctl_ext_key_t key,
+ struct sof_abi_hdr *abi, unsigned int max_bytes)
+{
+	struct snd_soc_tplg_bytes_control *bytes_ctl = CTL_GET_TPLG_BYTES(ctl, key);
+	struct ipc4_module_large_config config = {{ 0 }};
+	struct ipc4_module_large_config_reply *reply;
+	char *reply_data, *data;
+	void *msg;
+	uint32_t data_size;
+	int size, reply_data_size;
+	int err;
+
+	/* configure the IPC message */
+	plug_ctl_ipc_message(&config, abi->type, 0,
+ ctl->glb->ctl[key].module_id, ctl->glb->ctl[key].instance_id,
+ SOF_IPC4_MOD_LARGE_CONFIG_GET);
+
+	config.extension.r.final_block = 1;
+	config.extension.r.init_block = 1;
+
+	size = sizeof(config);
+	msg = calloc(size, 1);
+	if (!msg)
+ return -ENOMEM;
+
+	/*
+ * reply contains both the requested data and the reply status. Allocate enough memory
+ * for max data
+ */
+	reply_data_size = sizeof(*reply) + sizeof(*data) + bytes_ctl->max;
+	reply_data = calloc(reply_data_size, 1);
+	if (!reply_data_size) {
+ free(msg);
+ return -ENOMEM;
+	}
+
+	/* send the IPC message */
+	memcpy(msg, &config, sizeof(config));
+	err = plug_mq_cmd_tx_rx(&ctl->ipc_tx, &ctl->ipc_rx,
+ msg, size, reply_data, reply_data_size);
+	free(msg);
+	if (err < 0) {
+ SNDERR("failed to get bytes data for control %s\n", bytes_ctl->hdr.name);
+ goto out;
+	}
+
+	reply = (struct ipc4_module_large_config_reply *)reply_data;
+	if (reply->primary.r.status != IPC4_SUCCESS) {
+ SNDERR("bytes control %s get failed with status %d\n",
+ bytes_ctl->hdr.name, reply->primary.r.status);
+ err = -EINVAL;
+ goto out;
+	}
+
+	/* check data sanity */
+	data = (char *)(reply_data + sizeof(*reply));
+	data_size = reply->extension.r.data_off_size;
+	if (data_size > bytes_ctl->max) {
+ SNDERR("received data size %d is larger than max %d for bytes control %s\n",
+ data_size, bytes_ctl->max, bytes_ctl->hdr.name);
+ err = -EINVAL;
+ goto out;
+	}
+
+	abi->size = data_size;
+
+	if (data_size)
+ memcpy(abi->data, data, MIN(data_size, max_bytes));
+
+	err = data_size;
+out:
+	free(reply_data);
+	return err;
+}
+
 static int plug_ctl_read_bytes(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
  unsigned char *data, size_t max_bytes)
 {
+	snd_sof_ctl_t *ctl = ext->private_data;
+	struct sof_abi_hdr *abi = (struct sof_abi_hdr *)data;
+	int data_size;
+
+	data_size = plug_ctl_get_bytes_data(ctl, key, abi, max_bytes);
+	if (data_size < 0)
+ return data_size;
+
 	return 0;
 }
 
 static int plug_ctl_write_bytes(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
  unsigned char *data, size_t max_bytes)
 {
+	snd_sof_ctl_t *ctl = ext->private_data;
+	struct snd_soc_tplg_bytes_control *bytes_ctl = CTL_GET_TPLG_BYTES(ctl, key);
+	struct sof_abi_hdr *abi = (struct sof_abi_hdr *)data;
+	int err;
+
+	/* send IPC with kcontrol data */
+	err = plug_send_bytes_data(&ctl->ipc_tx, &ctl->ipc_rx,
+ ctl->glb->ctl[key].module_id, ctl->glb->ctl[key].instance_id,
+ abi);
+	if (err < 0) {
+ SNDERR("failed to set bytes data for control %s\n", bytes_ctl->hdr.name);
+ return err;
+	}
+
 	return 0;
 }
 
-/*
- * TLV ops
- *
- * The format of an array of \a tlv argument is:
- * tlv[0]: Type. One of SND_CTL_TLVT_XXX.
- * tlv[1]: Length. The length of value in units of byte.
- * tlv[2..]: Value. Depending on the type.
- */
+/* TLV ops used for TLV bytes control callback */
 static int plug_tlv_rw(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, int op_flag,
  unsigned int numid, unsigned int *tlv, unsigned int tlv_size)
 {
 	snd_sof_ctl_t *ctl = ext->private_data;
-	struct snd_soc_tplg_ctl_hdr *hdr = CTL_GET_TPLG_HDR(ctl, key);
+	struct snd_soc_tplg_bytes_control *bytes_ctl = CTL_GET_TPLG_BYTES(ctl, key);
+	struct sof_abi_hdr *abi = (struct sof_abi_hdr *)(tlv + 2); /* skip TLV header */
+	int data_size;
+
+	/* send IPC with kcontrol data if op_flag is > 0 else send IPC to get kcontrol data */
+	if (op_flag) {
+ int err;
+
+ err = plug_send_bytes_data(&ctl->ipc_tx, &ctl->ipc_rx,
+ ctl->glb->ctl[key].module_id,
+ ctl->glb->ctl[key].instance_id, abi);
+ if (err < 0) {
+ SNDERR("failed to set bytes data for control %s\n", bytes_ctl->hdr.name);
+ return err;
+ }
+
+ return 0;
+	}
+
+	/* read kcontrol data */
+	data_size = plug_ctl_get_bytes_data(ctl, key, abi, tlv_size);
+	if (data_size < 0)
+ return data_size;
 
-	//TODO: alsamixer showing wrong dB scales
-	tlv[0] = hdr->tlv.type;
-	tlv[1] = hdr->tlv.size - sizeof(uint32_t) * 2;
-	memcpy(&tlv[2], hdr->tlv.data, hdr->tlv.size - sizeof(uint32_t) * 2);
+	/* set data size and numid */
+	tlv[0] = numid;
+	tlv[1] = data_size + sizeof(*abi);
 
 	return 0;
 }

tools/plugin/alsaplug/plugin.c

@@ -41,79 +41,6 @@
 #include "plugin.h"
 #include "common.h"
 
-int plug_mq_cmd_tx_rx(struct plug_mq_desc *ipc_tx, struct plug_mq_desc *ipc_rx,
- void *msg, size_t len, void *reply, size_t rlen)
-{
-	struct timespec ts;
-	ssize_t ipc_size;
-	char mailbox[IPC3_MAX_MSG_SIZE];
-	int err;
-
-	if (len > IPC3_MAX_MSG_SIZE) {
- SNDERR("ipc: message too big %d\n", len);
- return -EINVAL;
-	}
-	memset(mailbox, 0, IPC3_MAX_MSG_SIZE);
-	memcpy(mailbox, msg, len);
-
-	/* wait for sof-pipe reader to consume data or timeout */
-	err = clock_gettime(CLOCK_REALTIME, &ts);
-	if (err == -1) {
- SNDERR("ipc: cant get time: %s", strerror(errno));
- return -errno;
-	}
-
-	/* IPCs should be read under 10ms */
-	plug_timespec_add_ms(&ts, 10);
-
-	/* now return message completion status */
-	err = mq_timedsend(ipc_tx->mq, mailbox, IPC3_MAX_MSG_SIZE, 0, &ts);
-	if (err == -1) {
- SNDERR("error: timeout can't send IPC message queue %s : %s\n",
- ipc_tx->queue_name, strerror(errno));
- return -errno;
-	}
-
-	/* wait for sof-pipe reader to consume data or timeout */
-	err = clock_gettime(CLOCK_REALTIME, &ts);
-	if (err == -1) {
- SNDERR("ipc: cant get time: %s", strerror(errno));
- return -errno;
-	}
-
-	/* IPCs should be processed under 20ms, but wait longer as
- * some can take longer especially in valgrind
- */
-	plug_timespec_add_ms(&ts, 20);
-
-	ipc_size = mq_timedreceive(ipc_rx->mq, mailbox, IPC3_MAX_MSG_SIZE, NULL, &ts);
-	if (ipc_size == -1) {
- //fprintf(stderr, "dbg: timeout can't read IPC message queue %s : %s retrying\n",
- //	ipc->queue_name, strerror(errno));
-
- /* ok, its a long IPC or valgrind, wait longer */
- plug_timespec_add_ms(&ts, 800);
-
- ipc_size = mq_timedreceive(ipc_rx->mq, mailbox, IPC3_MAX_MSG_SIZE, NULL, &ts);
- if (ipc_size == -1) {
- SNDERR("error: timeout can't read IPC message queue %s : %s\n",
- ipc_rx->queue_name, strerror(errno));
- return -errno;
- }
-
- /* needed for valgrind to complete MQ op before next client IPC */
- ts.tv_nsec = 20 * 1000 * 1000;
- ts.tv_sec = 0;
- nanosleep(&ts, NULL);
-	}
-
-	/* do the message work */
-	if (rlen && reply)
- memcpy(reply, mailbox, rlen);
-
-	return 0;
-}
-
 int plug_mq_cmd(struct plug_mq_desc *ipc, void *msg, size_t len, void *reply, size_t rlen)
 {
 	return plug_mq_cmd_tx_rx(ipc, ipc, msg, len, reply, rlen);

tools/plugin/alsaplug/tplg.c

@@ -23,6 +23,7 @@
 #include <assert.h>
 #include <errno.h>
 #include <dlfcn.h>
+#include <kernel/header.h>
 
 #include <ipc4/error_status.h>
 
@@ -312,7 +313,22 @@ static int plug_new_process(snd_sof_plug_t *plug)
 
 	plug_setup_widget_ipc_msg(comp_info);
 
-	return 0;
+	tplg_ctl = calloc(ctx->hdr->payload_size, 1);
+	if (!tplg_ctl) {
+ free(comp_info->ipc_payload);
+ return -ENOMEM;
+	}
+
+	/* set up kcontrols */
+	ret = tplg_create_controls(ctx, ctx->widget->num_kcontrols,
+ tplg_ctl, ctx->hdr->payload_size, comp_info);
+	if (ret < 0) {
+ SNDERR("failed to create controls for process comp\n");
+ free(comp_info->ipc_payload);
+	}
+
+	free(tplg_ctl);
+	return ret;
 }
 
 static int plug_new_pipeline(snd_sof_plug_t *plug)
@@ -1090,7 +1106,9 @@ static int plug_set_up_route(snd_sof_plug_t *plug, struct tplg_route_info *route
 static int plug_set_up_widget(snd_sof_plug_t *plug, struct tplg_comp_info *comp_info)
 {
 	struct tplg_pipeline_info *pipe_info = comp_info->pipe_info;
-	int ret;
+	struct plug_shm_glb_state *glb = plug->glb_ctx.addr;
+	struct plug_shm_ctl *ctl;
+	int ret, i;
 
 	pipe_info->usage_count++;
 
@@ -1108,6 +1126,33 @@ static int plug_set_up_widget(snd_sof_plug_t *plug, struct tplg_comp_info *comp_
 	if (ret < 0)
  return ret;
 
+	/* send kcontrol bytes data */
+	for (i = 0; i < glb->num_ctls; i++) {
+ struct snd_soc_tplg_bytes_control *tplg_bytes;
+ struct sof_abi_hdr *abi;
+ int priv_size;
+
+ ctl = &glb->ctl[i];
+
+ /* send the bytes data from kcontrols associated with current widget */
+ if (ctl->module_id != comp_info->module_id ||
+ ctl->instance_id != comp_info->instance_id ||
+ ctl->type != SND_SOC_TPLG_TYPE_BYTES)
+ continue;
+
+ tplg_bytes = &ctl->bytes_ctl;
+ priv_size = tplg_bytes->priv.size;
+ abi = (struct sof_abi_hdr *)ctl->data;
+
+ /* send IPC with kcontrol data */
+ ret = plug_send_bytes_data(&plug->ipc_tx, &plug->ipc_rx,
+ comp_info->module_id, comp_info->instance_id, abi);
+ if (ret < 0) {
+ SNDERR("failed to set bytes data for widget %s\n", comp_info->name);
+ return ret;
+ }
+	}
+
 	tplg_debug("widget %s set up\n", comp_info->name);
 
 	return 0;