Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit caeb66d1 authored by Alexy Joseph's avatar Alexy Joseph
Browse files

ASoC: msm: DTS: integrate DTS TM changes for version 3.1.2.0 



Integrate the kernel changes shared by DTS  for the
latest DTS TM release 3.1.2.0. Include DTS_SRS_TM
config for 8994 target to build the feature.

Change-Id: I8d8e28486abac8e40741d7fee98d99dadaf12745
Signed-off-by: default avatarSharad Sangle <assangle@codeaurora.org>
Signed-off-by: default avatarAlexy Joseph <alexyj@codeaurora.org>
parent 04b23645

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);