Re: [PATCH v3 07/17] ASoC: Intel: avs: Add module management requests

[Ranjani Sridharan <ranjani.sridharan@linux.intel.com>]

On Fri, 2022-03-04 at 15:57 +0100, Cezary Rojewski wrote:
> Firmware modules implement processing algorithms. Their lifecycle,
> similarly to pipelines is being controlled by IPCs: initialization,
> deletion and (un)binding.
> 
> Modules can be configured at runtime - runtime parameters. This is
> done
> with help of LARGE_CONFIG IPCs: getter and setter.
> 
> Signed-off-by: Amadeusz Sławiński <
> amadeuszx.slawinski@linux.intel.com>
> Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
> ---
>  sound/soc/intel/avs/ipc.c      |   8 +-
>  sound/soc/intel/avs/messages.c | 262
> +++++++++++++++++++++++++++++++++
>  sound/soc/intel/avs/messages.h |  53 +++++++
>  3 files changed, 322 insertions(+), 1 deletion(-)
> 
> diff --git a/sound/soc/intel/avs/ipc.c b/sound/soc/intel/avs/ipc.c
> index c0722f8b195f..9770368a898e 100644
> --- a/sound/soc/intel/avs/ipc.c
> +++ b/sound/soc/intel/avs/ipc.c
> @@ -21,9 +21,15 @@ static void avs_dsp_receive_rx(struct avs_dev
> *adev, u64 header)
>  
>  	ipc->rx.header = header;
>  	/* Abort copying payload if request processing was
> unsuccessful. */
> -	if (!msg.status)
> +	if (!msg.status) {
> +		/* update size in case of LARGE_CONFIG_GET */
> +		if (msg.msg_target == AVS_MOD_MSG &&
> +		    msg.global_msg_type == AVS_MOD_LARGE_CONFIG_GET)
> +			ipc->rx.size =
> msg.ext.large_config.data_off_size;
> +
>  		memcpy_fromio(ipc->rx.data, avs_uplink_addr(adev),
>  			      ipc->rx.size);
> +	}
>  }
>  
>  static void avs_dsp_process_notification(struct avs_dev *adev, u64
> header)
> diff --git a/sound/soc/intel/avs/messages.c
> b/sound/soc/intel/avs/messages.c
> index de2d50f8c6b4..613c9452226d 100644
> --- a/sound/soc/intel/avs/messages.c
> +++ b/sound/soc/intel/avs/messages.c
> @@ -6,6 +6,7 @@
>  //          Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
>  //
>  
> +#include <linux/slab.h>
>  #include "avs.h"
>  #include "messages.h"
>  
> @@ -139,3 +140,264 @@ int avs_ipc_get_pipeline_state(struct avs_dev
> *adev, u8 instance_id,
>  	*state = reply.rsp.ext.get_ppl_state.state;
>  	return ret;
>  }
> +
> +/*
> + * avs_ipc_init_instance - Initialize module instance
> + *
> + * @adev: Driver context
> + * @module_id: Module-type id
> + * @instance_id: Unique module instance id
> + * @ppl_id: Parent pipeline id
> + * @core_id: DSP core to allocate module on
> + * @domain: Processing domain (low latency or data processing)
> + * @param: Module-type specific configuration
> + * @param_size: Size of @param in bytes
> + *
> + * Argument verification, as well as pipeline state checks are done
> by the
> + * firmware.
> + *
> + * Note: @ppl_id and @core_id are independent of each other as
> single pipeline
> + * can be composed of module instances located on different DSP
> cores.
> + */
> +int avs_ipc_init_instance(struct avs_dev *adev, u16 module_id, u8
> instance_id,
> +			  u8 ppl_id, u8 core_id, u8 domain,
> +			  void *param, u32 param_size)
> +{
> +	union avs_module_msg msg = AVS_MODULE_REQUEST(INIT_INSTANCE);
> +	struct avs_ipc_msg request;
> +	int ret;
> +
> +	msg.module_id = module_id;
> +	msg.instance_id = instance_id;
> +	/* firmware expects size provided in dwords */
> +	msg.ext.init_instance.param_block_size =
> +			DIV_ROUND_UP(param_size, sizeof(u32));
> +	msg.ext.init_instance.ppl_instance_id = ppl_id;
> +	msg.ext.init_instance.core_id = core_id;
> +	msg.ext.init_instance.proc_domain = domain;
> +
> +	request.header = msg.val;
> +	request.data = param;
> +	request.size = param_size;
> +
> +	ret = avs_dsp_send_msg(adev, &request, NULL);
> +	if (ret)
> +		avs_ipc_err(adev, &request, "init instance", ret);
> +
> +	return ret;
> +}
> +
> +/*
> + * avs_ipc_delete_instance - Delete module instance
> + *
> + * @adev: Driver context
> + * @module_id: Module-type id
> + * @instance_id: Unique module instance id
> + *
> + * Argument verification, as well as pipeline state checks are done
> by the
> + * firmware.
> + *
> + * Note: only standalone modules i.e. without a parent pipeline
> shall be
> + * deleted using this IPC message. In all other cases, pipeline
> owning the
> + * modules peforms cleanup automatically when it is deleted.
Can you please provide an example of such stand-alone modules? If they
aren't part of any pipeline, how do they get scheduled?

> + */
> +int avs_ipc_delete_instance(struct avs_dev *adev, u16 module_id, u8
> instance_id)
> +{
> +	union avs_module_msg msg = AVS_MODULE_REQUEST(DELETE_INSTANCE);
> +	struct avs_ipc_msg request = {{0}};
> +	int ret;
> +
> +	msg.module_id = module_id;
> +	msg.instance_id = instance_id;
> +	request.header = msg.val;
> +
> +	ret = avs_dsp_send_msg(adev, &request, NULL);
> +	if (ret)
> +		avs_ipc_err(adev, &request, "delete instance", ret);
> +
> +	return ret;
> +}
> +
> +/*
> + * avs_ipc_bind - Bind two module instances
> + *
> + * @adev: Driver context
> + * @module_id: Source module-type id
> + * @instance_id: Source module instance id
> + * @dst_module_id: Sink module-type id
> + * @dst_instance_id: Sink module instance id
> + * @dst_queue: Sink module pin to bind @src_queue with
> + * @src_queue: Source module pin to bind @dst_queue with
> + */
> +int avs_ipc_bind(struct avs_dev *adev, u16 module_id, u8
> instance_id,
> +		 u16 dst_module_id, u8 dst_instance_id,
> +		 u8 dst_queue, u8 src_queue)
> +{
> +	union avs_module_msg msg = AVS_MODULE_REQUEST(BIND);
> +	struct avs_ipc_msg request = {{0}};
> +	int ret;
> +
> +	msg.module_id = module_id;
> +	msg.instance_id = instance_id;
> +	msg.ext.bind_unbind.dst_module_id = dst_module_id;
> +	msg.ext.bind_unbind.dst_instance_id = dst_instance_id;
> +	msg.ext.bind_unbind.dst_queue = dst_queue;
> +	msg.ext.bind_unbind.src_queue = src_queue;
> +	request.header = msg.val;
> +
> +	ret = avs_dsp_send_msg(adev, &request, NULL);
> +	if (ret)
> +		avs_ipc_err(adev, &request, "bind modules", ret);
> +
> +	return ret;
> +}
> +
> +/*
> + * avs_ipc_unbind - Unbind two module instances
> + *
> + * @adev: Driver context
> + * @module_id: Source module-type id
> + * @instance_id: Source module instance id
> + * @dst_module_id: Sink module-type id
> + * @dst_instance_id: Sink module instance id
> + * @dst_queue: Sink module pin to unbind @src_queue from
> + * @src_queue: Source module pin to unbind @dst_queue from
> + */
Are there any rules for unbinding? For example if you have 2 modules
connected to a mixer? Can you unbind the module belonging to the host
pipeline that is getting stopped while the mixer is still active?

> +int avs_ipc_unbind(struct avs_dev *adev, u16 module_id, u8
> instance_id,
> +		   u16 dst_module_id, u8 dst_instance_id,
> +		   u8 dst_queue, u8 src_queue)
> +{
> +	union avs_module_msg msg = AVS_MODULE_REQUEST(UNBIND);
> +	struct avs_ipc_msg request = {{0}};
> +	int ret;
> +
> +	msg.module_id = module_id;
> +	msg.instance_id = instance_id;
> +	msg.ext.bind_unbind.dst_module_id = dst_module_id;
> +	msg.ext.bind_unbind.dst_instance_id = dst_instance_id;
> +	msg.ext.bind_unbind.dst_queue = dst_queue;
> +	msg.ext.bind_unbind.src_queue = src_queue;
> +	request.header = msg.val;
> +
> +	ret = avs_dsp_send_msg(adev, &request, NULL);
> +	if (ret)
> +		avs_ipc_err(adev, &request, "unbind modules", ret);
> +
> +	return ret;
> +}
> +
> +static int __avs_ipc_set_large_config(struct avs_dev *adev, u16
> module_id, u8 instance_id,
> +				      u8 param_id, bool init_block,
> bool final_block,
> +				      u8 *request_data, size_t
> request_size, size_t off_size)
> +{
> +	union avs_module_msg msg =
> AVS_MODULE_REQUEST(LARGE_CONFIG_SET);
> +	struct avs_ipc_msg request;
> +	int ret;
> +
> +	msg.module_id = module_id;
> +	msg.instance_id = instance_id;
> +	msg.ext.large_config.data_off_size = off_size;
> +	msg.ext.large_config.large_param_id = param_id;
> +	msg.ext.large_config.final_block = final_block;
> +	msg.ext.large_config.init_block = init_block;
> +
> +	request.header = msg.val;
> +	request.data = request_data;
> +	request.size = request_size;
> +
> +	ret = avs_dsp_send_msg(adev, &request, NULL);
> +	if (ret)
> +		avs_ipc_err(adev, &request, "large config set", ret);
> +
> +	return ret;
> +}
> +
> +int avs_ipc_set_large_config(struct avs_dev *adev, u16 module_id,
> +			     u8 instance_id, u8 param_id,
> +			     u8 *request, size_t request_size)
> +{
> +	size_t remaining, tx_size;
> +	bool final;
> +	int ret;
> +
> +	remaining = request_size;
> +	tx_size = min_t(size_t, AVS_MAILBOX_SIZE, remaining);
> +	final = (tx_size == remaining);
> +
> +	/* Initial request states total payload size. */
> +	ret = __avs_ipc_set_large_config(adev, module_id, instance_id,
> +					 param_id, 1, final, request,
> tx_size,
> +					 request_size);
> +	if (ret)
> +		return ret;
> +
> +	remaining -= tx_size;
> +
> +	/* Loop the rest only when payload exceeds mailbox's size. */
> +	while (remaining) {
> +		size_t offset;
> +
> +		offset = request_size - remaining;
> +		tx_size = min_t(size_t, AVS_MAILBOX_SIZE, remaining);
> +		final = (tx_size == remaining);
> +
> +		ret = __avs_ipc_set_large_config(adev, module_id,
> instance_id,
> +						 param_id, 0, final,
> +						 request + offset,
> tx_size,
> +						 offset);
> +		if (ret)
> +			return ret;
> +
> +		remaining -= tx_size;
> +	}
> +
> +	return 0;
> +}
> +
> +int avs_ipc_get_large_config(struct avs_dev *adev, u16 module_id, u8
> instance_id,
> +			     u8 param_id, u8 *request_data, size_t
> request_size,
> +			     u8 **reply_data, size_t *reply_size)
> +{
> +	union avs_module_msg msg =
> AVS_MODULE_REQUEST(LARGE_CONFIG_GET);
> +	struct avs_ipc_msg request;
> +	struct avs_ipc_msg reply = {{0}};
> +	size_t size;
> +	void *buf;
> +	int ret;
> +
> +	reply.data = kzalloc(AVS_MAILBOX_SIZE, GFP_KERNEL);
> +	if (!reply.data)
> +		return -ENOMEM;
> +
> +	msg.module_id = module_id;
> +	msg.instance_id = instance_id;
> +	msg.ext.large_config.data_off_size = request_size;
> +	msg.ext.large_config.large_param_id = param_id;
> +	/* final_block is always 0 on request. Updated by fw on reply.
> */
> +	msg.ext.large_config.final_block = 0;
> +	msg.ext.large_config.init_block = 1;
> +
> +	request.header = msg.val;
> +	request.data = request_data;
> +	request.size = request_size;
> +	reply.size = AVS_MAILBOX_SIZE;
> +
> +	ret = avs_dsp_send_msg(adev, &request, &reply);
> +	if (ret) {
> +		avs_ipc_err(adev, &request, "large config get", ret);
> +		kfree(reply.data);
> +		return ret;
> +	}
How come you dont have a loop here? What if the rec'd data size if
larger than the max size of IP payload?
Thanks,Ranjani