ASoC: dsp: Update ASM driver to support Instance ID

Add support to set and get ASM module params with
Instance ID support. Maintain support for non
Instance ID set and get param structures as well.
Use common pack and set param functions to set and
get parameters to DSP instead of handling them at an
individual module level.

CRs-Fixed: 2151551
Change-Id: I633ce10a83d9033d42fadb7bad0b26842459df84
Signed-off-by: Vignesh Kulothungan <[email protected]>

dsp/q6asm.c

@@ -39,6 +39,7 @@
 #include <dsp/audio_cal_utils.h>
 #include <dsp/q6asm-v2.h>
 #include <dsp/q6audio-v2.h>
+#include <dsp/q6common.h>
 #include "adsp_err.h"
 
 #define TRUE        0x01
@@ -1898,6 +1899,7 @@ static int32_t q6asm_callback(struct apr_client_data *data, void *priv)
 	if (data->opcode == APR_BASIC_RSP_RESULT) {
 		switch (payload[0]) {
 		case ASM_STREAM_CMD_SET_PP_PARAMS_V2:
+		case ASM_STREAM_CMD_SET_PP_PARAMS_V3:
 			if (rtac_make_asm_callback(ac->session, payload,
 					data->payload_size))
 				break;
@@ -1945,9 +1947,12 @@ static int32_t q6asm_callback(struct apr_client_data *data, void *priv)
 				pr_err("%s: cmd = 0x%x returned error = 0x%x\n",
 					__func__, payload[0], payload[1]);
 				if (wakeup_flag) {
-					if ((is_adsp_reg_event(payload[0]) >= 0)
-					      || (payload[0] ==
-					      ASM_STREAM_CMD_SET_PP_PARAMS_V2))
+					if ((is_adsp_reg_event(payload[0]) >=
+					     0) ||
+					    (payload[0] ==
+					     ASM_STREAM_CMD_SET_PP_PARAMS_V2) ||
+					    (payload[0] ==
+					     ASM_STREAM_CMD_SET_PP_PARAMS_V3))
 						atomic_set(&ac->cmd_state_pp,
 								payload[1]);
 					else
@@ -1960,7 +1965,8 @@ static int32_t q6asm_callback(struct apr_client_data *data, void *priv)
 				return 0;
 			}
 			if ((is_adsp_reg_event(payload[0]) >= 0) ||
-			    (payload[0] == ASM_STREAM_CMD_SET_PP_PARAMS_V2)) {
+			    (payload[0] == ASM_STREAM_CMD_SET_PP_PARAMS_V2) ||
+			    (payload[0] == ASM_STREAM_CMD_SET_PP_PARAMS_V3)) {
 				if (atomic_read(&ac->cmd_state_pp) &&
 					wakeup_flag) {
 					atomic_set(&ac->cmd_state_pp, 0);
@@ -2619,6 +2625,174 @@ static void q6asm_add_mmaphdr(struct audio_client *ac, struct apr_hdr *hdr,
 	hdr->pkt_size  = pkt_size;
 }
 
+/**
+ * q6asm_set_pp_params
+ *	command to set ASM parameter data
+ *	send memory mapping header for out of band case
+ *	send pre-packed parameter data for in band case
+ *
+ * @ac: audio client handle
+ * @mem_hdr: memory mapping header
+ * @param_data: pre-packed parameter payload
+ * @param_size: size of pre-packed parameter data
+ *
+ * Returns 0 on success or error on failure
+ */
+int q6asm_set_pp_params(struct audio_client *ac,
+			struct mem_mapping_hdr *mem_hdr, u8 *param_data,
+			u32 param_size)
+{
+	struct asm_stream_cmd_set_pp_params *asm_set_param = NULL;
+	int pkt_size = 0;
+	int ret = 0;
+
+	if (ac == NULL) {
+		pr_err("%s: Audio Client is NULL\n", __func__);
+		return -EINVAL;
+	} else if (ac->apr == NULL) {
+		pr_err("%s: APR pointer is NULL\n", __func__);
+		return -EINVAL;
+	}
+
+	pkt_size = sizeof(struct asm_stream_cmd_set_pp_params);
+	/* Add param size to packet size when sending in-band only */
+	if (param_data != NULL)
+		pkt_size += param_size;
+	asm_set_param = kzalloc(pkt_size, GFP_KERNEL);
+	if (!asm_set_param)
+		return -ENOMEM;
+
+	q6asm_add_hdr_async(ac, &asm_set_param->apr_hdr, pkt_size, TRUE);
+
+	/* With pre-packed data, only the opcode differs from V2 and V3. */
+	if (q6common_is_instance_id_supported())
+		asm_set_param->apr_hdr.opcode = ASM_STREAM_CMD_SET_PP_PARAMS_V3;
+	else
+		asm_set_param->apr_hdr.opcode = ASM_STREAM_CMD_SET_PP_PARAMS_V2;
+
+	asm_set_param->payload_size = param_size;
+
+	if (mem_hdr != NULL) {
+		/* Out of band case */
+		asm_set_param->mem_hdr = *mem_hdr;
+	} else if (param_data != NULL) {
+		/*
+		 * In band case. Parameter data must be pre-packed with its
+		 * header before calling this function. Use
+		 * q6common_pack_pp_params to pack parameter data and header
+		 * correctly.
+		 */
+		memcpy(&asm_set_param->param_data, param_data, param_size);
+	} else {
+		pr_err("%s: Received NULL pointers for both mem header and param data\n",
+		       __func__);
+		ret = -EINVAL;
+		goto done;
+	}
+
+	atomic_set(&ac->cmd_state_pp, -1);
+	ret = apr_send_pkt(ac->apr, (uint32_t *)asm_set_param);
+	if (ret < 0) {
+		pr_err("%s: apr send failed rc %d\n", __func__, ret);
+		ret = -EINVAL;
+		goto done;
+	}
+
+	ret = wait_event_timeout(ac->cmd_wait,
+				 atomic_read(&ac->cmd_state_pp) >= 0, 5 * HZ);
+	if (!ret) {
+		pr_err("%s: timeout sending apr pkt\n", __func__);
+		ret = -ETIMEDOUT;
+		goto done;
+	}
+
+	if (atomic_read(&ac->cmd_state_pp) > 0) {
+		pr_err("%s: DSP returned error[%s]\n", __func__,
+		       adsp_err_get_err_str(atomic_read(&ac->cmd_state_pp)));
+		ret = adsp_err_get_lnx_err_code(atomic_read(&ac->cmd_state_pp));
+		goto done;
+	}
+	ret = 0;
+done:
+	kfree(asm_set_param);
+	return ret;
+}
+EXPORT_SYMBOL(q6asm_set_pp_params);
+
+/**
+ * q6asm_pack_and_set_pp_param_in_band
+ *	command to pack and set parameter data for in band case
+ *
+ * @ac: audio client handle
+ * @param_hdr: parameter header
+ * @param_data: parameter data
+ *
+ * Returns 0 on success or error on failure
+ */
+int q6asm_pack_and_set_pp_param_in_band(struct audio_client *ac,
+					struct param_hdr_v3 param_hdr,
+					u8 *param_data)
+{
+	u8 *packed_data = NULL;
+	u32 packed_size = sizeof(union param_hdrs) + param_hdr.param_size;
+	int ret = 0;
+
+        if (ac == NULL) {
+                pr_err("%s: Audio Client is NULL\n", __func__);
+                return -EINVAL;
+        }
+
+	packed_data = kzalloc(packed_size, GFP_KERNEL);
+	if (packed_data == NULL)
+		return -ENOMEM;
+
+	ret = q6common_pack_pp_params(packed_data, &param_hdr, param_data,
+				      &packed_size);
+	if (ret) {
+		pr_err("%s: Failed to pack params, error %d\n", __func__, ret);
+		goto done;
+	}
+
+	ret = q6asm_set_pp_params(ac, NULL, packed_data, packed_size);
+done:
+	kfree(packed_data);
+	return ret;
+}
+EXPORT_SYMBOL(q6asm_pack_and_set_pp_param_in_band);
+
+/**
+ * q6asm_set_soft_volume_module_instance_ids
+ *	command to set module and instance ids for soft volume
+ *
+ * @instance: soft volume instance
+ * @param_hdr: parameter header
+ *
+ * Returns 0 on success or error on failure
+ */
+int q6asm_set_soft_volume_module_instance_ids(int instance,
+					      struct param_hdr_v3 *param_hdr)
+{
+	if (param_hdr == NULL) {
+		pr_err("%s: Param header is NULL\n", __func__);
+		return -EINVAL;
+	}
+
+	switch (instance) {
+	case SOFT_VOLUME_INSTANCE_2:
+		param_hdr->module_id = ASM_MODULE_ID_VOL_CTRL2;
+		param_hdr->instance_id = INSTANCE_ID_0;
+		return 0;
+	case SOFT_VOLUME_INSTANCE_1:
+		param_hdr->module_id = ASM_MODULE_ID_VOL_CTRL;
+		param_hdr->instance_id = INSTANCE_ID_0;
+		return 0;
+	default:
+		pr_err("%s: Invalid instance %d\n", __func__, instance);
+		return -EINVAL;
+	}
+}
+EXPORT_SYMBOL(q6asm_set_soft_volume_module_instance_ids);
+
 static int __q6asm_open_read(struct audio_client *ac,
 			     uint32_t format, uint16_t bits_per_sample,
 			     uint32_t pcm_format_block_ver,
@@ -7336,67 +7510,28 @@ EXPORT_SYMBOL(q6asm_memory_unmap_regions);
 int q6asm_set_lrgain(struct audio_client *ac, int left_gain, int right_gain)
 {
 	struct asm_volume_ctrl_multichannel_gain multi_ch_gain;
-	int sz = 0;
+	struct param_hdr_v3 param_info;
 	int rc  = 0;
 
-	if (ac == NULL) {
-		pr_err("%s: APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
-	if (ac->apr == NULL) {
-		pr_err("%s: AC APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
-
+	memset(&param_info, 0, sizeof(param_info));
 	memset(&multi_ch_gain, 0, sizeof(multi_ch_gain));
-	sz = sizeof(struct asm_volume_ctrl_multichannel_gain);
-	q6asm_add_hdr_async(ac, &multi_ch_gain.hdr, sz, TRUE);
-	atomic_set(&ac->cmd_state_pp, -1);
-	multi_ch_gain.hdr.opcode = ASM_STREAM_CMD_SET_PP_PARAMS_V2;
-	multi_ch_gain.param.data_payload_addr_lsw = 0;
-	multi_ch_gain.param.data_payload_addr_msw = 0;
-	multi_ch_gain.param.mem_map_handle = 0;
-	multi_ch_gain.param.data_payload_size = sizeof(multi_ch_gain) -
-		sizeof(multi_ch_gain.hdr) - sizeof(multi_ch_gain.param);
-	multi_ch_gain.data.module_id = ASM_MODULE_ID_VOL_CTRL;
-	multi_ch_gain.data.param_id = ASM_PARAM_ID_MULTICHANNEL_GAIN;
-	multi_ch_gain.data.param_size = multi_ch_gain.param.data_payload_size -
-		sizeof(multi_ch_gain.data);
-	multi_ch_gain.data.reserved = 0;
+
+	param_info.module_id = ASM_MODULE_ID_VOL_CTRL;
+	param_info.instance_id = INSTANCE_ID_0;
+	param_info.param_id = ASM_PARAM_ID_MULTICHANNEL_GAIN;
+	param_info.param_size = sizeof(multi_ch_gain);
+
 	multi_ch_gain.gain_data[0].channeltype = PCM_CHANNEL_FL;
 	multi_ch_gain.gain_data[0].gain = left_gain << 15;
 	multi_ch_gain.gain_data[1].channeltype = PCM_CHANNEL_FR;
 	multi_ch_gain.gain_data[1].gain = right_gain << 15;
 	multi_ch_gain.num_channels = 2;
-	rc = apr_send_pkt(ac->apr, (uint32_t *) &multi_ch_gain);
-	if (rc < 0) {
+	rc = q6asm_pack_and_set_pp_param_in_band(ac, param_info,
+						 (u8 *) &multi_ch_gain);
+	if (rc < 0)
 		pr_err("%s: set-params send failed paramid[0x%x] rc %d\n",
-				__func__, multi_ch_gain.data.param_id, rc);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
+		       __func__, param_info.param_id, rc);
 
-	rc = wait_event_timeout(ac->cmd_wait,
-			(atomic_read(&ac->cmd_state_pp) >= 0), 5*HZ);
-	if (!rc) {
-		pr_err("%s: timeout, set-params paramid[0x%x]\n", __func__,
-				multi_ch_gain.data.param_id);
-		rc = -ETIMEDOUT;
-		goto fail_cmd;
-	}
-	if (atomic_read(&ac->cmd_state_pp) > 0) {
-		pr_err("%s: DSP returned error[%s] , set-params paramid[0x%x]\n",
-					__func__, adsp_err_get_err_str(
-					atomic_read(&ac->cmd_state_pp)),
-					multi_ch_gain.data.param_id);
-		rc = adsp_err_get_lnx_err_code(
-				atomic_read(&ac->cmd_state_pp));
-		goto fail_cmd;
-	}
-	rc = 0;
-fail_cmd:
 	return rc;
 }
 
@@ -7412,20 +7547,14 @@ int q6asm_set_multich_gain(struct audio_client *ac, uint32_t channels,
 			   uint32_t *gains, uint8_t *ch_map, bool use_default)
 {
 	struct asm_volume_ctrl_multichannel_gain multich_gain;
-	int sz = 0;
+	struct param_hdr_v3 param_info;
 	int rc  = 0;
 	int i;
 	u8 default_chmap[VOLUME_CONTROL_MAX_CHANNELS];
 
 	if (ac == NULL) {
-		pr_err("%s: ac is NULL\n", __func__);
-		rc = -EINVAL;
-		goto done;
-	}
-	if (ac->apr == NULL) {
-		dev_err(ac->dev, "%s: AC APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto done;
+		pr_err("%s: Audio client is NULL\n", __func__);
+		return -EINVAL;
 	}
 	if (gains == NULL) {
 		dev_err(ac->dev, "%s: gain_list is NULL\n", __func__);
@@ -7444,21 +7573,12 @@ int q6asm_set_multich_gain(struct audio_client *ac, uint32_t channels,
 		goto done;
 	}
 
+	memset(&param_info, 0, sizeof(param_info));
 	memset(&multich_gain, 0, sizeof(multich_gain));
-	sz = sizeof(struct asm_volume_ctrl_multichannel_gain);
-	q6asm_add_hdr_async(ac, &multich_gain.hdr, sz, TRUE);
-	atomic_set(&ac->cmd_state_pp, -1);
-	multich_gain.hdr.opcode = ASM_STREAM_CMD_SET_PP_PARAMS_V2;
-	multich_gain.param.data_payload_addr_lsw = 0;
-	multich_gain.param.data_payload_addr_msw = 0;
-	multich_gain.param.mem_map_handle = 0;
-	multich_gain.param.data_payload_size = sizeof(multich_gain) -
-		sizeof(multich_gain.hdr) - sizeof(multich_gain.param);
-	multich_gain.data.module_id = ASM_MODULE_ID_VOL_CTRL;
-	multich_gain.data.param_id = ASM_PARAM_ID_MULTICHANNEL_GAIN;
-	multich_gain.data.param_size = multich_gain.param.data_payload_size -
-		sizeof(multich_gain.data);
-	multich_gain.data.reserved = 0;
+	param_info.module_id = ASM_MODULE_ID_VOL_CTRL;
+	param_info.instance_id = INSTANCE_ID_0;
+	param_info.param_id = ASM_PARAM_ID_MULTICHANNEL_GAIN;
+	param_info.param_size = sizeof(multich_gain);
 
 	if (use_default) {
 		rc = q6asm_map_channels(default_chmap, channels, false);
@@ -7477,29 +7597,11 @@ int q6asm_set_multich_gain(struct audio_client *ac, uint32_t channels,
 	}
 	multich_gain.num_channels = channels;
 
-	rc = apr_send_pkt(ac->apr, (uint32_t *) &multich_gain);
-	if (rc < 0) {
+	rc = q6asm_pack_and_set_pp_param_in_band(ac, param_info,
+						 (u8 *) &multich_gain);
+	if (rc)
 		pr_err("%s: set-params send failed paramid[0x%x] rc %d\n",
-				__func__, multich_gain.data.param_id, rc);
-		goto done;
-	}
-
-	rc = wait_event_timeout(ac->cmd_wait,
-			(atomic_read(&ac->cmd_state_pp) >= 0), 5*HZ);
-	if (!rc) {
-		pr_err("%s: timeout, set-params paramid[0x%x]\n", __func__,
-				multich_gain.data.param_id);
-		rc = -EINVAL;
-		goto done;
-	}
-	if (atomic_read(&ac->cmd_state_pp) > 0) {
-		pr_err("%s: DSP returned error[%d] , set-params paramid[0x%x]\n",
-		       __func__, atomic_read(&ac->cmd_state_pp),
-		       multich_gain.data.param_id);
-		rc = -EINVAL;
-		goto done;
-	}
-	rc = 0;
+		       __func__, param_info.param_id, rc);
 done:
 	return rc;
 }
@@ -7517,62 +7619,21 @@ EXPORT_SYMBOL(q6asm_set_multich_gain);
 int q6asm_set_mute(struct audio_client *ac, int muteflag)
 {
 	struct asm_volume_ctrl_mute_config mute;
-	int sz = 0;
+	struct param_hdr_v3 param_info;
 	int rc  = 0;
 
-	if (ac == NULL) {
-		pr_err("%s: APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
-	if (ac->apr == NULL) {
-		pr_err("%s: AC APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
-
-	sz = sizeof(struct asm_volume_ctrl_mute_config);
-	q6asm_add_hdr_async(ac, &mute.hdr, sz, TRUE);
-	atomic_set(&ac->cmd_state_pp, -1);
-	mute.hdr.opcode = ASM_STREAM_CMD_SET_PP_PARAMS_V2;
-	mute.param.data_payload_addr_lsw = 0;
-	mute.param.data_payload_addr_msw = 0;
-	mute.param.mem_map_handle = 0;
-	mute.param.data_payload_size = sizeof(mute) -
-		sizeof(mute.hdr) - sizeof(mute.param);
-	mute.data.module_id = ASM_MODULE_ID_VOL_CTRL;
-	mute.data.param_id = ASM_PARAM_ID_VOL_CTRL_MUTE_CONFIG;
-	mute.data.param_size = mute.param.data_payload_size - sizeof(mute.data);
-	mute.data.reserved = 0;
+	memset(&mute, 0, sizeof(mute));
+	memset(&param_info, 0, sizeof(param_info));
+	param_info.module_id = ASM_MODULE_ID_VOL_CTRL;
+	param_info.instance_id = INSTANCE_ID_0;
+	param_info.param_id = ASM_PARAM_ID_VOL_CTRL_MUTE_CONFIG;
+	param_info.param_size = sizeof(mute);
 	mute.mute_flag = muteflag;
 
-	rc = apr_send_pkt(ac->apr, (uint32_t *) &mute);
-	if (rc < 0) {
+	rc = q6asm_pack_and_set_pp_param_in_band(ac, param_info, (u8 *) &mute);
+	if (rc)
 		pr_err("%s: set-params send failed paramid[0x%x] rc %d\n",
-				__func__, mute.data.param_id, rc);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
-
-	rc = wait_event_timeout(ac->cmd_wait,
-			(atomic_read(&ac->cmd_state_pp) >= 0), 5*HZ);
-	if (!rc) {
-		pr_err("%s: timeout, set-params paramid[0x%x]\n", __func__,
-				mute.data.param_id);
-		rc = -ETIMEDOUT;
-		goto fail_cmd;
-	}
-	if (atomic_read(&ac->cmd_state_pp) > 0) {
-		pr_err("%s: DSP returned error[%s] set-params paramid[0x%x]\n",
-				__func__, adsp_err_get_err_str(
-				atomic_read(&ac->cmd_state_pp)),
-				mute.data.param_id);
-		rc = adsp_err_get_lnx_err_code(
-				atomic_read(&ac->cmd_state_pp));
-		goto fail_cmd;
-	}
-	rc = 0;
-fail_cmd:
+		       __func__, param_info.param_id, rc);
 	return rc;
 }
 EXPORT_SYMBOL(q6asm_set_mute);
@@ -7580,74 +7641,28 @@ EXPORT_SYMBOL(q6asm_set_mute);
 static int __q6asm_set_volume(struct audio_client *ac, int volume, int instance)
 {
 	struct asm_volume_ctrl_master_gain vol;
-	int sz = 0;
-	int rc  = 0;
-	int module_id;
+	struct param_hdr_v3 param_info;
+	int rc = 0;
 
-	if (ac == NULL) {
-		pr_err("%s: APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
-	if (ac->apr == NULL) {
-		pr_err("%s: AC APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
+	memset(&vol, 0, sizeof(vol));
+	memset(&param_info, 0, sizeof(param_info));
 
-	switch (instance) {
-	case SOFT_VOLUME_INSTANCE_2:
-		module_id = ASM_MODULE_ID_VOL_CTRL2;
-		break;
-	case SOFT_VOLUME_INSTANCE_1:
-	default:
-		module_id = ASM_MODULE_ID_VOL_CTRL;
-		break;
+	rc = q6asm_set_soft_volume_module_instance_ids(instance, &param_info);
+	if (rc) {
+		pr_err("%s: Failed to pack soft volume module and instance IDs, error %d\n",
+		       __func__, rc);
+		return rc;
 	}
 
-	sz = sizeof(struct asm_volume_ctrl_master_gain);
-	q6asm_add_hdr_async(ac, &vol.hdr, sz, TRUE);
-	atomic_set(&ac->cmd_state_pp, -1);
-	vol.hdr.opcode = ASM_STREAM_CMD_SET_PP_PARAMS_V2;
-	vol.param.data_payload_addr_lsw = 0;
-	vol.param.data_payload_addr_msw = 0;
-	vol.param.mem_map_handle = 0;
-	vol.param.data_payload_size = sizeof(vol) -
-		sizeof(vol.hdr) - sizeof(vol.param);
-	vol.data.module_id = module_id;
-	vol.data.param_id = ASM_PARAM_ID_VOL_CTRL_MASTER_GAIN;
-	vol.data.param_size = vol.param.data_payload_size - sizeof(vol.data);
-	vol.data.reserved = 0;
+	param_info.param_id = ASM_PARAM_ID_VOL_CTRL_MASTER_GAIN;
+	param_info.param_size = sizeof(vol);
 	vol.master_gain = volume;
 
-	rc = apr_send_pkt(ac->apr, (uint32_t *) &vol);
-	if (rc < 0) {
+	rc = q6asm_pack_and_set_pp_param_in_band(ac, param_info, (u8 *) &vol);
+	if (rc)
 		pr_err("%s: set-params send failed paramid[0x%x] rc %d\n",
-				__func__, vol.data.param_id, rc);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
-
-	rc = wait_event_timeout(ac->cmd_wait,
-			(atomic_read(&ac->cmd_state_pp) >= 0), 5*HZ);
-	if (!rc) {
-		pr_err("%s: timeout, set-params paramid[0x%x]\n", __func__,
-				vol.data.param_id);
-		rc = -ETIMEDOUT;
-		goto fail_cmd;
-	}
-	if (atomic_read(&ac->cmd_state_pp) > 0) {
-		pr_err("%s: DSP returned error[%s] set-params paramid[0x%x]\n",
-				__func__, adsp_err_get_err_str(
-				atomic_read(&ac->cmd_state_pp)),
-				vol.data.param_id);
-		rc = adsp_err_get_lnx_err_code(
-				atomic_read(&ac->cmd_state_pp));
-		goto fail_cmd;
-	}
+		       __func__, param_info.param_id, rc);
 
-	rc = 0;
-fail_cmd:
 	return rc;
 }
 
@@ -7925,67 +7940,27 @@ int q6asm_set_softpause(struct audio_client *ac,
 			struct asm_softpause_params *pause_param)
 {
 	struct asm_soft_pause_params softpause;
-	int sz = 0;
+	struct param_hdr_v3 param_info;
 	int rc  = 0;
 
-	if (ac == NULL) {
-		pr_err("%s: APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
-	if (ac->apr == NULL) {
-		pr_err("%s: AC APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
+	memset(&softpause, 0, sizeof(softpause));
+	memset(&param_info, 0, sizeof(param_info));
+	param_info.module_id = ASM_MODULE_ID_VOL_CTRL;
+	param_info.instance_id = INSTANCE_ID_0;
+	param_info.param_id = ASM_PARAM_ID_SOFT_PAUSE_PARAMETERS;
+	param_info.param_size = sizeof(softpause);
 
-	sz = sizeof(struct asm_soft_pause_params);
-	q6asm_add_hdr_async(ac, &softpause.hdr, sz, TRUE);
-	atomic_set(&ac->cmd_state_pp, -1);
-	softpause.hdr.opcode = ASM_STREAM_CMD_SET_PP_PARAMS_V2;
-
-	softpause.param.data_payload_addr_lsw = 0;
-	softpause.param.data_payload_addr_msw = 0;
-	softpause.param.mem_map_handle = 0;
-	softpause.param.data_payload_size = sizeof(softpause) -
-		sizeof(softpause.hdr) - sizeof(softpause.param);
-	softpause.data.module_id = ASM_MODULE_ID_VOL_CTRL;
-	softpause.data.param_id = ASM_PARAM_ID_SOFT_PAUSE_PARAMETERS;
-	softpause.data.param_size = softpause.param.data_payload_size -
-		sizeof(softpause.data);
-	softpause.data.reserved = 0;
 	softpause.enable_flag = pause_param->enable;
 	softpause.period = pause_param->period;
 	softpause.step = pause_param->step;
 	softpause.ramping_curve = pause_param->rampingcurve;
 
-	rc = apr_send_pkt(ac->apr, (uint32_t *) &softpause);
-	if (rc < 0) {
+	rc = q6asm_pack_and_set_pp_param_in_band(ac, param_info,
+						 (u8 *) &softpause);
+	if (rc)
 		pr_err("%s: set-params send failed paramid[0x%x] rc %d\n",
-				__func__, softpause.data.param_id, rc);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
+		       __func__, param_info.param_id, rc);
 
-	rc = wait_event_timeout(ac->cmd_wait,
-			(atomic_read(&ac->cmd_state_pp) >= 0), 5*HZ);
-	if (!rc) {
-		pr_err("%s: timeout, set-params paramid[0x%x]\n", __func__,
-						softpause.data.param_id);
-		rc = -ETIMEDOUT;
-		goto fail_cmd;
-	}
-	if (atomic_read(&ac->cmd_state_pp) > 0) {
-		pr_err("%s: DSP returned error[%s] set-params paramid[0x%x]\n",
-				__func__, adsp_err_get_err_str(
-				atomic_read(&ac->cmd_state_pp)),
-				softpause.data.param_id);
-		rc = adsp_err_get_lnx_err_code(
-				atomic_read(&ac->cmd_state_pp));
-		goto fail_cmd;
-	}
-	rc = 0;
-fail_cmd:
 	return rc;
 }
 EXPORT_SYMBOL(q6asm_set_softpause);
@@ -7995,76 +7970,32 @@ static int __q6asm_set_softvolume(struct audio_client *ac,
 				  int instance)
 {
 	struct asm_soft_step_volume_params softvol;
-	int sz = 0;
-	int rc  = 0;
-	int module_id;
+	struct param_hdr_v3 param_info;
+	int rc = 0;
 
-	if (ac == NULL) {
-		pr_err("%s: APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
-	if (ac->apr == NULL) {
-		pr_err("%s: AC APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
+	memset(&softvol, 0, sizeof(softvol));
+	memset(&param_info, 0, sizeof(param_info));
 
-	switch (instance) {
-	case SOFT_VOLUME_INSTANCE_2:
-		module_id = ASM_MODULE_ID_VOL_CTRL2;
-		break;
-	case SOFT_VOLUME_INSTANCE_1:
-	default:
-		module_id = ASM_MODULE_ID_VOL_CTRL;
-		break;
+	rc = q6asm_set_soft_volume_module_instance_ids(instance, &param_info);
+	if (rc) {
+		pr_err("%s: Failed to pack soft volume module and instance IDs, error %d\n",
+		       __func__, rc);
+		return rc;
 	}
 
-	sz = sizeof(struct asm_soft_step_volume_params);
-	q6asm_add_hdr_async(ac, &softvol.hdr, sz, TRUE);
-	atomic_set(&ac->cmd_state_pp, -1);
-	softvol.hdr.opcode = ASM_STREAM_CMD_SET_PP_PARAMS_V2;
-	softvol.param.data_payload_addr_lsw = 0;
-	softvol.param.data_payload_addr_msw = 0;
-	softvol.param.mem_map_handle = 0;
-	softvol.param.data_payload_size = sizeof(softvol) -
-		sizeof(softvol.hdr) - sizeof(softvol.param);
-	softvol.data.module_id = module_id;
-	softvol.data.param_id = ASM_PARAM_ID_SOFT_VOL_STEPPING_PARAMETERS;
-	softvol.data.param_size = softvol.param.data_payload_size -
-		sizeof(softvol.data);
-	softvol.data.reserved = 0;
+	param_info.param_id = ASM_PARAM_ID_SOFT_VOL_STEPPING_PARAMETERS;
+	param_info.param_size = sizeof(softvol);
+
 	softvol.period = softvol_param->period;
 	softvol.step = softvol_param->step;
 	softvol.ramping_curve = softvol_param->rampingcurve;
 
-	rc = apr_send_pkt(ac->apr, (uint32_t *) &softvol);
-	if (rc < 0) {
+	rc = q6asm_pack_and_set_pp_param_in_band(ac, param_info,
+						 (u8 *) &softvol);
+	if (rc)
 		pr_err("%s: set-params send failed paramid[0x%x] rc %d\n",
-				__func__, softvol.data.param_id, rc);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
+		       __func__, param_info.param_id, rc);
 
-	rc = wait_event_timeout(ac->cmd_wait,
-			(atomic_read(&ac->cmd_state_pp) >= 0), 5*HZ);
-	if (!rc) {
-		pr_err("%s: timeout, set-params paramid[0x%x]\n", __func__,
-						softvol.data.param_id);
-		rc = -ETIMEDOUT;
-		goto fail_cmd;
-	}
-	if (atomic_read(&ac->cmd_state_pp) > 0) {
-		pr_err("%s: DSP returned error[%s] set-params paramid[0x%x]\n",
-				__func__, adsp_err_get_err_str(
-				atomic_read(&ac->cmd_state_pp)),
-				softvol.data.param_id);
-		rc = adsp_err_get_lnx_err_code(
-				atomic_read(&ac->cmd_state_pp));
-		goto fail_cmd;
-	}
-	rc = 0;
-fail_cmd:
 	return rc;
 }
 
@@ -8116,40 +8047,27 @@ int q6asm_equalizer(struct audio_client *ac, void *eq_p)
 {
 	struct asm_eq_params eq;
 	struct msm_audio_eq_stream_config *eq_params = NULL;
+	struct param_hdr_v3 param_info;
 	int i  = 0;
-	int sz = 0;
 	int rc  = 0;
 
 	if (ac == NULL) {
-		pr_err("%s: APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
-	if (ac->apr == NULL) {
-		pr_err("%s: AC APR handle NULL\n", __func__);
-		rc = -EINVAL;
-		goto fail_cmd;
+		pr_err("%s: Audio client is NULL\n", __func__);
+		return -EINVAL;
 	}
-
 	if (eq_p == NULL) {
 		pr_err("%s: [%d]: Invalid Eq param\n", __func__, ac->session);
 		rc = -EINVAL;
 		goto fail_cmd;
 	}
-	sz = sizeof(struct asm_eq_params);
-	eq_params = (struct msm_audio_eq_stream_config *) eq_p;
-	q6asm_add_hdr(ac, &eq.hdr, sz, TRUE);
-	atomic_set(&ac->cmd_state_pp, -1);
 
-	eq.hdr.opcode = ASM_STREAM_CMD_SET_PP_PARAMS_V2;
-	eq.param.data_payload_addr_lsw = 0;
-	eq.param.data_payload_addr_msw = 0;
-	eq.param.mem_map_handle = 0;
-	eq.param.data_payload_size = sizeof(eq) -
-		sizeof(eq.hdr) - sizeof(eq.param);
-	eq.data.module_id = ASM_MODULE_ID_EQUALIZER;
-	eq.data.param_id = ASM_PARAM_ID_EQUALIZER_PARAMETERS;
-	eq.data.param_size = eq.param.data_payload_size - sizeof(eq.data);
+	memset(&eq, 0, sizeof(eq));
+	memset(&param_info, 0, sizeof(param_info));
+	eq_params = (struct msm_audio_eq_stream_config *) eq_p;
+	param_info.module_id = ASM_MODULE_ID_EQUALIZER;
+	param_info.instance_id = INSTANCE_ID_0;
+	param_info.param_id = ASM_PARAM_ID_EQUALIZER_PARAMETERS;
+	param_info.param_size = sizeof(eq);
 	eq.enable_flag = eq_params->enable;
 	eq.num_bands = eq_params->num_bands;
 
@@ -8175,32 +8093,11 @@ int q6asm_equalizer(struct audio_client *ac, void *eq_p)
 		pr_debug("%s: q_factor:%d bandnum:%d\n", __func__,
 				eq_params->eq_bands[i].q_factor, i);
 	}
-	rc = apr_send_pkt(ac->apr, (uint32_t *)&eq);
-	if (rc < 0) {
+	rc = q6asm_pack_and_set_pp_param_in_band(ac, param_info, (u8 *) &eq);
+	if (rc)
 		pr_err("%s: set-params send failed paramid[0x%x] rc %d\n",
-				__func__, eq.data.param_id, rc);
-		rc = -EINVAL;
-		goto fail_cmd;
-	}
+		       __func__, param_info.param_id, rc);
 
-	rc = wait_event_timeout(ac->cmd_wait,
-			(atomic_read(&ac->cmd_state_pp) >= 0), 5*HZ);
-	if (!rc) {
-		pr_err("%s: timeout, set-params paramid[0x%x]\n", __func__,
-						eq.data.param_id);
-		rc = -ETIMEDOUT;
-		goto fail_cmd;
-	}
-	if (atomic_read(&ac->cmd_state_pp) > 0) {
-		pr_err("%s: DSP returned error[%s] set-params paramid[0x%x]\n",
-				__func__, adsp_err_get_err_str(
-				atomic_read(&ac->cmd_state_pp)),
-				eq.data.param_id);
-		rc = adsp_err_get_lnx_err_code(
-				atomic_read(&ac->cmd_state_pp));
-		goto fail_cmd;
-	}
-	rc = 0;
 fail_cmd:
 	return rc;
 }
@@ -8797,7 +8694,7 @@ int q6asm_get_session_time(struct audio_client *ac, uint64_t *tstamp)
 	mtmx_params.param_info.param_id =
 		ASM_SESSION_MTMX_STRTR_PARAM_SESSION_TIME_V3;
 	mtmx_params.param_info.param_max_size =
-		sizeof(struct asm_stream_param_data_v2) +
+		sizeof(struct param_hdr_v1) +
 		sizeof(struct asm_session_mtmx_strtr_param_session_time_v3_t);
 	atomic_set(&ac->time_flag, 1);
 
@@ -8894,72 +8791,18 @@ EXPORT_SYMBOL(q6asm_get_session_time_legacy);
 int q6asm_send_audio_effects_params(struct audio_client *ac, char *params,
 				    uint32_t params_length)
 {
-	char *asm_params = NULL;
-	struct apr_hdr hdr;
-	struct asm_stream_cmd_set_pp_params_v2 payload_params;
-	int sz, rc;
+	int rc;
 
 	pr_debug("%s:\n", __func__);
-	if (!ac) {
-		pr_err("%s: APR handle NULL\n", __func__);
-		return -EINVAL;
-	}
-	if (ac->apr == NULL) {
-		pr_err("%s: AC APR handle NULL\n", __func__);
-		return -EINVAL;
-	}
-	if (params == NULL) {
-		pr_err("%s: params NULL\n", __func__);
-		return -EINVAL;
-	}
-	sz = sizeof(struct apr_hdr) +
-		sizeof(struct asm_stream_cmd_set_pp_params_v2) +
-		params_length;
-	asm_params = kzalloc(sz, GFP_KERNEL);
-	if (!asm_params) {
-		pr_err("%s, asm params memory alloc failed", __func__);
-		return -ENOMEM;
-	}
-	q6asm_add_hdr_async(ac, &hdr, (sizeof(struct apr_hdr) +
-				sizeof(struct asm_stream_cmd_set_pp_params_v2) +
-				params_length), TRUE);
-	atomic_set(&ac->cmd_state_pp, -1);
-	hdr.opcode = ASM_STREAM_CMD_SET_PP_PARAMS_V2;
-	payload_params.data_payload_addr_lsw = 0;
-	payload_params.data_payload_addr_msw = 0;
-	payload_params.mem_map_handle = 0;
-	payload_params.data_payload_size = params_length;
-	memcpy(((u8 *)asm_params), &hdr, sizeof(struct apr_hdr));
-	memcpy(((u8 *)asm_params + sizeof(struct apr_hdr)), &payload_params,
-			sizeof(struct asm_stream_cmd_set_pp_params_v2));
-	memcpy(((u8 *)asm_params + sizeof(struct apr_hdr) +
-				sizeof(struct asm_stream_cmd_set_pp_params_v2)),
-			params, params_length);
-	rc = apr_send_pkt(ac->apr, (uint32_t *) asm_params);
-	if (rc < 0) {
+
+	/*
+	 * Leave function as wrapper for use by effects. Params must be properly
+	 * packed. Use q6common_pack_pp_param to pack params correctly.
+	 */
+	rc = q6asm_set_pp_params(ac, NULL, params, params_length);
+	if (rc)
 		pr_err("%s: audio effects set-params send failed\n", __func__);
-		rc = -EINVAL;
-		goto fail_send_param;
-	}
-	rc = wait_event_timeout(ac->cmd_wait,
-				(atomic_read(&ac->cmd_state_pp) >= 0), 1*HZ);
-	if (!rc) {
-		pr_err("%s: timeout, audio effects set-params\n", __func__);
-		rc = -ETIMEDOUT;
-		goto fail_send_param;
-	}
-	if (atomic_read(&ac->cmd_state_pp) > 0) {
-		pr_err("%s: DSP returned error[%s] set-params\n",
-				__func__, adsp_err_get_err_str(
-				atomic_read(&ac->cmd_state_pp)));
-		rc = adsp_err_get_lnx_err_code(
-				atomic_read(&ac->cmd_state_pp));
-		goto fail_send_param;
-	}
 
-	rc = 0;
-fail_send_param:
-	kfree(asm_params);
 	return rc;
 }
 EXPORT_SYMBOL(q6asm_send_audio_effects_params);
@@ -9006,7 +8849,7 @@ int q6asm_send_mtmx_strtr_window(struct audio_client *ac,
 	matrix.param.data_payload_addr_msw = 0;
 	matrix.param.mem_map_handle = 0;
 	matrix.param.data_payload_size =
-		sizeof(struct asm_stream_param_data_v2) +
+		sizeof(struct param_hdr_v1) +
 		sizeof(struct asm_session_mtmx_strtr_param_window_v2_t);
 	matrix.param.direction = 0; /* RX */
 	matrix.data.module_id = ASM_SESSION_MTMX_STRTR_MODULE_ID_AVSYNC;
@@ -9101,7 +8944,7 @@ int q6asm_send_mtmx_strtr_render_mode(struct audio_client *ac,
 	matrix.param.data_payload_addr_msw = 0;
 	matrix.param.mem_map_handle = 0;
 	matrix.param.data_payload_size =
-		sizeof(struct asm_stream_param_data_v2) +
+		sizeof(struct param_hdr_v1) +
 		sizeof(struct asm_session_mtmx_strtr_param_render_mode_t);
 	matrix.param.direction = 0; /* RX */
 	matrix.data.module_id = ASM_SESSION_MTMX_STRTR_MODULE_ID_AVSYNC;
@@ -9196,7 +9039,7 @@ int q6asm_send_mtmx_strtr_clk_rec_mode(struct audio_client *ac,
 	matrix.param.data_payload_addr_msw = 0;
 	matrix.param.mem_map_handle = 0;
 	matrix.param.data_payload_size =
-		sizeof(struct asm_stream_param_data_v2) +
+		sizeof(struct param_hdr_v1) +
 		sizeof(struct asm_session_mtmx_strtr_param_clk_rec_t);
 	matrix.param.direction = 0; /* RX */
 	matrix.data.module_id = ASM_SESSION_MTMX_STRTR_MODULE_ID_AVSYNC;
@@ -9281,7 +9124,7 @@ int q6asm_send_mtmx_strtr_enable_adjust_session_clock(struct audio_client *ac,
 	matrix.param.data_payload_addr_msw = 0;
 	matrix.param.mem_map_handle = 0;
 	matrix.param.data_payload_size =
-		sizeof(struct asm_stream_param_data_v2) +
+		sizeof(struct param_hdr_v1) +
 		sizeof(struct asm_session_mtmx_param_adjust_session_time_ctl_t);
 	matrix.param.direction = 0; /* RX */
 	matrix.data.module_id = ASM_SESSION_MTMX_STRTR_MODULE_ID_AVSYNC;
@@ -10010,20 +9853,14 @@ done:
 int q6asm_send_cal(struct audio_client *ac)
 {
 	struct cal_block_data *cal_block = NULL;
-	struct apr_hdr	hdr;
-	char *asm_params = NULL;
-	struct asm_stream_cmd_set_pp_params_v2 payload_params;
-	int sz, rc = -EINVAL;
-
+	struct mem_mapping_hdr mem_hdr;
+	u32 payload_size = 0;
+	int rc = -EINVAL;
 	pr_debug("%s:\n", __func__);
 
 	if (!ac) {
-		pr_err("%s: APR handle NULL\n", __func__);
-		goto done;
-	}
-	if (ac->apr == NULL) {
-		pr_err("%s: AC APR handle NULL\n", __func__);
-		goto done;
+		pr_err("%s: Audio client is NULL\n", __func__);
+		return -EINVAL;
 	}
 	if (ac->io_mode & NT_MODE) {
 		pr_debug("%s: called for NT MODE, exiting\n", __func__);
@@ -10038,6 +9875,7 @@ int q6asm_send_cal(struct audio_client *ac)
 		goto done;
 	}
 
+	memset(&mem_hdr, 0, sizeof(mem_hdr));
 	mutex_lock(&cal_data[ASM_AUDSTRM_CAL]->lock);
 	cal_block = cal_utils_get_only_cal_block(cal_data[ASM_AUDSTRM_CAL]);
 	if (cal_block == NULL) {
@@ -10060,62 +9898,26 @@ int q6asm_send_cal(struct audio_client *ac)
 		goto unlock;
 	}
 
-	sz = sizeof(struct apr_hdr) +
-		sizeof(struct asm_stream_cmd_set_pp_params_v2);
-	asm_params = kzalloc(sz, GFP_KERNEL);
-	if (!asm_params) {
-		pr_err("%s, asm params memory alloc failed", __func__);
-		rc = -ENOMEM;
-		goto unlock;
-	}
-
-	/* asm_stream_cmd_set_pp_params_v2 has no APR header in it */
-	q6asm_add_hdr_async(ac, &hdr, (sizeof(struct apr_hdr) +
-		sizeof(struct asm_stream_cmd_set_pp_params_v2)), TRUE);
-
-	atomic_set(&ac->cmd_state_pp, -1);
-	hdr.opcode = ASM_STREAM_CMD_SET_PP_PARAMS_V2;
-	payload_params.data_payload_addr_lsw =
-			lower_32_bits(cal_block->cal_data.paddr);
-	payload_params.data_payload_addr_msw =
-			msm_audio_populate_upper_32_bits(
-						cal_block->cal_data.paddr);
-	payload_params.mem_map_handle = cal_block->map_data.q6map_handle;
-	payload_params.data_payload_size = cal_block->cal_data.size;
-	memcpy(((u8 *)asm_params), &hdr, sizeof(struct apr_hdr));
-	memcpy(((u8 *)asm_params + sizeof(struct apr_hdr)), &payload_params,
-			sizeof(struct asm_stream_cmd_set_pp_params_v2));
+	mem_hdr.data_payload_addr_lsw =
+		lower_32_bits(cal_block->cal_data.paddr);
+	mem_hdr.data_payload_addr_msw =
+		msm_audio_populate_upper_32_bits(cal_block->cal_data.paddr);
+	mem_hdr.mem_map_handle = cal_block->map_data.q6map_handle;
+	payload_size = cal_block->cal_data.size;
 
 	pr_debug("%s: phyaddr lsw = %x msw = %x, maphdl = %x calsize = %d\n",
-		__func__, payload_params.data_payload_addr_lsw,
-		payload_params.data_payload_addr_msw,
-		payload_params.mem_map_handle,
-		payload_params.data_payload_size);
+		 __func__, mem_hdr.data_payload_addr_lsw,
+		 mem_hdr.data_payload_addr_msw, mem_hdr.mem_map_handle,
+		 payload_size);
 
-	rc = apr_send_pkt(ac->apr, (uint32_t *) asm_params);
-	if (rc < 0) {
+	rc = q6asm_set_pp_params(ac, &mem_hdr, NULL, payload_size);
+	if (rc) {
 		pr_err("%s: audio audstrm cal send failed\n", __func__);
-		rc = -EINVAL;
-		goto free;
-	}
-	rc = wait_event_timeout(ac->cmd_wait,
-				(atomic_read(&ac->cmd_state_pp) >= 0), 5 * HZ);
-	if (!rc) {
-		pr_err("%s: timeout, audio audstrm cal send\n", __func__);
-		rc = -ETIMEDOUT;
-		goto free;
-	}
-	if (atomic_read(&ac->cmd_state_pp) > 0) {
-		pr_err("%s: DSP returned error[%d] audio audstrm cal send\n",
-				__func__, atomic_read(&ac->cmd_state_pp));
-		rc = -EINVAL;
-		goto free;
+		goto unlock;
 	}
 
 	rc = 0;
 
-free:
-	kfree(asm_params);
 unlock:
 	mutex_unlock(&cal_data[ASM_AUDSTRM_CAL]->lock);
 done:

include/dsp/apr_audio-v2.h

@@ -730,15 +730,6 @@ struct adm_cmd_set_pp_params_v5 {
 	 */
 } __packed;
 
-struct audproc_mfc_output_media_fmt {
-	struct adm_cmd_set_pp_params_v5 params;
-	struct param_hdr_v1 data;
-	uint32_t sampling_rate;
-	uint16_t bits_per_sample;
-	uint16_t num_channels;
-	uint16_t channel_type[8];
-} __packed;
-
 struct audproc_mfc_param_media_fmt {
 	uint32_t sampling_rate;
 	uint16_t bits_per_sample;
@@ -6610,55 +6601,27 @@ struct asm_stream_cmd_open_transcode_loopback_t {
 #define ASM_STREAM_CMD_SET_PP_PARAMS_V2 0x00010DA1
 #define ASM_STREAM_CMD_SET_PP_PARAMS_V3 0x0001320D
 
-struct asm_stream_cmd_set_pp_params_v2 {
-	u32                  data_payload_addr_lsw;
-/* LSW of parameter data payload address. Supported values: any. */
-	u32                  data_payload_addr_msw;
-/* MSW of Parameter data payload address. Supported values: any.
- * - Must be set to zero for in-band data.
- * - In the case of 32 bit Shared memory address, msw  field must be
- * - set to zero.
- * - In the case of 36 bit shared memory address, bit 31 to bit 4 of
- * msw
- *
- * - must be set to zero.
- */
-	u32                  mem_map_handle;
-/* Supported Values: Any.
- * memory map handle returned by DSP through
- * ASM_CMD_SHARED_MEM_MAP_REGIONS
- * command.
- * if mmhandle is NULL, the ParamData payloads are within the
- * message payload (in-band).
- * If mmhandle is non-NULL, the ParamData payloads begin at the
- * address specified in the address msw and lsw (out-of-band).
- */
-
-	u32                  data_payload_size;
-/* Size in bytes of the variable payload accompanying the
- * message, or in shared memory. This field is used for parsing the
- * parameter payload.
+/*
+ * Structure for the ASM Stream Set PP Params command. Parameter data must be
+ * pre-packed with the correct header for either V2 or V3 when sent in-band.
+ * Use q6core_pack_pp_params to pack the header and data correctly depending on
+ * Instance ID support.
  */
-} __packed;
-
-
-struct asm_stream_param_data_v2 {
-	u32                  module_id;
-	/* Unique module ID. */
-
-	u32                  param_id;
-	/* Unique parameter ID. */
+struct asm_stream_cmd_set_pp_params {
+	/* APR Header */
+	struct apr_hdr apr_hdr;
 
-	u16                  param_size;
-/* Data size of the param_id/module_id combination. This is
- * a multiple of 4 bytes.
- */
+	/* The memory mapping header to be used when sending out of band */
+	struct mem_mapping_hdr mem_hdr;
 
-	u16                  reserved;
-/* Reserved for future enhancements. This field must be set to
- * zero.
- */
+	/* The total size of the payload, including the parameter header */
+	u32 payload_size;
 
+	/* The parameter data to be filled when sent inband. Parameter data
+	 * must be pre-packed with parameter header and then copied here. Use
+	 * q6core_pack_pp_params to pack the header and param data correctly.
+	 */
+	u32 param_data[0];
 } __packed;
 
 #define ASM_STREAM_CMD_GET_PP_PARAMS_V2		0x00010DA2
@@ -8082,9 +8045,6 @@ struct audproc_topology_module_id_info_t {
 
 
 struct asm_volume_ctrl_master_gain {
-	struct apr_hdr	hdr;
-	struct asm_stream_cmd_set_pp_params_v2 param;
-	struct asm_stream_param_data_v2 data;
 	uint16_t                  master_gain;
 	/* Linear gain in Q13 format. */
 
@@ -8094,10 +8054,6 @@ struct asm_volume_ctrl_master_gain {
 
 
 struct asm_volume_ctrl_lr_chan_gain {
-	struct apr_hdr	hdr;
-	struct asm_stream_cmd_set_pp_params_v2 param;
-	struct asm_stream_param_data_v2 data;
-
 	uint16_t                  l_chan_gain;
 	/*< Linear gain in Q13 format for the left channel. */
 
@@ -8117,9 +8073,6 @@ struct asm_volume_ctrl_lr_chan_gain {
 
 
 struct asm_volume_ctrl_mute_config {
-	struct apr_hdr	hdr;
-	struct asm_stream_cmd_set_pp_params_v2 param;
-	struct asm_stream_param_data_v2 data;
 	uint32_t                  mute_flag;
 /*< Specifies whether mute is disabled (0) or enabled (nonzero).*/
 
@@ -8147,9 +8100,6 @@ struct asm_volume_ctrl_mute_config {
  * parameters used by the Volume Control module.
  */
 struct asm_soft_step_volume_params {
-	struct apr_hdr	hdr;
-	struct asm_stream_cmd_set_pp_params_v2 param;
-	struct asm_stream_param_data_v2 data;
 	uint32_t                  period;
 /*< Period in milliseconds.
  * Supported values: 0 to 15000
@@ -8179,9 +8129,6 @@ struct asm_soft_step_volume_params {
 
 
 struct asm_soft_pause_params {
-	struct apr_hdr	hdr;
-	struct asm_stream_cmd_set_pp_params_v2 param;
-	struct asm_stream_param_data_v2 data;
 	uint32_t                  enable_flag;
 /*< Specifies whether soft pause is disabled (0) or enabled
  * (nonzero).
@@ -8271,10 +8218,7 @@ struct asm_volume_ctrl_channeltype_gain_pair {
 
 
 struct asm_volume_ctrl_multichannel_gain {
-	struct apr_hdr	hdr;
-	struct asm_stream_cmd_set_pp_params_v2 param;
-	struct asm_stream_param_data_v2 data;
-	uint32_t                  num_channels;
+	uint32_t num_channels;
 	/*
 	 * Number of channels for which gain values are provided. Any
 	 * channels present in the data for which gain is not provided are
@@ -8299,9 +8243,6 @@ struct asm_volume_ctrl_multichannel_gain {
 
 
 struct asm_volume_ctrl_channelype_mute_pair {
-	struct apr_hdr	hdr;
-	struct asm_stream_cmd_set_pp_params_v2 param;
-	struct asm_stream_param_data_v2 data;
 	uint8_t                   channelype;
 /*< Channel type for which the mute setting is to be applied.
  * Supported values:
@@ -8350,9 +8291,6 @@ struct asm_volume_ctrl_channelype_mute_pair {
 
 
 struct asm_volume_ctrl_multichannel_mute {
-	struct apr_hdr	hdr;
-	struct asm_stream_cmd_set_pp_params_v2 param;
-	struct asm_stream_param_data_v2 data;
 	uint32_t                  num_channels;
 /*< Number of channels for which mute configuration is
  * provided. Any channels present in the data for which mute
@@ -8797,9 +8735,6 @@ struct asm_eq_per_band_params {
 } __packed;
 
 struct asm_eq_params {
-	struct apr_hdr	hdr;
-	struct asm_stream_cmd_set_pp_params_v2 param;
-	struct asm_stream_param_data_v2 data;
 		uint32_t                  enable_flag;
 /*< Specifies whether the equalizer module is disabled (0) or enabled
  * (nonzero).
@@ -9463,16 +9398,6 @@ struct srs_trumedia_params {
 #define ASM_STREAM_POSTPROC_TOPO_ID_DTS_HPX 0x00010DED
 #define ASM_STREAM_POSTPROC_TOPO_ID_HPX_PLUS  0x10015000
 #define ASM_STREAM_POSTPROC_TOPO_ID_HPX_MASTER  0x10015001
-struct asm_dts_eagle_param {
-	struct apr_hdr	hdr;
-	struct asm_stream_cmd_set_pp_params_v2 param;
-	struct asm_stream_param_data_v2 data;
-} __packed;
-
-struct asm_dts_eagle_param_get {
-	struct apr_hdr	hdr;
-	struct asm_stream_cmd_get_pp_params_v2 param;
-} __packed;
 
 /* Opcode to set BT address and license for aptx decoder */
 #define APTX_DECODER_BT_ADDRESS 0x00013201
@@ -10759,7 +10684,7 @@ union asm_session_mtmx_strtr_param_config {
 struct asm_mtmx_strtr_params {
 	struct apr_hdr  hdr;
 	struct asm_session_cmd_set_mtmx_strstr_params_v2 param;
-	struct asm_stream_param_data_v2 data;
+	struct param_hdr_v1 data;
 	union asm_session_mtmx_strtr_param_config config;
 } __packed;
 
@@ -10869,7 +10794,7 @@ struct asm_mtmx_strtr_get_params {
 
 struct asm_mtmx_strtr_get_params_cmdrsp {
 	uint32_t err_code;
-	struct asm_stream_param_data_v2 param_info;
+	struct param_hdr_v1 param_info;
 	union asm_session_mtmx_strtr_data_type param_data;
 } __packed;
 

include/dsp/q6asm-v2.h

@@ -264,6 +264,17 @@ int q6asm_audio_client_buf_alloc_contiguous(unsigned int dir
 int q6asm_audio_client_buf_free_contiguous(unsigned int dir,
 			struct audio_client *ac);
 
+int q6asm_set_pp_params(struct audio_client *ac,
+			struct mem_mapping_hdr *mem_hdr, u8 *param_data,
+			u32 param_size);
+
+int q6asm_pack_and_set_pp_param_in_band(struct audio_client *ac,
+					struct param_hdr_v3 param_hdr,
+					u8 *param_data);
+
+int q6asm_set_soft_volume_module_instance_ids(int instance,
+					      struct param_hdr_v3 *param_hdr);
+
 int q6asm_open_read(struct audio_client *ac, uint32_t format
 		/*, uint16_t bits_per_sample*/);