Merge "ASoC: msm: DTS: integrate DTS TM changes for version 3.1.2.0" (69b6fa93) · Commits · e / devices / android_kernel_sony_msm8994

include/sound/apr_audio-v2.h

+48 −35

Original line number	Diff line number	Diff line
		@@ -6988,18 +6988,19 @@ struct afe_spkr_prot_calib_get_resp {
		#define SRS_TRUMEDIA_PARAMS_WOWHD 0x10005012
		#define SRS_TRUMEDIA_PARAMS_CSHP 0x10005013
		#define SRS_TRUMEDIA_PARAMS_HPF 0x10005014
		#define SRS_TRUMEDIA_PARAMS_PEQ 0x10005015
		#define SRS_TRUMEDIA_PARAMS_AEQ 0x10005015
		#define SRS_TRUMEDIA_PARAMS_HL 0x10005016
		#define SRS_TRUMEDIA_PARAMS_GEQ 0x10005017

		#define SRS_ID_GLOBAL 0x00000001
		#define SRS_ID_WOWHD 0x00000002
		#define SRS_ID_CSHP 0x00000003
		#define SRS_ID_HPF 0x00000004
		#define SRS_ID_PEQ 0x00000005
		#define SRS_ID_AEQ 0x00000005
		#define SRS_ID_HL 0x00000006
		#define SRS_ID_GEQ 0x00000007

		#define SRS_CMD_UPLOAD 0x7FFF0000
		#define SRS_PARAM_INDEX_MASK 0x80000000
		#define SRS_PARAM_OFFSET_MASK 0x3FFF0000
		#define SRS_PARAM_VALUE_MASK 0x0000FFFF

		@@ -7012,6 +7013,7 @@ struct srs_trumedia_params_GLOBAL {
		uint8_t v6;
		uint8_t v7;
		uint8_t v8;
		uint16_t v9;
		} __packed;

		struct srs_trumedia_params_WOWHD {
		@@ -7028,6 +7030,12 @@ struct srs_trumedia_params_WOWHD {
		uint16_t v10;
		uint16_t v11;
		uint32_t v12[16];
		uint32_t v13[16];
		uint32_t v14[16];
		uint32_t v15[16];
		uint32_t v16;
		uint16_t v17;
		uint16_t v18;
		} __packed;

		struct srs_trumedia_params_CSHP {
		@@ -7049,14 +7057,15 @@ struct srs_trumedia_params_HPF {
		uint32_t v2[26];
		} __packed;

		struct srs_trumedia_params_PEQ {
		struct srs_trumedia_params_AEQ {
		uint32_t v1;
		uint16_t v2;
		uint16_t v3;
		uint16_t v4;
		uint16_t v____A1;
		uint32_t v5[26];
		uint32_t v6[26];
		uint32_t v5[74];
		uint32_t v6[74];
		uint16_t v7[2048];
		} __packed;

		struct srs_trumedia_params_HL {
		@@ -7071,13 +7080,17 @@ struct srs_trumedia_params_HL {
		uint32_t v7;
		} __packed;

		struct srs_trumedia_params_GEQ {
		int16_t v1[10];
		} __packed;
		struct srs_trumedia_params {
		struct srs_trumedia_params_GLOBAL global;
		struct srs_trumedia_params_WOWHD wowhd;
		struct srs_trumedia_params_CSHP cshp;
		struct srs_trumedia_params_HPF hpf;
		struct srs_trumedia_params_PEQ peq;
		struct srs_trumedia_params_AEQ aeq;
		struct srs_trumedia_params_HL hl;
		struct srs_trumedia_params_GEQ geq;
		} __packed;
		/* SRS TruMedia end */

include/sound/q6adm-v2.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -35,6 +35,7 @@ enum {
		ADM_RTAC_INFO_CAL,
		ADM_RTAC_APR_CAL,
		ADM_DTS_EAGLE,
		ADM_SRS_TRUMEDIA,
		ADM_MAX_CAL_TYPES
		};

		@@ -52,7 +53,7 @@ struct route_payload {
		unsigned int session_id;
		};

		int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		int srs_trumedia_open(int port_id, int copp_idx, __s32 srs_tech_id,
		void *srs_params);

		int adm_dts_eagle_set(int port_id, int copp_idx, int param_id,

sound/soc/msm/qdsp6v2/msm-dts-srs-tm-config.c

+105 −64

Original line number	Diff line number	Diff line
		@@ -14,17 +14,24 @@
		#include <linux/module.h>
		#include <linux/bitops.h>
		#include <linux/mutex.h>
		#include <linux/atomic.h>
		#include <linux/msm_audio_ion.h>
		#include <sound/control.h>
		#include <sound/q6adm-v2.h>
		#include <sound/asound.h>

		#include "msm-dts-srs-tm-config.h"
		#include "msm-pcm-routing-v2.h"
		#include "msm-dts-eagle.h"

		static int srs_port_id[AFE_MAX_PORTS] = {-1};
		static int srs_copp_idx[AFE_MAX_PORTS] = {-1};
		static int srs_alsa_ctrl_ever_called;
		static union srs_trumedia_params_u msm_srs_trumedia_params[2];
		static union srs_trumedia_params_u msm_srs_trumedia_params;
		static struct ion_client *ion_client;
		static struct ion_handle *ion_handle;
		static struct param_outband po;
		static atomic_t ref_cnt;
		#define ION_MEM_SIZE (8 * 1024)

		static int set_port_id(int port_id, int copp_idx)
		{
		@@ -39,16 +46,9 @@ static int set_port_id(int port_id, int copp_idx)
		return 0;
		}

		static void msm_dts_srs_tm_send_params(int port_id, unsigned int techs,
		int param_block_idx)
		static void msm_dts_srs_tm_send_params(__s32 port_id, __u32 techs)
		{
		int index;
		/* only send commands to dsp if srs alsa ctrl was used
		at least one time */
		if (!srs_alsa_ctrl_ever_called)
		return;

		index = adm_validate_and_get_port_index(port_id);
		__s32 index = adm_validate_and_get_port_index(port_id);
		if (index < 0) {
		pr_err("%s: Invalid port idx %d port_id 0x%x\n",
		__func__, index, port_id);
		@@ -60,30 +60,33 @@ static void msm_dts_srs_tm_send_params(int port_id, unsigned int techs,
		__func__);
		return;
		}
		pr_debug("SRS %s: called, port_id = %d, techs flags = %u, paramblockidx %d\n",
		__func__, port_id, techs, param_block_idx);
		pr_debug("SRS %s: called, port_id = %d, techs flags = %u\n",
		__func__, port_id, techs);
		/* force all if techs is set to 1 */
		if (techs == 1)
		techs = 0xFFFFFFFF;

		if (techs & (1 << SRS_ID_WOWHD))
		srs_trumedia_open(port_id, srs_copp_idx[index], SRS_ID_WOWHD,
		(void *)&msm_srs_trumedia_params[param_block_idx].srs_params.wowhd);
		(void *)&msm_srs_trumedia_params.srs_params.wowhd);
		if (techs & (1 << SRS_ID_CSHP))
		srs_trumedia_open(port_id, srs_copp_idx[index], SRS_ID_CSHP,
		(void *)&msm_srs_trumedia_params[param_block_idx].srs_params.cshp);
		(void *)&msm_srs_trumedia_params.srs_params.cshp);
		if (techs & (1 << SRS_ID_HPF))
		srs_trumedia_open(port_id, srs_copp_idx[index], SRS_ID_HPF,
		(void *)&msm_srs_trumedia_params[param_block_idx].srs_params.hpf);
		if (techs & (1 << SRS_ID_PEQ))
		srs_trumedia_open(port_id, srs_copp_idx[index], SRS_ID_PEQ,
		(void *)&msm_srs_trumedia_params[param_block_idx].srs_params.peq);
		(void *)&msm_srs_trumedia_params.srs_params.hpf);
		if (techs & (1 << SRS_ID_AEQ))
		srs_trumedia_open(port_id, srs_copp_idx[index], SRS_ID_AEQ,
		(void *)&msm_srs_trumedia_params.srs_params.aeq);
		if (techs & (1 << SRS_ID_HL))
		srs_trumedia_open(port_id, srs_copp_idx[index], SRS_ID_HL,
		(void *)&msm_srs_trumedia_params[param_block_idx].srs_params.hl);
		(void *)&msm_srs_trumedia_params.srs_params.hl);
		if (techs & (1 << SRS_ID_GEQ))
		srs_trumedia_open(port_id, srs_copp_idx[index], SRS_ID_GEQ,
		(void *)&msm_srs_trumedia_params.srs_params.geq);
		if (techs & (1 << SRS_ID_GLOBAL))
		srs_trumedia_open(port_id, srs_copp_idx[index], SRS_ID_GLOBAL,
		(void *)&msm_srs_trumedia_params[param_block_idx].srs_params.global);
		(void *)&msm_srs_trumedia_params.srs_params.global);
		}


		@@ -98,53 +101,35 @@ static int msm_dts_srs_trumedia_control_set_(int port_id,
		struct snd_kcontrol *kcontrol,
		struct snd_ctl_elem_value *ucontrol)
		{
		unsigned int techs = 0;
		unsigned short offset, value, max, index;

		srs_alsa_ctrl_ever_called = 1;

		max = sizeof(msm_srs_trumedia_params) >> 1;
		index = (unsigned short)((ucontrol->value.integer.value[0] &
		SRS_PARAM_INDEX_MASK) >> 31);
		__u16 offset, value, max = sizeof(msm_srs_trumedia_params) >> 1;
		if (SRS_CMD_UPLOAD ==
		(ucontrol->value.integer.value[0] & SRS_CMD_UPLOAD)) {
		techs = ucontrol->value.integer.value[0] & 0xFF;
		pr_debug("SRS %s: send params request, flags = %u",
		__u32 techs = ucontrol->value.integer.value[0] & 0xFF;
		__s32 index = adm_validate_and_get_port_index(port_id);
		if (index < 0) {
		pr_err("%s: Invalid port idx %d port_id 0x%x\n",
		__func__, index, port_id);
		return -EINVAL;
		}
		pr_debug("SRS %s: send params request, flag = %u\n",
		__func__, techs);
		if (srs_port_id >= 0 && techs)
		msm_dts_srs_tm_send_params(port_id, techs, index);
		if (srs_port_id[index] >= 0 && techs)
		msm_dts_srs_tm_send_params(port_id, techs);
		return 0;
		}
		offset = (unsigned short)((ucontrol->value.integer.value[0] &
		offset = (__u16)((ucontrol->value.integer.value[0] &
		SRS_PARAM_OFFSET_MASK) >> 16);
		value = (unsigned short)(ucontrol->value.integer.value[0] &
		value = (__u16)(ucontrol->value.integer.value[0] &
		SRS_PARAM_VALUE_MASK);
		if (offset < max) {
		msm_srs_trumedia_params[index].raw_params[offset] = value;
		pr_debug("SRS %s: index set... (max %d, requested %d, val %d, paramblockidx %d)",
		__func__, max, offset, value, index);
		msm_srs_trumedia_params.raw_params[offset] = value;
		pr_debug("SRS %s: index set... (max %d, requested %d, value 0x%X)\n",
		__func__, max, offset, value);
		} else {
		pr_err("SRS %s: index out of bounds! (max %d, requested %d)",
		pr_err("SRS %s: index out of bounds! (max %d, requested %d)\n",
		__func__, max, offset);
		}
		if (offset == 4) {
		int i;
		for (i = 0; i < max; i++) {
		if (i == 0) {
		pr_debug("SRS %s: global block start",
		__func__);
		}
		if (i ==
		(sizeof(struct srs_trumedia_params_GLOBAL) >> 1)) {
		pr_debug("SRS %s: wowhd block start at offset %d word offset %d",
		__func__, i, i>>1);
		break;
		}
		pr_debug("SRS %s: param_index %d index %d val %d",
		__func__, index, i,
		msm_srs_trumedia_params[index].raw_params[i]);
		}
		}
		return 0;
		}

		@@ -153,7 +138,7 @@ static int msm_dts_srs_trumedia_control_set(struct snd_kcontrol *kcontrol,
		{
		int ret, port_id;

		pr_debug("SRS control normal called");
		pr_debug("SRS control normal called\n");
		msm_pcm_routing_acquire_lock();
		port_id = SLIMBUS_0_RX;
		ret = msm_dts_srs_trumedia_control_set_(port_id, kcontrol, ucontrol);
		@@ -166,31 +151,33 @@ static int msm_dts_srs_trumedia_control_i2s_set(struct snd_kcontrol *kcontrol,
		{
		int ret, port_id;

		pr_debug("SRS control I2S called");
		pr_debug("SRS control I2S called\n");
		msm_pcm_routing_acquire_lock();
		port_id = PRIMARY_I2S_RX;
		ret = msm_dts_srs_trumedia_control_set_(port_id, kcontrol, ucontrol);
		msm_pcm_routing_release_lock();
		return ret;
		}

		static int msm_dts_srs_trumedia_control_mi2s_set(struct snd_kcontrol *kcontrol,
		struct snd_ctl_elem_value *ucontrol)
		{
		int ret, port_id;

		pr_debug("SRS control MI2S called");
		pr_debug("SRS control MI2S called\n");
		msm_pcm_routing_acquire_lock();
		port_id = AFE_PORT_ID_PRIMARY_MI2S_RX;
		ret = msm_dts_srs_trumedia_control_set_(port_id, kcontrol, ucontrol);
		msm_pcm_routing_release_lock();
		return ret;
		}

		static int msm_dts_srs_trumedia_control_hdmi_set(struct snd_kcontrol *kcontrol,
		struct snd_ctl_elem_value *ucontrol)
		{
		int ret, port_id;

		pr_debug("SRS control HDMI called");
		pr_debug("SRS control HDMI called\n");
		msm_pcm_routing_acquire_lock();
		port_id = HDMI_RX;
		ret = msm_dts_srs_trumedia_control_set_(port_id, kcontrol, ucontrol);
		@@ -257,6 +244,7 @@ static const struct snd_kcontrol_new lpa_srs_trumedia_controls_i2s[] = {
		})
		}
		};

		static const struct snd_kcontrol_new lpa_srs_trumedia_controls_mi2s[] = {
		{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		@@ -278,6 +266,7 @@ static const struct snd_kcontrol_new lpa_srs_trumedia_controls_mi2s[] = {
		})
		}
		};

		void msm_dts_srs_tm_add_controls(struct snd_soc_platform *platform)
		{
		snd_soc_add_platform_controls(platform,
		@@ -296,19 +285,71 @@ void msm_dts_srs_tm_add_controls(struct snd_soc_platform *platform)
		ARRAY_SIZE(lpa_srs_trumedia_controls_mi2s));
		}

		static int reg_ion_mem(void)
		{
		int rc;
		rc = msm_audio_ion_alloc("SRS_TRUMEDIA", &ion_client, &ion_handle,
		ION_MEM_SIZE, &po.paddr, (size_t *)&po.size,
		&po.kvaddr);
		if (rc != 0)
		pr_err("%s: failed to allocate memory.\n", __func__);
		pr_debug("%s: exited ion_client = %p, ion_handle = %p, phys_addr = %lu, length = %d, vaddr = %p, rc = 0x%x\n",
		__func__, ion_client, ion_handle, (long)po.paddr,
		(unsigned int)po.size, po.kvaddr, rc);
		return rc;
		}

		void msm_dts_srs_tm_ion_memmap(struct param_outband *po_)
		{
		if (po.kvaddr == NULL) {
		pr_debug("%s: callingreg_ion_mem()\n", __func__);
		reg_ion_mem();
		}
		po_->size = ION_MEM_SIZE;
		po_->kvaddr = po.kvaddr;
		po_->paddr = po.paddr;
		}

		static void unreg_ion_mem(void)
		{
		msm_audio_ion_free(ion_client, ion_handle);
		po.kvaddr = NULL;
		po.paddr = 0;
		po.size = 0;
		}

		void msm_dts_srs_tm_deinit(int port_id)
		{
		set_port_id(port_id, -1);
		atomic_dec(&ref_cnt);
		if (po.kvaddr != NULL) {
		if (!atomic_read(&ref_cnt)) {
		pr_debug("%s: calling unreg_ion_mem()\n", __func__);
		unreg_ion_mem();
		}
		}
		return;
		}

		void msm_dts_srs_tm_init(int port_id, int copp_idx)
		{
		if (!set_port_id(port_id, copp_idx)) {
		int cur_ref_cnt = 0;

		if (set_port_id(port_id, copp_idx) < 0) {
		pr_err("%s: Invalid port_id: %d\n", __func__, port_id);
		return;
		}

		msm_dts_srs_tm_send_params(port_id, 1, 0);
		cur_ref_cnt = atomic_read(&ref_cnt);
		atomic_inc(&ref_cnt);
		if (!cur_ref_cnt && po.kvaddr == NULL) {
		pr_debug("%s: calling reg_ion_mem()\n", __func__);
		if (reg_ion_mem() != 0) {
		atomic_dec(&ref_cnt);
		po.kvaddr = NULL;
		return;
		}
		}
		msm_dts_srs_tm_send_params(port_id, 1);
		return;
		}

sound/soc/msm/qdsp6v2/msm-dts-srs-tm-config.h

+9 −4

Original line number	Diff line number	Diff line
		@@ -14,20 +14,25 @@

		#include <sound/soc.h>

		struct param_outband;

		#ifdef CONFIG_DTS_SRS_TM

		union srs_trumedia_params_u {
		struct srs_trumedia_params srs_params;
		unsigned short int raw_params[1];
		__u16 raw_params[1];
		};

		void msm_dts_srs_tm_ion_memmap(struct param_outband *po_);
		void msm_dts_srs_tm_init(int port_id, int copp_idx);
		void msm_dts_srs_tm_deinit(int port_id);
		void msm_dts_srs_tm_add_controls(struct snd_soc_platform *platform);
		#else
		void msm_dts_srs_tm_init(int port_id, int copp_idx) { }
		void msm_dts_srs_tm_deinit(int port_id) { }
		void msm_dts_srs_tm_add_controls(struct snd_soc_platform *platform) { }
		static inline void msm_dts_srs_tm_ion_memmap(struct param_outband *po_) { }
		static inline void msm_dts_srs_tm_init(int port_id, int copp_idx) { }
		static inline void msm_dts_srs_tm_deinit(int port_id) { }
		static inline void msm_dts_srs_tm_add_controls(
		struct snd_soc_platform *platform) { }

		#endif

sound/soc/msm/qdsp6v2/q6adm.c

+110 −69

Original line number	Diff line number	Diff line
		@@ -23,8 +23,8 @@
		#include <sound/q6audio-v2.h>
		#include <sound/q6afe-v2.h>
		#include <sound/audio_cal_utils.h>

		#include <sound/asound.h>
		#include "msm-dts-srs-tm-config.h"
		#include "msm-dts-eagle.h"

		#define TIMEOUT_MS 1000
		@@ -382,19 +382,20 @@ fail_cmd:
		return ret;
		}

		int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		int srs_trumedia_open(int port_id, int copp_idx, __s32 srs_tech_id,
		void *srs_params)
		{
		struct adm_cmd_set_pp_params_inband_v5 *adm_params = NULL;
		int ret = 0, sz = 0;
		int port_idx;
		struct adm_cmd_set_pp_params_v5 *adm_params_ = NULL;
		__s32 sz = 0, param_id, module_id = SRS_TRUMEDIA_MODULE_ID, outband = 0;
		int ret = 0, port_idx;

		pr_debug("SRS - %s", __func__);

		port_id = afe_convert_virtual_to_portid(port_id);
		port_idx = adm_validate_and_get_port_index(port_id);
		if (port_idx < 0) {
		pr_err("%s: Invalid port_id 0x%x\n", __func__, port_id);
		pr_err("%s: Invalid port_id %#x\n", __func__, port_id);
		return -EINVAL;
		}
		switch (srs_tech_id) {
		@@ -411,7 +412,7 @@ int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		adm_params->payload_size =
		sizeof(struct srs_trumedia_params_GLOBAL) +
		sizeof(struct adm_param_data_v5);
		adm_params->params.param_id = SRS_TRUMEDIA_PARAMS;
		param_id = SRS_TRUMEDIA_PARAMS;
		adm_params->params.param_size =
		sizeof(struct srs_trumedia_params_GLOBAL);
		glb_params = (struct srs_trumedia_params_GLOBAL *)
		@@ -419,12 +420,6 @@ int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		sizeof(struct adm_cmd_set_pp_params_inband_v5));
		memcpy(glb_params, srs_params,
		sizeof(struct srs_trumedia_params_GLOBAL));
		pr_debug("SRS - %s: Global params - 1 = %x, 2 = %x, 3 = %x, 4 = %x, 5 = %x, 6 = %x, 7 = %x, 8 = %x\n",
		__func__, (int)glb_params->v1,
		(int)glb_params->v2, (int)glb_params->v3,
		(int)glb_params->v4, (int)glb_params->v5,
		(int)glb_params->v6, (int)glb_params->v7,
		(int)glb_params->v8);
		break;
		}
		case SRS_ID_WOWHD: {
		@@ -440,7 +435,7 @@ int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		adm_params->payload_size =
		sizeof(struct srs_trumedia_params_WOWHD) +
		sizeof(struct adm_param_data_v5);
		adm_params->params.param_id = SRS_TRUMEDIA_PARAMS_WOWHD;
		param_id = SRS_TRUMEDIA_PARAMS_WOWHD;
		adm_params->params.param_size =
		sizeof(struct srs_trumedia_params_WOWHD);
		whd_params = (struct srs_trumedia_params_WOWHD *)
		@@ -448,13 +443,6 @@ int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		sizeof(struct adm_cmd_set_pp_params_inband_v5));
		memcpy(whd_params, srs_params,
		sizeof(struct srs_trumedia_params_WOWHD));
		pr_debug("SRS - %s: WOWHD params - 1 = %x, 2 = %x, 3 = %x, 4 = %x, 5 = %x, 6 = %x, 7 = %x, 8 = %x, 9 = %x, 10 = %x, 11 = %x\n",
		__func__, (int)whd_params->v1,
		(int)whd_params->v2, (int)whd_params->v3,
		(int)whd_params->v4, (int)whd_params->v5,
		(int)whd_params->v6, (int)whd_params->v7,
		(int)whd_params->v8, (int)whd_params->v9,
		(int)whd_params->v10, (int)whd_params->v11);
		break;
		}
		case SRS_ID_CSHP: {
		@@ -470,7 +458,7 @@ int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		adm_params->payload_size =
		sizeof(struct srs_trumedia_params_CSHP) +
		sizeof(struct adm_param_data_v5);
		adm_params->params.param_id = SRS_TRUMEDIA_PARAMS_CSHP;
		param_id = SRS_TRUMEDIA_PARAMS_CSHP;
		adm_params->params.param_size =
		sizeof(struct srs_trumedia_params_CSHP);
		chp_params = (struct srs_trumedia_params_CSHP *)
		@@ -478,12 +466,6 @@ int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		sizeof(struct adm_cmd_set_pp_params_inband_v5));
		memcpy(chp_params, srs_params,
		sizeof(struct srs_trumedia_params_CSHP));
		pr_debug("SRS - %s: CSHP params - 1 = %x, 2 = %x, 3 = %x, 4 = %x, 5 = %x, 6 = %x, 7 = %x, 8 = %x, 9 = %x\n",
		__func__, (int)chp_params->v1,
		(int)chp_params->v2, (int)chp_params->v3,
		(int)chp_params->v4, (int)chp_params->v5,
		(int)chp_params->v6, (int)chp_params->v7,
		(int)chp_params->v8, (int)chp_params->v9);
		break;
		}
		case SRS_ID_HPF: {
		@@ -499,7 +481,7 @@ int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		adm_params->payload_size =
		sizeof(struct srs_trumedia_params_HPF) +
		sizeof(struct adm_param_data_v5);
		adm_params->params.param_id = SRS_TRUMEDIA_PARAMS_HPF;
		param_id = SRS_TRUMEDIA_PARAMS_HPF;
		adm_params->params.param_size =
		sizeof(struct srs_trumedia_params_HPF);
		hpf_params = (struct srs_trumedia_params_HPF *)
		@@ -507,35 +489,35 @@ int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		sizeof(struct adm_cmd_set_pp_params_inband_v5));
		memcpy(hpf_params, srs_params,
		sizeof(struct srs_trumedia_params_HPF));
		pr_debug("SRS - %s: HPF params - 1 = %x\n", __func__,
		(int)hpf_params->v1);
		break;
		}
		case SRS_ID_PEQ: {
		struct srs_trumedia_params_PEQ *peq_params = NULL;
		sz = sizeof(struct adm_cmd_set_pp_params_inband_v5) +
		sizeof(struct srs_trumedia_params_PEQ);
		adm_params = kzalloc(sz, GFP_KERNEL);
		if (!adm_params) {
		case SRS_ID_AEQ: {
		int update_params_ptr = (int )this_adm.outband_memmap.kvaddr;
		outband = 1;
		adm_params = kzalloc(sizeof(struct adm_cmd_set_pp_params_v5),
		GFP_KERNEL);
		adm_params_ = (struct adm_cmd_set_pp_params_v5 *)adm_params;
		if (!adm_params_) {
		pr_err("%s, adm params memory alloc failed\n",
		__func__);
		return -ENOMEM;
		}
		adm_params->payload_size =
		sizeof(struct srs_trumedia_params_PEQ) +
		sizeof(struct adm_param_data_v5);
		adm_params->params.param_id = SRS_TRUMEDIA_PARAMS_PEQ;
		adm_params->params.param_size =
		sizeof(struct srs_trumedia_params_PEQ);
		peq_params = (struct srs_trumedia_params_PEQ *)
		((u8 *)adm_params +
		sizeof(struct adm_cmd_set_pp_params_inband_v5));
		memcpy(peq_params, srs_params,
		sizeof(struct srs_trumedia_params_PEQ));
		pr_debug("SRS - %s: PEQ params - 1 = %x 2 = %x, 3 = %x, 4 = %x\n",
		__func__, (int)peq_params->v1,
		(int)peq_params->v2, (int)peq_params->v3,
		(int)peq_params->v4);

		sz = sizeof(struct srs_trumedia_params_AEQ);
		if (update_params_ptr == NULL) {
		pr_err("ADM_SRS_TRUMEDIA - %s: null memmap for AEQ params\n",
		__func__);
		ret = -EINVAL;
		goto fail_cmd;
		}
		param_id = SRS_TRUMEDIA_PARAMS_AEQ;
		*update_params_ptr++ = module_id;
		*update_params_ptr++ = param_id;
		*update_params_ptr++ = sz;
		memcpy(update_params_ptr, srs_params, sz);

		adm_params_->payload_size = sz + 12;

		break;
		}
		case SRS_ID_HL: {
		@@ -551,7 +533,7 @@ int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		adm_params->payload_size =
		sizeof(struct srs_trumedia_params_HL) +
		sizeof(struct adm_param_data_v5);
		adm_params->params.param_id = SRS_TRUMEDIA_PARAMS_HL;
		param_id = SRS_TRUMEDIA_PARAMS_HL;
		adm_params->params.param_size =
		sizeof(struct srs_trumedia_params_HL);
		hl_params = (struct srs_trumedia_params_HL *)
		@@ -559,11 +541,30 @@ int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		sizeof(struct adm_cmd_set_pp_params_inband_v5));
		memcpy(hl_params, srs_params,
		sizeof(struct srs_trumedia_params_HL));
		pr_debug("SRS - %s: HL params - 1 = %x, 2 = %x, 3 = %x, 4 = %x, 5 = %x, 6 = %x, 7 = %x\n",
		__func__, (int)hl_params->v1,
		(int)hl_params->v2, (int)hl_params->v3,
		(int)hl_params->v4, (int)hl_params->v5,
		(int)hl_params->v6, (int)hl_params->v7);
		break;
		}
		case SRS_ID_GEQ: {
		struct srs_trumedia_params_GEQ *geq_params = NULL;
		sz = sizeof(struct adm_cmd_set_pp_params_inband_v5) +
		sizeof(struct srs_trumedia_params_GEQ);
		adm_params = kzalloc(sz, GFP_KERNEL);
		if (!adm_params) {
		pr_err("%s, adm params memory alloc failed\n",
		__func__);
		return -ENOMEM;
		}
		adm_params->payload_size =
		sizeof(struct srs_trumedia_params_GEQ) +
		sizeof(struct adm_param_data_v5);
		param_id = SRS_TRUMEDIA_PARAMS_GEQ;
		adm_params->params.param_size =
		sizeof(struct srs_trumedia_params_GEQ);
		geq_params = (struct srs_trumedia_params_GEQ *)
		((u8 *)adm_params +
		sizeof(struct adm_cmd_set_pp_params_inband_v5));
		memcpy(geq_params, srs_params,
		sizeof(struct srs_trumedia_params_GEQ));
		pr_debug("SRS - %s: GEQ params prepared\n", __func__);
		break;
		}
		default:
		@@ -572,7 +573,6 @@ int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,

		adm_params->hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
		APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER);
		adm_params->hdr.pkt_size = sz;
		adm_params->hdr.src_svc = APR_SVC_ADM;
		adm_params->hdr.src_domain = APR_DOMAIN_APPS;
		adm_params->hdr.src_port = port_id;
		@@ -582,27 +582,41 @@ int srs_trumedia_open(int port_id, int copp_idx, int srs_tech_id,
		atomic_read(&this_adm.copp.id[port_idx][copp_idx]);
		adm_params->hdr.token = port_idx << 16 \| copp_idx;
		adm_params->hdr.opcode = ADM_CMD_SET_PP_PARAMS_V5;
		if (outband && this_adm.outband_memmap.paddr) {
		adm_params->hdr.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE, sizeof(
		struct adm_cmd_set_pp_params_v5));
		adm_params->payload_addr_lsw = lower_32_bits(
		this_adm.outband_memmap.paddr);
		adm_params->payload_addr_msw = upper_32_bits(
		this_adm.outband_memmap.paddr);
		adm_params->mem_map_handle = atomic_read(&this_adm.
		mem_map_cal_handles[ADM_SRS_TRUMEDIA]);
		} else {
		adm_params->hdr.pkt_size = sz;
		adm_params->payload_addr_lsw = 0;
		adm_params->payload_addr_msw = 0;
		adm_params->mem_map_handle = 0;

		adm_params->params.module_id = SRS_TRUMEDIA_MODULE_ID;
		adm_params->params.module_id = module_id;
		adm_params->params.param_id = param_id;
		adm_params->params.reserved = 0;
		}

		pr_debug("SRS - %s: Command was sent now check Q6 - port id = %d, size %d, module id %x, param id %x.\n",
		__func__, adm_params->hdr.dest_port,
		adm_params->payload_size, adm_params->params.module_id,
		adm_params->params.param_id);
		adm_params->payload_size, module_id, param_id);

		atomic_set(&this_adm.copp.stat[port_idx][copp_idx], 0);
		ret = apr_send_pkt(this_adm.apr, (uint32_t *)adm_params);
		if (ret < 0) {
		pr_err("SRS - %s: ADM enable for port %d failed %d\n",
		__func__, port_id, ret);
		pr_err("SRS - %s: ADM enable for port %d failed\n", __func__,
		port_id);
		ret = -EINVAL;
		goto fail_cmd;
		}
		/* Wait for the callback with copp id */
		ret = wait_event_timeout(this_adm.copp.wait[port_idx][copp_idx], 1,
		ret = wait_event_timeout(this_adm.copp.wait[port_idx][copp_idx],
		atomic_read(&this_adm.copp.stat[port_idx][copp_idx]),
		msecs_to_jiffies(TIMEOUT_MS));
		if (!ret) {
		pr_err("%s: SRS set params timed out port = %d\n",
		@@ -1865,7 +1879,6 @@ int adm_open(int port_id, int path, int rate, int channel_mode, int topology,
		if (res < 0)
		pr_err("%s: DTS_EAGLE mmap did not work!", __func__);
		}

		if (this_adm.copp.adm_delay[port_idx][copp_idx] &&
		perf_mode == LEGACY_PCM_MODE) {
		atomic_set(&this_adm.copp.adm_delay_stat[port_idx][copp_idx],
		@@ -1878,6 +1891,20 @@ int adm_open(int port_id, int path, int rate, int channel_mode, int topology,
		if (atomic_read(&this_adm.copp.cnt[port_idx][copp_idx]) == 0) {
		pr_debug("%s: open ADM: port_idx: %d, copp_idx: %d\n", __func__,
		port_idx, copp_idx);
		if ((topology == SRS_TRUMEDIA_TOPOLOGY_ID) &&
		perf_mode == LEGACY_PCM_MODE) {
		int res;
		atomic_set(&this_adm.mem_map_cal_index, ADM_SRS_TRUMEDIA);
		msm_dts_srs_tm_ion_memmap(&this_adm.outband_memmap);
		res = adm_memory_map_regions(&this_adm.outband_memmap.paddr, 0,
		(uint32_t *)&this_adm.outband_memmap.size, 1);
		if (res < 0) {
		pr_err("%s: SRS adm_memory_map_regions failed ! addr = 0x%p, size = %d\n",
		__func__, (void *)this_adm.outband_memmap.paddr,
		(uint32_t)this_adm.outband_memmap.size);
		}
		}

		open.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
		APR_HDR_LEN(APR_HDR_SIZE),
		APR_PKT_VER);
		@@ -2157,6 +2184,20 @@ int adm_close(int port_id, int perf_mode, int copp_idx)
		copp_id = adm_get_copp_id(port_idx, copp_idx);
		pr_debug("%s: Closing ADM port_idx:%d copp_idx:%d copp_id:0x%x\n",
		__func__, port_idx, copp_idx, copp_id);
		if ((!perf_mode) && (this_adm.outband_memmap.paddr != 0) &&
		(atomic_read(&this_adm.copp.topology[port_idx][copp_idx]) ==
		SRS_TRUMEDIA_TOPOLOGY_ID)) {
		atomic_set(&this_adm.mem_map_cal_index,
		ADM_SRS_TRUMEDIA);
		ret = adm_memory_unmap_regions();
		if (ret < 0) {
		pr_err("%s: adm mem unmmap err %d",
		__func__, ret);
		} else {
		atomic_set(&this_adm.mem_map_cal_handles
		[ADM_SRS_TRUMEDIA], 0);
		}
		}

		if ((!perf_mode) && (this_adm.outband_memmap.paddr != 0)) {
		atomic_set(&this_adm.mem_map_cal_index, ADM_DTS_EAGLE);