From 5c026fcbfe5594db6aebe01a215a00a0c09f2979 Mon Sep 17 00:00:00 2001
From: abhikran <abhikran@codeaurora.org>
Date: Wed, 6 Feb 2019 15:02:13 +0530
Subject: [PATCH] msm: cvp: Enable DFS and DME features on CVP

Add support to enable DFS (depth from stereo) and DME
(descriptor motion estimate) features of CVP (computer
vision processor) on Kona.

Change-Id: Id8613c396bcfbecb8c39ddc3f0d64c2f6b85d57f
Signed-off-by: abhikran <abhikran@codeaurora.org>
Signed-off-by: George Shen <sqiao@codeaurora.org>
---
 drivers/media/platform/msm/cvp/cvp_hfi.c      | 395 ++++++-----
 drivers/media/platform/msm/cvp/cvp_hfi.h      |  92 ++-
 drivers/media/platform/msm/cvp/cvp_hfi_api.h  | 110 ++-
 .../media/platform/msm/cvp/cvp_hfi_helper.h   |  82 ++-
 .../platform/msm/cvp/hfi_packetization.c      | 322 ++++-----
 .../platform/msm/cvp/hfi_packetization.h      |  28 +-
 .../platform/msm/cvp/hfi_response_handler.c   | 154 ++--
 drivers/media/platform/msm/cvp/msm_cvp.c      | 659 +++++++++---------
 drivers/media/platform/msm/cvp/msm_cvp.h      |   4 -
 .../media/platform/msm/cvp/msm_cvp_common.c   |  21 +-
 .../media/platform/msm/cvp/msm_cvp_internal.h |   6 -
 .../media/platform/msm/cvp/msm_cvp_platform.c |   2 +-
 .../platform/msm/cvp/msm_cvp_res_parse.c      |  11 +-
 drivers/media/platform/msm/cvp/msm_v4l2_cvp.c |   5 +-
 .../media/platform/msm/cvp/msm_v4l2_private.c | 255 ++++---
 include/uapi/media/msm_cvp_private.h          | 132 ++--
 16 files changed, 1185 insertions(+), 1093 deletions(-)

diff --git a/drivers/media/platform/msm/cvp/cvp_hfi.c b/drivers/media/platform/msm/cvp/cvp_hfi.c
index 39cb5b3df9bd..34e836afb5b8 100644
--- a/drivers/media/platform/msm/cvp/cvp_hfi.c
+++ b/drivers/media/platform/msm/cvp/cvp_hfi.c
@@ -249,17 +249,6 @@ static void __sim_modify_cmd_packet(u8 *packet, struct venus_hfi_device *device)
 		}
 		break;
 	}
-	case HFI_CMD_SESSION_REGISTER_BUFFERS:
-	{
-		struct hfi_cmd_session_register_buffers_packet *pkt =
-			(struct hfi_cmd_session_register_buffers_packet *)
-			packet;
-		struct hfi_buffer_mapping_type *buf =
-			(struct hfi_buffer_mapping_type *)pkt->buffer;
-		for (i = 0; i < pkt->num_buffers; i++)
-			buf[i].device_addr -= fw_bias;
-		break;
-	}
 	default:
 		break;
 	}
@@ -2602,76 +2591,6 @@ err_create_pkt:
 	return rc;
 }
 
-static int venus_hfi_session_register_buffer(void *sess,
-		struct cvp_register_buffer *buffer)
-{
-	int rc = 0;
-	u8 packet[CVP_IFACEQ_VAR_LARGE_PKT_SIZE];
-	struct hfi_cmd_session_register_buffers_packet *pkt;
-	struct hal_session *session = sess;
-	struct venus_hfi_device *device;
-
-	if (!session || !session->device || !buffer) {
-		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
-		return -EINVAL;
-	}
-	device = session->device;
-
-	mutex_lock(&device->lock);
-	if (!__is_session_valid(device, session, __func__)) {
-		rc = -EINVAL;
-		goto exit;
-	}
-	pkt = (struct hfi_cmd_session_register_buffers_packet *)packet;
-	rc = call_hfi_pkt_op(device, session_register_buffer, pkt,
-			session, buffer);
-	if (rc) {
-		dprintk(CVP_ERR, "%s: failed to create packet\n", __func__);
-		goto exit;
-	}
-	if (__iface_cmdq_write(session->device, pkt))
-		rc = -ENOTEMPTY;
-exit:
-	mutex_unlock(&device->lock);
-
-	return rc;
-}
-
-static int venus_hfi_session_unregister_buffer(void *sess,
-		struct cvp_unregister_buffer *buffer)
-{
-	int rc = 0;
-	u8 packet[CVP_IFACEQ_VAR_LARGE_PKT_SIZE];
-	struct hfi_cmd_session_unregister_buffers_packet *pkt;
-	struct hal_session *session = sess;
-	struct venus_hfi_device *device;
-
-	if (!session || !session->device || !buffer) {
-		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
-		return -EINVAL;
-	}
-	device = session->device;
-
-	mutex_lock(&device->lock);
-	if (!__is_session_valid(device, session, __func__)) {
-		rc = -EINVAL;
-		goto exit;
-	}
-	pkt = (struct hfi_cmd_session_unregister_buffers_packet *)packet;
-	rc = call_hfi_pkt_op(device, session_unregister_buffer, pkt,
-			session, buffer);
-	if (rc) {
-		dprintk(CVP_ERR, "%s: failed to create packet\n", __func__);
-		goto exit;
-	}
-	if (__iface_cmdq_write(session->device, pkt))
-		rc = -ENOTEMPTY;
-exit:
-	mutex_unlock(&device->lock);
-
-	return rc;
-}
-
 static int venus_hfi_session_start(void *session)
 {
 	dprintk(CVP_ERR, "Deprecated function %s\n", __func__);
@@ -2720,11 +2639,121 @@ static int venus_hfi_session_stop(void *session)
 	return rc;
 }
 
-static int venus_hfi_session_cvp_dfs_config(void *sess,
-		struct msm_cvp_dfsconfig *dfs_config)
+static int venus_hfi_session_cvp_dme_config(void *sess,
+		struct msm_cvp_internal_dmeconfig *dme_config)
 {
 	int rc = 0;
-	struct hfi_cmd_session_cvp_dfs_config pkt;
+	struct hfi_cmd_session_cvp_dme_config_packet pkt;
+	struct hal_session *session = sess;
+	struct venus_hfi_device *device;
+
+	if (!session || !session->device) {
+		dprintk(CVP_ERR, "invalid session");
+		return -ENODEV;
+	}
+
+	device = session->device;
+	mutex_lock(&device->lock);
+
+	if (!__is_session_valid(device, session, __func__)) {
+		rc = -EINVAL;
+		goto dme_config_err;
+	}
+	rc = call_hfi_pkt_op(device, session_cvp_dme_config,
+			&pkt, session, dme_config);
+	if (rc) {
+		dprintk(CVP_ERR,
+				"Session get buf req: failed to create pkt\n");
+		goto dme_config_err;
+	}
+
+	if (__iface_cmdq_write(session->device, &pkt))
+		rc = -ENOTEMPTY;
+	dprintk(CVP_DBG, "%s: calling __iface_cmdq_write\n", __func__);
+dme_config_err:
+	mutex_unlock(&device->lock);
+	return rc;
+}
+
+static int venus_hfi_session_cvp_dme_frame(void *sess,
+				struct msm_cvp_internal_dmeframe *dme_frame)
+{
+	int rc = 0;
+	struct hfi_cmd_session_cvp_dme_frame_packet pkt;
+	struct hal_session *session = sess;
+	struct venus_hfi_device *device;
+
+	if (!session || !session->device) {
+		dprintk(CVP_ERR, "invalid session");
+		return -ENODEV;
+	}
+
+	device = session->device;
+	mutex_lock(&device->lock);
+
+	if (!__is_session_valid(device, session, __func__)) {
+		rc = -EINVAL;
+		goto dme_frame_err;
+	}
+	rc = call_hfi_pkt_op(device, session_cvp_dme_frame,
+			&pkt, session, dme_frame);
+	if (rc) {
+		dprintk(CVP_ERR,
+				"Session get buf req: failed to create pkt\n");
+		goto dme_frame_err;
+	}
+
+	if (__iface_cmdq_write(session->device, &pkt))
+		rc = -ENOTEMPTY;
+	dprintk(CVP_DBG, "%s: done calling __iface_cmdq_write\n", __func__);
+dme_frame_err:
+	mutex_unlock(&device->lock);
+	return rc;
+}
+
+
+static int venus_hfi_session_cvp_persist(void *sess,
+		struct msm_cvp_internal_persist_cmd *pbuf_cmd)
+{
+	int rc = 0;
+	struct hfi_cmd_session_cvp_persist_packet pkt;
+	struct hal_session *session = sess;
+	struct venus_hfi_device *device;
+
+	if (!session || !session->device) {
+		dprintk(CVP_ERR, "invalid session");
+		return -ENODEV;
+	}
+
+	device = session->device;
+	mutex_lock(&device->lock);
+
+	if (!__is_session_valid(device, session, __func__)) {
+		rc = -EINVAL;
+		goto persist_err;
+	}
+	rc = call_hfi_pkt_op(device, session_cvp_persist,
+			&pkt, session, pbuf_cmd);
+	if (rc) {
+		dprintk(CVP_ERR,
+				"Failed to create persist pkt\n");
+		goto persist_err;
+	}
+
+	if (__iface_cmdq_write(session->device, &pkt))
+		rc = -ENOTEMPTY;
+
+	dprintk(CVP_DBG, "%s: done calling __iface_cmdq_write\n", __func__);
+persist_err:
+	mutex_unlock(&device->lock);
+	return rc;
+}
+
+static int venus_hfi_session_cvp_dfs_config(void *sess,
+		struct msm_cvp_internal_dfsconfig *dfs_config)
+{
+	int rc = 0;
+	struct hfi_cmd_session_cvp_dfs_config_packet pkt;
 	struct hal_session *session = sess;
 	struct venus_hfi_device *device;
 
@@ -2760,10 +2789,10 @@ err_create_pkt:
 }
 
 static int venus_hfi_session_cvp_dfs_frame(void *sess,
-				struct msm_cvp_dfsframe *dfs_frame)
+				struct msm_cvp_internal_dfsframe *dfs_frame)
 {
 	int rc = 0;
-	struct hfi_cmd_session_cvp_dfs_frame pkt;
+	struct hfi_cmd_session_cvp_dfs_frame_packet pkt;
 	struct hal_session *session = sess;
 	struct venus_hfi_device *device;
 
@@ -2796,12 +2825,6 @@ err_create_pkt:
 	return rc;
 }
 
-static int venus_hfi_session_cvp_send_cmd(void *sess,
-	struct cvp_frame_data *input_frame)
-{
-	return 0;
-}
-
 static int venus_hfi_session_get_buf_req(void *sess)
 {
 	struct hfi_cmd_session_get_property_packet pkt;
@@ -3205,6 +3228,80 @@ static struct hal_session *__get_session(struct venus_hfi_device *device,
 	return NULL;
 }
 
+#define _INVALID_MSG_ "Unrecognized MSG (%#x) session (%pK), discarding\n"
+#define _INVALID_STATE_ "Ignore responses from %d to %d invalid state\n"
+#define _DEVFREQ_FAIL_ "Failed to add devfreq device bus %s governor %s: %d\n"
+
+static void process_system_msg(struct msm_cvp_cb_info *info,
+		struct venus_hfi_device *device,
+		void *raw_packet)
+{
+	struct cvp_hal_sys_init_done sys_init_done = {0};
+
+	switch (info->response_type) {
+	case HAL_SYS_ERROR:
+		__process_sys_error(device);
+		break;
+	case HAL_SYS_RELEASE_RESOURCE_DONE:
+		dprintk(CVP_DBG, "Received SYS_RELEASE_RESOURCE\n");
+		break;
+	case HAL_SYS_INIT_DONE:
+		dprintk(CVP_DBG, "Received SYS_INIT_DONE\n");
+
+		sys_init_done.capabilities =
+			device->sys_init_capabilities;
+		cvp_hfi_process_sys_init_done_prop_read(
+			(struct hfi_msg_sys_init_done_packet *)
+				raw_packet, &sys_init_done);
+		info->response.cmd.data.sys_init_done = sys_init_done;
+		break;
+	default:
+		break;
+	}
+}
+
+
+static void **get_session_id(struct msm_cvp_cb_info *info)
+{
+	void **session_id = NULL;
+
+	/* For session-related packets, validate session */
+	switch (info->response_type) {
+	case HAL_SESSION_INIT_DONE:
+	case HAL_SESSION_END_DONE:
+	case HAL_SESSION_ABORT_DONE:
+	case HAL_SESSION_STOP_DONE:
+	case HAL_SESSION_FLUSH_DONE:
+	case HAL_SESSION_SET_BUFFER_DONE:
+	case HAL_SESSION_SUSPEND_DONE:
+	case HAL_SESSION_RESUME_DONE:
+	case HAL_SESSION_SET_PROP_DONE:
+	case HAL_SESSION_GET_PROP_DONE:
+	case HAL_SESSION_RELEASE_BUFFER_DONE:
+	case HAL_SESSION_REGISTER_BUFFER_DONE:
+	case HAL_SESSION_UNREGISTER_BUFFER_DONE:
+	case HAL_SESSION_DFS_CONFIG_CMD_DONE:
+	case HAL_SESSION_DME_CONFIG_CMD_DONE:
+	case HAL_SESSION_DFS_FRAME_CMD_DONE:
+	case HAL_SESSION_DME_FRAME_CMD_DONE:
+	case HAL_SESSION_PERSIST_CMD_DONE:
+	case HAL_SESSION_PROPERTY_INFO:
+		session_id = &info->response.cmd.session_id;
+		break;
+	case HAL_SESSION_ERROR:
+		session_id = &info->response.data.session_id;
+		break;
+	case HAL_SESSION_EVENT_CHANGE:
+		session_id = &info->response.event.session_id;
+		break;
+	case HAL_RESPONSE_UNUSED:
+	default:
+		session_id = NULL;
+		break;
+	}
+	return session_id;
+}
+
 static int __response_handler(struct venus_hfi_device *device)
 {
 	struct msm_cvp_cb_info *packets;
@@ -3249,7 +3346,6 @@ static int __response_handler(struct venus_hfi_device *device)
 	while (!__iface_msgq_read(device, raw_packet)) {
 		void **session_id = NULL;
 		struct msm_cvp_cb_info *info = &packets[packet_count++];
-		struct cvp_hal_sys_init_done sys_init_done = {0};
 		int rc = 0;
 
 		rc = cvp_hfi_process_msg_packet(device->device_id,
@@ -3262,59 +3358,9 @@ static int __response_handler(struct venus_hfi_device *device)
 		}
 
 		/* Process the packet types that we're interested in */
-		switch (info->response_type) {
-		case HAL_SYS_ERROR:
-			__process_sys_error(device);
-			break;
-		case HAL_SYS_RELEASE_RESOURCE_DONE:
-			dprintk(CVP_DBG, "Received SYS_RELEASE_RESOURCE\n");
-			break;
-		case HAL_SYS_INIT_DONE:
-			dprintk(CVP_DBG, "Received SYS_INIT_DONE\n");
-
-			sys_init_done.capabilities =
-				device->sys_init_capabilities;
-			cvp_hfi_process_sys_init_done_prop_read(
-				(struct hfi_msg_sys_init_done_packet *)
-					raw_packet, &sys_init_done);
-			info->response.cmd.data.sys_init_done = sys_init_done;
-			break;
-		default:
-			break;
-		}
-
-		/* For session-related packets, validate session */
-		switch (info->response_type) {
-		case HAL_SESSION_INIT_DONE:
-		case HAL_SESSION_END_DONE:
-		case HAL_SESSION_ABORT_DONE:
-		case HAL_SESSION_STOP_DONE:
-		case HAL_SESSION_FLUSH_DONE:
-		case HAL_SESSION_SET_BUFFER_DONE:
-		case HAL_SESSION_SUSPEND_DONE:
-		case HAL_SESSION_RESUME_DONE:
-		case HAL_SESSION_SET_PROP_DONE:
-		case HAL_SESSION_GET_PROP_DONE:
-		case HAL_SESSION_RELEASE_BUFFER_DONE:
-		case HAL_SESSION_REGISTER_BUFFER_DONE:
-		case HAL_SESSION_UNREGISTER_BUFFER_DONE:
-		case HAL_SESSION_DFS_CONFIG_CMD_DONE:
-		case HAL_SESSION_DFS_FRAME_CMD_DONE:
-		case HAL_SESSION_PROPERTY_INFO:
-			session_id = &info->response.cmd.session_id;
-			break;
-		case HAL_SESSION_ERROR:
-			session_id = &info->response.data.session_id;
-			break;
-		case HAL_SESSION_EVENT_CHANGE:
-			session_id = &info->response.event.session_id;
-			break;
-		case HAL_RESPONSE_UNUSED:
-		default:
-			session_id = NULL;
-			break;
-		}
+		process_system_msg(info, device, raw_packet);
 
+		session_id = get_session_id(info);
 		/*
 		 * hfi_process_msg_packet provides a session_id that's a hashed
 		 * value of struct hal_session, we need to coerce the hashed
@@ -3333,8 +3379,7 @@ static int __response_handler(struct venus_hfi_device *device)
 			session = __get_session(device,
 					(u32)(uintptr_t)*session_id);
 			if (!session) {
-				dprintk(CVP_ERR,
-						"Received a packet (%#x) for an unrecognized session (%pK), discarding\n",
+				dprintk(CVP_ERR, _INVALID_MSG_,
 						info->response_type,
 						*session_id);
 				--packet_count;
@@ -3347,7 +3392,7 @@ static int __response_handler(struct venus_hfi_device *device)
 		if (packet_count >= cvp_max_packets &&
 				__get_q_size(device, CVP_IFACEQ_MSGQ_IDX)) {
 			dprintk(CVP_WARN,
-					"Too many packets in message queue to handle at once, deferring read\n");
+				"Too many packets in message queue!\n");
 			break;
 		}
 
@@ -3420,8 +3465,7 @@ err_no_work:
 
 		if (!__core_in_valid_state(device)) {
 			dprintk(CVP_ERR,
-				"Ignore responses from %d to %d as device is in invalid state",
-				(i + 1), num_responses);
+				_INVALID_STATE_, (i + 1), num_responses);
 			break;
 		}
 		dprintk(CVP_DBG, "Processing response %d of %d, type %d\n",
@@ -3732,9 +3776,8 @@ static int __init_bus(struct venus_hfi_device *device)
 				&bus->devfreq_prof, bus->governor, NULL);
 		if (IS_ERR_OR_NULL(bus->devfreq)) {
 			rc = PTR_ERR(bus->devfreq) ?: -EBADHANDLE;
-			dprintk(CVP_ERR,
-					"Failed to add devfreq device for bus %s and governor %s: %d\n",
-					bus->name, bus->governor, rc);
+			dprintk(CVP_ERR, _DEVFREQ_FAIL_,
+				bus->name, bus->governor, rc);
 			bus->devfreq = NULL;
 			goto err_add_dev;
 		}
@@ -3969,16 +4012,30 @@ static int __enable_regulators(struct venus_hfi_device *device)
 	dprintk(CVP_DBG, "Enabling regulators\n");
 
 	venus_hfi_for_each_regulator(device, rinfo) {
-		rc = regulator_enable(rinfo->regulator);
-		if (rc) {
-			dprintk(CVP_ERR,
-					"Failed to enable %s: %d\n",
-					rinfo->name, rc);
-			goto err_reg_enable_failed;
-		}
+		if (rinfo->has_hw_power_collapse) {
+			rc = regulator_set_mode(rinfo->regulator,
+				REGULATOR_MODE_FAST);
+			if (rc) {
+				dprintk(CVP_ERR,
+					"Failed to enable hwctrl%s: %d\n",
+						rinfo->name, rc);
+				goto err_reg_enable_failed;
+			}
+			dprintk(CVP_DBG, "Enabled regulator %s hw ctrl\n",
+					rinfo->name);
 
-		dprintk(CVP_DBG, "Enabled regulator %s\n",
-				rinfo->name);
+		} else {
+			rc = regulator_enable(rinfo->regulator);
+			if (rc) {
+				dprintk(CVP_ERR,
+						"Failed to enable %s: %d\n",
+						rinfo->name, rc);
+				goto err_reg_enable_failed;
+			}
+
+			dprintk(CVP_DBG, "Enabled regulator %s\n",
+					rinfo->name);
+		}
 		c++;
 	}
 
@@ -3997,8 +4054,12 @@ static int __disable_regulators(struct venus_hfi_device *device)
 
 	dprintk(CVP_DBG, "Disabling regulators\n");
 
-	venus_hfi_for_each_regulator_reverse(device, rinfo)
+	venus_hfi_for_each_regulator_reverse(device, rinfo) {
 		__disable_regulator(rinfo, device);
+		if (rinfo->has_hw_power_collapse)
+			regulator_set_mode(rinfo->regulator,
+				REGULATOR_MODE_NORMAL);
+	}
 
 	return 0;
 }
@@ -4085,7 +4146,7 @@ static int __venus_power_on(struct venus_hfi_device *device)
 	rc = __scale_clocks(device);
 	if (rc) {
 		dprintk(CVP_WARN,
-				"Failed to scale clocks, performance might be affected\n");
+			"Failed to scale clocks, perf may regress\n");
 		rc = 0;
 	}
 
@@ -4647,15 +4708,15 @@ static void venus_init_hfi_callbacks(struct hfi_device *hdev)
 	hdev->session_clean = venus_hfi_session_clean;
 	hdev->session_set_buffers = venus_hfi_session_set_buffers;
 	hdev->session_release_buffers = venus_hfi_session_release_buffers;
-	hdev->session_register_buffer = venus_hfi_session_register_buffer;
-	hdev->session_unregister_buffer = venus_hfi_session_unregister_buffer;
 	hdev->session_start = venus_hfi_session_start;
 	hdev->session_continue = venus_hfi_session_continue;
 	hdev->session_stop = venus_hfi_session_stop;
 	hdev->session_get_buf_req = venus_hfi_session_get_buf_req;
 	hdev->session_cvp_dfs_config = venus_hfi_session_cvp_dfs_config;
 	hdev->session_cvp_dfs_frame = venus_hfi_session_cvp_dfs_frame;
-	hdev->session_cvp_send_cmd = venus_hfi_session_cvp_send_cmd;
+	hdev->session_cvp_dme_config = venus_hfi_session_cvp_dme_config;
+	hdev->session_cvp_dme_frame = venus_hfi_session_cvp_dme_frame;
+	hdev->session_cvp_persist = venus_hfi_session_cvp_persist;
 	hdev->session_flush = venus_hfi_session_flush;
 	hdev->session_set_property = venus_hfi_session_set_property;
 	hdev->session_get_property = venus_hfi_session_get_property;
diff --git a/drivers/media/platform/msm/cvp/cvp_hfi.h b/drivers/media/platform/msm/cvp/cvp_hfi.h
index e19532dc6446..8a3de61b780f 100644
--- a/drivers/media/platform/msm/cvp/cvp_hfi.h
+++ b/drivers/media/platform/msm/cvp/cvp_hfi.h
@@ -326,10 +326,6 @@ struct hfi_uncompressed_plane_actual_constraints_info {
 #define HFI_CMD_SESSION_CVP_START	\
 	(HFI_DOMAIN_BASE_CVP + HFI_ARCH_COMMON_OFFSET +	\
 	HFI_CMD_START_OFFSET + 0x1000)
-#define HFI_CMD_SESSION_REGISTER_BUFFERS	\
-	(HFI_CMD_SESSION_CVP_START + 0x0A0)
-#define HFI_CMD_SESSION_UNREGISTER_BUFFERS	\
-	(HFI_CMD_SESSION_CVP_START + 0x0A1)
 
 /* =============BASIC OPERATIONS=================*/
 #define  HFI_CMD_SESSION_CVP_SET_BUFFERS\
@@ -384,6 +380,13 @@ struct hfi_uncompressed_plane_actual_constraints_info {
 #define HFI_CMD_SESSION_CVP_PYS_HCD_CONFIG\
 	(HFI_CMD_SESSION_CVP_START + 0x017)
 
+#define  HFI_CMD_SESSION_CVP_DME_CONFIG\
+	(HFI_CMD_SESSION_CVP_START + 0x039)
+#define  HFI_CMD_SESSION_CVP_DME_FRAME\
+	(HFI_CMD_SESSION_CVP_START + 0x03A)
+
+#define  HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS\
+	(HFI_CMD_SESSION_CVP_START + 0x04D)
 
 #define HFI_MSG_SYS_OX_START			\
 (HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_MSG_START_OFFSET + 0x0000)
@@ -409,10 +412,6 @@ struct hfi_uncompressed_plane_actual_constraints_info {
 #define HFI_MSG_SESSION_CVP_START	\
 	(HFI_DOMAIN_BASE_CVP + HFI_ARCH_COMMON_OFFSET +	\
 	HFI_MSG_START_OFFSET + 0x1000)
-#define HFI_MSG_SESSION_REGISTER_BUFFERS_DONE	\
-	(HFI_MSG_SESSION_CVP_START + 0x0A0)
-#define HFI_MSG_SESSION_UNREGISTER_BUFFERS_DONE	\
-	(HFI_MSG_SESSION_CVP_START + 0x0A1)
 
 /* =================BASIC OPERATIONS=================*/
 #define HFI_MSG_SESSION_CVP_SET_BUFFERS\
@@ -436,7 +435,12 @@ struct hfi_uncompressed_plane_actual_constraints_info {
 #define HFI_MSG_SESSION_CVP_FTEXT\
 	(HFI_MSG_SESSION_CVP_START + 0x00A)
 
-#define HFI_MSG_SESSION_CVP_OPERATION_CONFIG (HFI_MSG_SESSION_CVP_START + 0x010)
+#define HFI_MSG_SESSION_CVP_DME\
+	(HFI_MSG_SESSION_CVP_START + 0x023)
+#define HFI_MSG_SESSION_CVP_OPERATION_CONFIG (HFI_MSG_SESSION_CVP_START + 0x030)
+
+#define  HFI_MSG_SESSION_CVP_SET_PERSIST_BUFFERS\
+	(HFI_MSG_SESSION_CVP_START + 0x034)
 
 #define CVP_IFACEQ_MAX_PKT_SIZE       1024
 #define CVP_IFACEQ_MED_PKT_SIZE       768
@@ -577,36 +581,40 @@ struct HFI_CVP_COLOR_PLANE_INFO {
 	u32 buf_size[HFI_MAX_PLANES];
 };
 
-struct hfi_cmd_session_cvp_dfs_config {
+struct hfi_cmd_session_hdr {
 	u32 size;
 	u32 packet_type;
 	u32 session_id;
-	u32 srcbuffer_format;
-	struct HFI_CVP_COLOR_PLANE_INFO left_plane_info;
-	struct HFI_CVP_COLOR_PLANE_INFO right_plane_info;
-	u32 width;
-	u32 height;
-	u32 occlusionmask_enable;
-	u32 occlusioncost;
-	u32 occlusionbound;
-	u32 occlusionshift;
-	u32 maxdisparity;
-	u32 disparityoffset;
-	u32 medianfilter_enable;
-	u32 occlusionfilling_enable;
-	u32 occlusionmaskdump;
-	struct hfi_cvp_client_data  clientdata;
 };
 
-struct hfi_cmd_session_cvp_dfs_frame {
-	u32 size;
-	u32 packet_type;
-	u32 session_id;
-	u32 left_buffer_index;
-	u32 right_buffer_index;
-	u32 disparitymap_buffer_idx;
-	u32 occlusionmask_buffer_idx;
-	struct hfi_cvp_client_data  clientdata;
+struct hfi_cmd_session_cvp_dfs_config_packet {
+	u32 cvp_internal_dfs_config[CVP_DFS_CONFIG_CMD_SIZE];
+};
+
+struct hfi_cmd_session_cvp_dfs_frame_packet {
+	u32 cvp_dfs_frame[CVP_DFS_FRAME_BUFFERS_OFFSET];
+	u32 left_view_buffer_addr;
+	u32 left_view_buffer_size;
+	u32 right_view_buffer_addr;
+	u32 right_view_buffer_size;
+	u32 disparity_map_buffer_addr;
+	u32 disparity_map_buffer_size;
+	u32 occlusion_mask_buffer_addr;
+	u32 occlusion_mask_buffer_size;
+};
+
+struct hfi_cmd_session_cvp_dme_config_packet {
+	u32 cvp_internal_dme_config[CVP_DME_CONFIG_CMD_SIZE];
+};
+
+struct hfi_cmd_session_cvp_dme_frame_packet {
+	u32 cvp_dme_frame[CVP_DME_FRAME_BUFFERS_OFFSET];
+	struct buf_desc bufs[8];
+};
+
+struct hfi_cmd_session_cvp_persist_packet {
+	u32 cvp_persist_frame[CVP_PERSIST_BUFFERS_OFFSET];
+	struct buf_desc bufs[CVP_PSRSIST_BUF_NUM];
 };
 
 struct hfi_cmd_session_release_buffer_packet {
@@ -814,22 +822,6 @@ struct hfi_msg_session_release_buffers_done_packet {
 	u32 rg_buffer_info[1];
 };
 
-struct hfi_msg_session_register_buffers_done_packet {
-	u32 size;
-	u32 packet_type;
-	u32 session_id;
-	u32 client_data;
-	u32 error_type;
-};
-
-struct hfi_msg_session_unregister_buffers_done_packet {
-	u32 size;
-	u32 packet_type;
-	u32 session_id;
-	u32 client_data;
-	u32 error_type;
-};
-
 struct hfi_extradata_mb_quantization_payload {
 	u8 rg_mb_qp[1];
 };
diff --git a/drivers/media/platform/msm/cvp/cvp_hfi_api.h b/drivers/media/platform/msm/cvp/cvp_hfi_api.h
index 1e3ef88b7163..dae783a2e7e3 100644
--- a/drivers/media/platform/msm/cvp/cvp_hfi_api.h
+++ b/drivers/media/platform/msm/cvp/cvp_hfi_api.h
@@ -904,24 +904,6 @@ struct cvp_resource_hdr {
 	void *resource_handle;
 };
 
-struct cvp_register_buffer {
-	enum hal_buffer type;
-	u32 index;
-	u32 size;
-	u32 device_addr;
-	u32 response_required;
-	u32 client_data;
-};
-
-struct cvp_unregister_buffer {
-	enum hal_buffer type;
-	u32 index;
-	u32 size;
-	u32 device_addr;
-	u32 response_required;
-	u32 client_data;
-};
-
 struct cvp_buffer_addr_info {
 	enum hal_buffer buffer_type;
 	u32 buffer_size;
@@ -1118,7 +1100,6 @@ enum hal_command_response {
 	HAL_SESSION_ABORT_DONE,
 	HAL_SESSION_STOP_DONE,
 	HAL_SESSION_CVP_OPERATION_CONFIG,
-	HAL_SESSION_CVP_DFS,
 	HAL_SESSION_FLUSH_DONE,
 	HAL_SESSION_SUSPEND_DONE,
 	HAL_SESSION_RESUME_DONE,
@@ -1130,6 +1111,9 @@ enum hal_command_response {
 	HAL_SESSION_RELEASE_RESOURCE_DONE,
 	HAL_SESSION_DFS_CONFIG_CMD_DONE,
 	HAL_SESSION_DFS_FRAME_CMD_DONE,
+	HAL_SESSION_DME_CONFIG_CMD_DONE,
+	HAL_SESSION_DME_FRAME_CMD_DONE,
+	HAL_SESSION_PERSIST_CMD_DONE,
 	HAL_SESSION_PROPERTY_INFO,
 	HAL_SESSION_ERROR,
 	HAL_RESPONSE_UNUSED = 0x10000000,
@@ -1278,8 +1262,6 @@ struct msm_cvp_cb_cmd_done {
 		struct cvp_hal_sys_init_done sys_init_done;
 		struct cvp_hal_session_init_done session_init_done;
 		struct hal_buffer_info buffer_info;
-		struct cvp_register_buffer regbuf;
-		struct cvp_unregister_buffer unregbuf;
 		union hal_get_property property;
 		enum hal_flush flush_type;
 	} data;
@@ -1428,6 +1410,76 @@ struct hal_vbv_hdr_buf_size {
 #define call_hfi_op(q, op, args...)			\
 	(((q) && (q)->op) ? ((q)->op(args)) : 0)
 
+/* DFS related structures */
+struct msm_cvp_internal_dfsconfig {
+	struct list_head list;
+	struct msm_smem smem;
+	struct msm_cvp_dfs_config dfs_config;
+};
+
+struct	buf_desc {
+	u32 fd;
+	u32 size;
+};
+
+/**
+ * struct msm_cvp_dfs_frame_kmd - argument passed with VIDIOC_CVP_CMD
+ * @cvp_dfs_frame:                parameters for DFS frame command
+ * @left_view_buffer_fd:          fd for left view buffer
+ * @left_view_buffer_size:        size for left view buffer
+ * @right_view_buffer_fd:         fd for right view buffer
+ * @right_view_buffer_size:       size for right view buffer
+ * @disparity_map_buffer_fd:      fd for disparity map buffer
+ * @disparity_map_buffer_size:    size for disparity map buffer
+ * @occlusion_mask_buffer_fd:     fd for occlusion mask buffer
+ * @occlusion_mask_buffer_size:   size for occlusion mask buffer
+ */
+
+struct msm_cvp_dfs_frame_kmd {
+	unsigned int cvp_dfs_frame[CVP_DFS_FRAME_BUFFERS_OFFSET];
+	unsigned int left_view_buffer_fd;
+	unsigned int left_view_buffer_size;
+	unsigned int right_view_buffer_fd;
+	unsigned int right_view_buffer_size;
+	unsigned int disparity_map_buffer_fd;
+	unsigned int disparity_map_buffer_size;
+	unsigned int occlusion_mask_buffer_fd;
+	unsigned int occlusion_mask_buffer_size;
+};
+
+
+struct msm_cvp_internal_dfsframe {
+	struct list_head list;
+	struct msm_cvp_dfs_frame_kmd dfs_frame;
+};
+
+/* DME related structures */
+struct msm_cvp_internal_dmeconfig {
+	struct list_head list;
+	struct msm_smem smem;
+	struct msm_cvp_dme_config dme_config;
+};
+
+struct msm_cvp_dme_frame_kmd {
+	unsigned int cvp_dme_frame[CVP_DME_FRAME_BUFFERS_OFFSET];
+	struct buf_desc bufs[CVP_DME_BUF_NUM];
+};
+
+struct msm_cvp_internal_dmeframe {
+	struct list_head list;
+	struct msm_cvp_dme_frame_kmd dme_frame;
+};
+
+struct msm_cvp_persist_kmd {
+	unsigned int cvp_pcmd[CVP_PERSIST_BUFFERS_OFFSET];
+	struct buf_desc bufs[CVP_PSRSIST_BUF_NUM];
+};
+
+struct msm_cvp_internal_persist_cmd {
+	struct list_head list;
+	struct msm_cvp_persist_kmd persist_cmd;
+};
+
 struct hfi_device {
 	void *hfi_device_data;
 
@@ -1445,10 +1497,6 @@ struct hfi_device {
 				struct cvp_buffer_addr_info *buffer_info);
 	int (*session_release_buffers)(void *sess,
 				struct cvp_buffer_addr_info *buffer_info);
-	int (*session_register_buffer)(void *sess,
-				struct cvp_register_buffer *buffer);
-	int (*session_unregister_buffer)(void *sess,
-				struct cvp_unregister_buffer *buffer);
 	int (*session_load_res)(void *sess);
 	int (*session_release_res)(void *sess);
 	int (*session_start)(void *sess);
@@ -1457,11 +1505,15 @@ struct hfi_device {
 	int (*session_cvp_operation_config)(void *sess,
 		struct cvp_frame_data *input_frame);
 	int (*session_cvp_dfs_config)(void *sess,
-		struct msm_cvp_dfsconfig *dfs_config);
+		struct msm_cvp_internal_dfsconfig *dfs_config);
 	int (*session_cvp_dfs_frame)(void *sess,
-		struct msm_cvp_dfsframe *dfs_frame);
-	int (*session_cvp_send_cmd)(void *sess,
-		struct cvp_frame_data *input_frame);
+		struct msm_cvp_internal_dfsframe *dfs_frame);
+	int (*session_cvp_dme_config)(void *sess,
+		struct msm_cvp_internal_dmeconfig *dme_config);
+	int (*session_cvp_dme_frame)(void *sess,
+		struct msm_cvp_internal_dmeframe *dme_frame);
+	int (*session_cvp_persist)(void *sess,
+		struct msm_cvp_internal_persist_cmd *pbuf_cmd);
 	int (*session_get_buf_req)(void *sess);
 	int (*session_flush)(void *sess, enum hal_flush flush_mode);
 	int (*session_set_property)(void *sess, enum hal_property ptype,
diff --git a/drivers/media/platform/msm/cvp/cvp_hfi_helper.h b/drivers/media/platform/msm/cvp/cvp_hfi_helper.h
index f43be676d238..681ef009a4ca 100644
--- a/drivers/media/platform/msm/cvp/cvp_hfi_helper.h
+++ b/drivers/media/platform/msm/cvp/cvp_hfi_helper.h
@@ -1036,26 +1036,6 @@ struct hfi_buffer_mapping_type {
 	u32 size;
 };
 
-struct hfi_cmd_session_register_buffers_packet {
-	u32 size;
-	u32 packet_type;
-	u32 session_id;
-	u32 client_data;
-	u32 response_req;
-	u32 num_buffers;
-	struct hfi_buffer_mapping_type buffer[1];
-};
-
-struct hfi_cmd_session_unregister_buffers_packet {
-	u32 size;
-	u32 packet_type;
-	u32 session_id;
-	u32 client_data;
-	u32 response_req;
-	u32 num_buffers;
-	struct hfi_buffer_mapping_type buffer[1];
-};
-
 struct hfi_cmd_session_sync_process_packet {
 	u32 size;
 	u32 packet_type;
@@ -1084,24 +1064,76 @@ struct hfi_msg_session_cvp_operation_config_done_packet_type {
 	u32 size;
 	u32 packet_type;
 	u32 session_id;
+	struct hfi_cvp_client_data  client_data;
 	u32 op_conf_id;
 	u32 error_type;
-	struct hfi_cvp_client_data  client_data;
 };
 
 struct hfi_msg_session_cvp_dfs_packet_type {
 	u32 size;
 	u32 packet_type;
 	u32 session_id;
+	struct hfi_cvp_client_data  client_data;
 	u32 error_type;
-	u32 left_view_buffer_index;
-	u32 right_view_buffer_index;
 	u32 width;
 	u32 height;
 	u32 occlusionmask_enable;
-	u32 disparitymap_buffer_idx;
-	u32 occlusionmask_buffer_idx;
+	u32 left_view_buf_addr;
+	u32 left_view_buf_size;
+	u32 right_view_buf_addr;
+	u32 right_view_buf_size;
+	u32 disparity_map_buf_addr;
+	u32 disparity_map_buf_size;
+	u32 occ_mask_buf_addr;
+	u32 occ_mask_buf_size;
+};
+
+struct hfi_msg_session_cvp_dme_packet_type {
+	u32 size;
+	u32 packet_type;
+	u32 session_id;
 	struct hfi_cvp_client_data  client_data;
+	u32 error_type;
+	u32 skip_mv_calc;
+	u32 src_buf_addr;
+	u32 src_buf_size;
+	u32 nSrcBuffer_size;
+	u32 src_frame_ctx_buf_addr;
+	u32 src_frame_ctx_buf_size;
+	u32 ref_buf_addr;
+	u32 ref_buf_size;
+	u32 ref_frame_ctxt_buf_addr;
+	u32 ref_frame_ctxt_buf_size;
+	u32 video_spatial_temp_status_buf_addr;
+	u32 video_spatial_temp_status_buf_size;
+	u32 full_res_height;
+	u32 full_res_width;
+	u32 proc_frame_width;
+	u32 proc_frame_height;
+	u32 transform_confidence;
+	u32 frame_sum_gradient;
+	u32 frame_sum_square_gradient1;
+	u32 frame_sum_square_gradient2;
+	u16 n_luma_hist[8];
+	s32 mvx_sum;
+	s32 mvy_Sum;
+	u32 num_mvs;
+	s32 final_transform[9];
+	s32 pad;
+	s64 transform[9];
+};
+
+struct hfi_msg_session_cvp_persist_packet_type {
+	u32 size;
+	u32 packet_type;
+	u32 session_id;
+	struct hfi_cvp_client_data  client_data;
+	u32 error_type;
+	u32 cvp_op;
+	u32 persist1_buffer_fd;
+	u32 persist1_size;
+	u32 persist2_fd;
+	u32 persist2_size;
 };
 
 struct hfi_msg_release_buffer_ref_event_packet {
diff --git a/drivers/media/platform/msm/cvp/hfi_packetization.c b/drivers/media/platform/msm/cvp/hfi_packetization.c
index e675f8a2c215..f944c2bb6a48 100644
--- a/drivers/media/platform/msm/cvp/hfi_packetization.c
+++ b/drivers/media/platform/msm/cvp/hfi_packetization.c
@@ -673,72 +673,6 @@ int cvp_create_pkt_cmd_session_release_buffers(
 	return 0;
 }
 
-int cvp_create_pkt_cmd_session_register_buffer(
-		struct hfi_cmd_session_register_buffers_packet *pkt,
-		struct hal_session *session,
-		struct cvp_register_buffer *buffer)
-{
-	int rc = 0, i;
-	struct hfi_buffer_mapping_type *buf;
-
-	if (!pkt || !session) {
-		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
-		return -EINVAL;
-	}
-
-	pkt->packet_type = HFI_CMD_SESSION_REGISTER_BUFFERS;
-	pkt->session_id = hash32_ptr(session);
-	pkt->client_data = buffer->client_data;
-	pkt->response_req = buffer->response_required;
-	pkt->num_buffers = 1;
-	pkt->size = sizeof(struct hfi_cmd_session_register_buffers_packet) -
-			sizeof(u32) + (pkt->num_buffers *
-			sizeof(struct hfi_buffer_mapping_type));
-
-	buf = (struct hfi_buffer_mapping_type *)pkt->buffer;
-	for (i = 0; i < pkt->num_buffers; i++) {
-		buf->index = buffer->index;
-		buf->device_addr = buffer->device_addr;
-		buf->size = buffer->size;
-		buf++;
-	}
-
-	return rc;
-}
-
-int cvp_create_pkt_cmd_session_unregister_buffer(
-		struct hfi_cmd_session_unregister_buffers_packet *pkt,
-		struct hal_session *session,
-		struct cvp_unregister_buffer *buffer)
-{
-	int rc = 0, i;
-	struct hfi_buffer_mapping_type *buf;
-
-	if (!pkt || !session) {
-		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
-		return -EINVAL;
-	}
-
-	pkt->packet_type = HFI_CMD_SESSION_UNREGISTER_BUFFERS;
-	pkt->session_id = hash32_ptr(session);
-	pkt->client_data = buffer->client_data;
-	pkt->response_req = buffer->response_required;
-	pkt->num_buffers = 1;
-	pkt->size = sizeof(struct hfi_cmd_session_unregister_buffers_packet) -
-			sizeof(u32) + (pkt->num_buffers *
-			sizeof(struct hfi_buffer_mapping_type));
-
-	buf = (struct hfi_buffer_mapping_type *)pkt->buffer;
-	for (i = 0; i < pkt->num_buffers; i++) {
-		buf->index = buffer->index;
-		buf->device_addr = buffer->device_addr;
-		buf->size = buffer->size;
-		buf++;
-	}
-
-	return rc;
-}
-
 int cvp_create_pkt_cmd_session_etb_decoder(
 	struct hfi_cmd_session_empty_buffer_compressed_packet *pkt,
 	struct hal_session *session, struct cvp_frame_data *input_frame)
@@ -865,131 +799,167 @@ int cvp_create_pkt_cmd_session_get_buf_req(
 }
 
 int cvp_create_pkt_cmd_session_cvp_dfs_config(
-		struct hfi_cmd_session_cvp_dfs_config *pkt,
+		struct hfi_cmd_session_cvp_dfs_config_packet *pkt,
 		struct hal_session *session,
-		struct msm_cvp_dfsconfig *dfs_config)
+		struct msm_cvp_internal_dfsconfig *dfs_config)
 {
-	int rc = 0, i = 0;
+	struct hfi_cmd_session_hdr *ptr =
+		(struct hfi_cmd_session_hdr *)pkt;
 
 	if (!pkt || !session)
 		return -EINVAL;
 
-	pkt->size = sizeof(struct hfi_cmd_session_cvp_dfs_config);
-	pkt->packet_type = HFI_CMD_SESSION_CVP_DFS_CONFIG;
-	pkt->session_id = hash32_ptr(session);
-	pkt->srcbuffer_format = dfs_config->srcbuffer_format;
-	for (i = 0; i < HFI_MAX_PLANES; i++) {
-		pkt->left_plane_info.stride[i] =
-			dfs_config->left_plane_info.stride[i];
-		pkt->left_plane_info.buf_size[i] =
-			dfs_config->left_plane_info.buf_size[i];
-		pkt->right_plane_info.stride[i] =
-			dfs_config->right_plane_info.stride[i];
-		pkt->right_plane_info.buf_size[i] =
-			dfs_config->right_plane_info.buf_size[i];
-	}
-	pkt->width = dfs_config->width;
-	pkt->height = dfs_config->height;
-	pkt->occlusionmask_enable = dfs_config->occlusionmask_enable;
-	pkt->occlusioncost = dfs_config->occlusioncost;
-	pkt->occlusionbound = dfs_config->occlusionbound;
-	pkt->occlusionshift = dfs_config->occlusionshift;
-	pkt->maxdisparity = dfs_config->maxdisparity;
-	pkt->disparityoffset = dfs_config->disparityoffset;
-	pkt->medianfilter_enable = dfs_config->medianfilter_enable;
-	pkt->occlusionfilling_enable = dfs_config->occlusionfilling_enable;
-	pkt->occlusionmaskdump = dfs_config->occlusionmaskdump;
-	pkt->clientdata.transactionid =
-		dfs_config->clientdata.transactionid;
-	pkt->clientdata.client_data1  =
-		dfs_config->clientdata.client_data1;
-	pkt->clientdata.client_data2  =
-		dfs_config->clientdata.client_data2;
+	memcpy(pkt, &dfs_config->dfs_config,
+		CVP_DFS_CONFIG_CMD_SIZE*sizeof(unsigned int));
 
-	dprintk(CVP_DBG,
-		"%s: size=%d packet_type=%d session_id=%d height=%d", __func__,
-		pkt->size, pkt->packet_type, pkt->session_id, pkt->height);
-	dprintk(CVP_DBG,
-		"occlusionmask_enable=%d occlusioncost=%d occlusionbound=%d",
-		pkt->occlusionmask_enable, pkt->occlusioncost,
-		pkt->occlusionbound);
-	dprintk(CVP_DBG,
-		"occlusionshift=%d maxdisparity=%d disparityoffset=%d",
-		pkt->occlusionshift, pkt->maxdisparity,
-		pkt->disparityoffset);
-	dprintk(CVP_DBG,
-		"medianfilter_enable=%d occlusionfilling_enable=%d occlusionmaskdump=%d",
-		pkt->medianfilter_enable, pkt->occlusionfilling_enable,
-		pkt->occlusionmaskdump);
-	dprintk(CVP_DBG,
-		"left_plane_info.ActualStride[HFI_COLOR_PLANE_PICDATA]:%u",
-		pkt->left_plane_info.stride[HFI_COLOR_PLANE_PICDATA]
-		);
-	dprintk(CVP_DBG,
-		"LeftViewColPlaneInfo.ActualStride[HFI_COLOR_PLANE_METADATA]:%u",
-		pkt->left_plane_info.stride[HFI_COLOR_PLANE_METADATA]
-		);
-	dprintk(CVP_DBG,
-		"LeftViewColPlaneInfo.ActualBufSize[HFI_COLOR_PLANE_PICDATA]:%u,",
-		pkt->left_plane_info.buf_size[HFI_COLOR_PLANE_PICDATA]
-		);
-	dprintk(CVP_DBG,
-		"LeftViewColPlaneInfo.ActualBufSize[HFI_COLOR_PLANE_METADATA]%u",
-		pkt->left_plane_info.buf_size[HFI_COLOR_PLANE_METADATA]
-		);
-	dprintk(CVP_DBG,
-		"RightViewColPlaneInfo:stride[HFI_COLOR_PLANE_PICDATA]:%u",
-		pkt->right_plane_info.stride[HFI_COLOR_PLANE_PICDATA]
-		);
-	dprintk(CVP_DBG,
-		"RightViewColPlaneInfo.stride[HFI_COLOR_PLANE_METADATA]:%u",
-		pkt->right_plane_info.stride[HFI_COLOR_PLANE_METADATA]
-		);
-	dprintk(CVP_DBG,
-		"RightViewColPlaneInfo.ActualBufSize[HFI_COLOR_PLANE_PICDATA] :%u",
-		pkt->right_plane_info.buf_size[HFI_COLOR_PLANE_PICDATA]
-		);
-	dprintk(CVP_DBG,
-	"RightViewColPlaneInfo.ActualBufSize[HFI_COLOR_PLANE_METADATA] %u",
-	pkt->right_plane_info.buf_size[HFI_COLOR_PLANE_METADATA]
-	);
+	if (ptr->size != CVP_DFS_CONFIG_CMD_SIZE*sizeof(unsigned int))
+		goto error_dfs_config;
 
-	return rc;
+	if (ptr->packet_type != HFI_CMD_SESSION_CVP_DFS_CONFIG)
+		goto error_dfs_config;
+
+	if (ptr->session_id != hash32_ptr(session))
+		goto error_dfs_config;
+
+	return 0;
+
+error_dfs_config:
+	dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",
+		__func__, ptr->size, ptr->packet_type, ptr->session_id);
+
+	return -EINVAL;
 }
 
 
 int cvp_create_pkt_cmd_session_cvp_dfs_frame(
-		struct hfi_cmd_session_cvp_dfs_frame *pkt,
+		struct hfi_cmd_session_cvp_dfs_frame_packet *pkt,
 		struct hal_session *session,
-		struct msm_cvp_dfsframe *dfs_frame)
+		struct msm_cvp_internal_dfsframe *dfs_frame)
 {
-	int rc = 0;
+	struct hfi_cmd_session_hdr *ptr =
+		(struct hfi_cmd_session_hdr *)pkt;
 
 	if (!pkt || !session)
 		return -EINVAL;
 
-	pkt->size = sizeof(struct hfi_cmd_session_cvp_dfs_frame);
-	pkt->packet_type = HFI_CMD_SESSION_CVP_DFS_FRAME;
-	pkt->session_id = hash32_ptr(session);
-	pkt->left_buffer_index = dfs_frame->left_buffer_index;
-	pkt->right_buffer_index = dfs_frame->right_buffer_index;
-	pkt->disparitymap_buffer_idx = dfs_frame->disparitymap_buffer_idx;
-	pkt->occlusionmask_buffer_idx = dfs_frame->occlusionmask_buffer_idx;
-	pkt->clientdata.transactionid = dfs_frame->clientdata.transactionid;
-	pkt->clientdata.client_data1 = dfs_frame->clientdata.client_data1;
+	memcpy(pkt, &dfs_frame->dfs_frame,
+		CVP_DFS_FRAME_CMD_SIZE*sizeof(unsigned int));
 
-	dprintk(CVP_DBG,
-		"%s: size=%d, packet_type=%d session_id=%d left_buffer_index=%d",
-		__func__, pkt->size, pkt->packet_type, pkt->session_id,
-		pkt->left_buffer_index);
-	dprintk(CVP_DBG,
-		"right_buffer_index=%d disparitymap_buffer_idx=%d",
-		pkt->right_buffer_index, pkt->disparitymap_buffer_idx);
-	dprintk(CVP_DBG,
-		"occlusionmask_buffer_idx=%d ",
-			pkt->occlusionmask_buffer_idx);
+	if (ptr->size != CVP_DFS_FRAME_CMD_SIZE*sizeof(unsigned int))
+		goto error_dfs_frame;
+
+	if (ptr->packet_type != HFI_CMD_SESSION_CVP_DFS_FRAME)
+		goto error_dfs_frame;
+
+	if (ptr->session_id != hash32_ptr(session))
+		goto error_dfs_frame;
+
+
+	return 0;
+
+error_dfs_frame:
+	dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",
+		__func__, ptr->size, ptr->packet_type, ptr->session_id);
+
+	return -EINVAL;
+}
+
+int cvp_create_pkt_cmd_session_cvp_dme_config(
+		struct hfi_cmd_session_cvp_dme_config_packet *pkt,
+		struct hal_session *session,
+		struct msm_cvp_internal_dmeconfig *dme_config)
+{
+	struct hfi_cmd_session_hdr *ptr =
+		(struct hfi_cmd_session_hdr *)pkt;
+
+	if (!pkt || !session)
+		return -EINVAL;
+
+	memcpy(pkt, &dme_config->dme_config,
+		CVP_DME_CONFIG_CMD_SIZE*sizeof(unsigned int));
+
+	if (ptr->size != CVP_DME_CONFIG_CMD_SIZE*sizeof(unsigned int))
+		goto error_dme_config;
+
+	if (ptr->packet_type != HFI_CMD_SESSION_CVP_DME_CONFIG)
+		goto error_dme_config;
+
+	if (ptr->session_id != hash32_ptr(session))
+		goto error_dme_config;
+
+	return 0;
+
+error_dme_config:
+	dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",
+		__func__, ptr->size, ptr->packet_type, ptr->session_id);
+
+	return -EINVAL;
+}
+
+
+int cvp_create_pkt_cmd_session_cvp_dme_frame(
+		struct hfi_cmd_session_cvp_dme_frame_packet *pkt,
+		struct hal_session *session,
+		struct msm_cvp_internal_dmeframe *dme_frame)
+{
+	struct hfi_cmd_session_hdr *ptr =
+		(struct hfi_cmd_session_hdr *)pkt;
+
+	if (!pkt || !session)
+		return -EINVAL;
+
+	memcpy(pkt, &dme_frame->dme_frame,
+		CVP_DME_FRAME_CMD_SIZE*sizeof(unsigned int));
+
+	if (ptr->size != CVP_DME_FRAME_CMD_SIZE*sizeof(unsigned int))
+		goto error_dme_frame;
+
+	if (ptr->packet_type != HFI_CMD_SESSION_CVP_DME_FRAME)
+		goto error_dme_frame;
+
+	if (ptr->session_id != hash32_ptr(session))
+		goto error_dme_frame;
+
+	return 0;
+
+error_dme_frame:
+	dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",
+		__func__, ptr->size, ptr->packet_type, ptr->session_id);
+
+	return -EINVAL;
+}
+
+int cvp_create_pckt_cmd_session_cvp_persist(
+		struct hfi_cmd_session_cvp_persist_packet *pkt,
+		struct hal_session *session,
+		struct msm_cvp_internal_persist_cmd *pbuf_cmd)
+{
+	struct hfi_cmd_session_hdr *ptr =
+		(struct hfi_cmd_session_hdr *)pkt;
+
+	if (!pkt || !session)
+		return -EINVAL;
+
+	memcpy(pkt, &pbuf_cmd->persist_cmd,
+		CVP_PERSIST_CMD_SIZE*sizeof(unsigned int));
+
+	if (ptr->size != CVP_PERSIST_CMD_SIZE*sizeof(unsigned int))
+		goto error_persist;
+
+	if (ptr->packet_type != HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS)
+		goto error_persist;
+
+	if (ptr->session_id != hash32_ptr(session))
+		goto error_persist;
+
+	return 0;
+
+error_persist:
+	dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",
+		__func__, ptr->size, ptr->packet_type, ptr->session_id);
+
+	return -EINVAL;
 
-	return rc;
 }
 
 
@@ -2189,10 +2159,6 @@ static struct hfi_packetization_ops hfi_default = {
 		cvp_create_pkt_cmd_session_set_buffers,
 	.session_release_buffers =
 		cvp_create_pkt_cmd_session_release_buffers,
-	.session_register_buffer =
-		cvp_create_pkt_cmd_session_register_buffer,
-	.session_unregister_buffer =
-		cvp_create_pkt_cmd_session_unregister_buffer,
 	.session_etb_decoder = cvp_create_pkt_cmd_session_etb_decoder,
 	.session_etb_encoder = cvp_create_pkt_cmd_session_etb_encoder,
 	.session_ftb = cvp_create_pkt_cmd_session_ftb,
@@ -2204,6 +2170,12 @@ static struct hfi_packetization_ops hfi_default = {
 		cvp_create_pkt_cmd_session_cvp_dfs_config,
 	.session_cvp_dfs_frame =
 		cvp_create_pkt_cmd_session_cvp_dfs_frame,
+	.session_cvp_dme_config =
+		cvp_create_pkt_cmd_session_cvp_dme_config,
+	.session_cvp_dme_frame =
+		cvp_create_pkt_cmd_session_cvp_dme_frame,
+	.session_cvp_persist =
+		cvp_create_pckt_cmd_session_cvp_persist,
 };
 
 struct hfi_packetization_ops *cvp_hfi_get_pkt_ops_handle(
diff --git a/drivers/media/platform/msm/cvp/hfi_packetization.h b/drivers/media/platform/msm/cvp/hfi_packetization.h
index c876ac154776..e613d8e8743f 100644
--- a/drivers/media/platform/msm/cvp/hfi_packetization.h
+++ b/drivers/media/platform/msm/cvp/hfi_packetization.h
@@ -51,14 +51,6 @@ struct hfi_packetization_ops {
 		struct hfi_cmd_session_cvp_release_buffers_packet *pkt,
 		struct hal_session *session,
 		struct cvp_buffer_addr_info *buffer_info);
-	int (*session_register_buffer)(
-		struct hfi_cmd_session_register_buffers_packet *pkt,
-		struct hal_session *session,
-		struct cvp_register_buffer *buffer);
-	int (*session_unregister_buffer)(
-		struct hfi_cmd_session_unregister_buffers_packet *pkt,
-		struct hal_session *session,
-		struct cvp_unregister_buffer *buffer);
 	int (*session_etb_decoder)(
 		struct hfi_cmd_session_empty_buffer_compressed_packet *pkt,
 		struct hal_session *session,
@@ -86,13 +78,25 @@ struct hfi_packetization_ops {
 		struct hfi_cmd_session_sync_process_packet *pkt,
 		struct hal_session *session);
 	int (*session_cvp_dfs_config)(
-			struct hfi_cmd_session_cvp_dfs_config *pkt,
+			struct hfi_cmd_session_cvp_dfs_config_packet *pkt,
 			struct hal_session *session,
-			struct msm_cvp_dfsconfig *dfs_config);
+			struct msm_cvp_internal_dfsconfig *dfs_config);
 	int (*session_cvp_dfs_frame)(
-			struct hfi_cmd_session_cvp_dfs_frame *pkt,
+			struct hfi_cmd_session_cvp_dfs_frame_packet *pkt,
 			struct hal_session *session,
-			struct msm_cvp_dfsframe *dfs_frame);
+			struct msm_cvp_internal_dfsframe *dfs_frame);
+	int (*session_cvp_dme_config)(
+			struct hfi_cmd_session_cvp_dme_config_packet *pkt,
+			struct hal_session *session,
+			struct msm_cvp_internal_dmeconfig *dme_config);
+	int (*session_cvp_dme_frame)(
+			struct hfi_cmd_session_cvp_dme_frame_packet *pkt,
+			struct hal_session *session,
+			struct msm_cvp_internal_dmeframe *dme_frame);
+	int (*session_cvp_persist)(
+			struct hfi_cmd_session_cvp_persist_packet *pkt,
+			struct hal_session *session,
+			struct msm_cvp_internal_persist_cmd *pbuf_cmd);
 };
 
 struct hfi_packetization_ops *cvp_hfi_get_pkt_ops_handle(
diff --git a/drivers/media/platform/msm/cvp/hfi_response_handler.c b/drivers/media/platform/msm/cvp/hfi_response_handler.c
index 041d7635b190..d0ea374ee06d 100644
--- a/drivers/media/platform/msm/cvp/hfi_response_handler.c
+++ b/drivers/media/platform/msm/cvp/hfi_response_handler.c
@@ -743,61 +743,6 @@ static int hfi_process_session_init_done(u32 device_id,
 
 	return 0;
 }
-
-static int hfi_process_session_register_buffer_done(u32 device_id,
-		struct hfi_msg_session_register_buffers_done_packet *pkt,
-		struct msm_cvp_cb_info *info)
-{
-	struct msm_cvp_cb_cmd_done cmd_done = {0};
-
-	if (!pkt || pkt->size <
-		sizeof(struct hfi_msg_session_register_buffers_done_packet)) {
-		dprintk(CVP_ERR, "%s: bad packet/packet size %d\n",
-			__func__, pkt ? pkt->size : 0);
-		return -E2BIG;
-	}
-	dprintk(CVP_DBG, "RECEIVED: SESSION_REGISTER_BUFFERS_DONE[%#x]\n",
-			pkt->session_id);
-
-	cmd_done.device_id = device_id;
-	cmd_done.size = sizeof(struct msm_cvp_cb_cmd_done);
-	cmd_done.session_id = (void *)(uintptr_t)pkt->session_id;
-	cmd_done.status = hfi_map_err_status(pkt->error_type);
-	cmd_done.data.regbuf.client_data = pkt->client_data;
-
-	info->response_type = HAL_SESSION_REGISTER_BUFFER_DONE;
-	info->response.cmd = cmd_done;
-
-	return 0;
-}
-
-static int hfi_process_session_unregister_buffer_done(u32 device_id,
-		struct hfi_msg_session_unregister_buffers_done_packet *pkt,
-		struct msm_cvp_cb_info *info)
-{
-	struct msm_cvp_cb_cmd_done cmd_done = {0};
-
-	if (!pkt || pkt->size <
-		sizeof(struct hfi_msg_session_unregister_buffers_done_packet)) {
-		dprintk(CVP_ERR, "%s: bad packet/packet size %d\n",
-			__func__, pkt ? pkt->size : 0);
-		return -E2BIG;
-	}
-	dprintk(CVP_DBG, "RECEIVED: SESSION_UNREGISTER_BUFFERS_DONE[%#x]\n",
-			pkt->session_id);
-
-	cmd_done.device_id = device_id;
-	cmd_done.size = sizeof(struct msm_cvp_cb_cmd_done);
-	cmd_done.session_id = (void *)(uintptr_t)pkt->session_id;
-	cmd_done.status = hfi_map_err_status(pkt->error_type);
-	cmd_done.data.unregbuf.client_data = pkt->client_data;
-
-	info->response_type = HAL_SESSION_UNREGISTER_BUFFER_DONE;
-	info->response.cmd = cmd_done;
-
-	return 0;
-}
-
 static int hfi_process_session_end_done(u32 device_id,
 		struct hfi_msg_sys_session_end_done_packet *pkt,
 		struct msm_cvp_cb_info *info)
@@ -924,9 +869,22 @@ static int hfi_process_session_cvp_operation_config(u32 device_id,
 	cmd_done.status = hfi_map_err_status(pkt->error_type);
 	cmd_done.size = 0;
 
-	dprintk(CVP_DBG, "%s: device_id=%d cmd_done.status=%d\n",
-		__func__, device_id, cmd_done.status);
+	dprintk(CVP_DBG,
+		"%s: device_id=%d status=%d, sessionid=%x config=%x\n",
+		__func__, device_id, cmd_done.status,
+		cmd_done.session_id, pkt->op_conf_id);
+	switch (pkt->op_conf_id) {
+	case HFI_CMD_SESSION_CVP_DFS_CONFIG:
 	info->response_type = HAL_SESSION_DFS_CONFIG_CMD_DONE;
+		break;
+	case HFI_CMD_SESSION_CVP_DME_CONFIG:
+		info->response_type = HAL_SESSION_DME_CONFIG_CMD_DONE;
+		break;
+	default:
+		dprintk(CVP_ERR, "%s Invalid op config id\n", __func__);
+		return -EINVAL;
+	}
+
 	info->response.cmd = cmd_done;
 	return 0;
 }
@@ -951,14 +909,73 @@ static int hfi_process_session_cvp_dfs(u32 device_id,
 	cmd_done.status = hfi_map_err_status(pkt->error_type);
 	cmd_done.size = 0;
 
-	dprintk(CVP_DBG, "%s: device_id=%d cmd_done.status=%d\n",
-		__func__, device_id, cmd_done.status);
+	dprintk(CVP_DBG,
+		"%s: device_id=%d cmd_done.status=%d sessionid=%x\n",
+		__func__, device_id, cmd_done.status, cmd_done.session_id);
 	info->response_type = HAL_SESSION_DFS_FRAME_CMD_DONE;
 	info->response.cmd = cmd_done;
 
 	return 0;
 }
 
+static int hfi_process_session_cvp_dme(u32 device_id,
+	struct hfi_msg_session_cvp_dme_packet_type *pkt,
+	struct msm_cvp_cb_info *info)
+{
+	struct msm_cvp_cb_cmd_done cmd_done = {0};
+
+	if (!pkt) {
+		dprintk(CVP_ERR, "%s: invalid param\n", __func__);
+		return -EINVAL;
+	} else if (pkt->size < sizeof(*pkt)) {
+		dprintk(CVP_ERR,
+				"%s: bad_pkt_size\n", __func__);
+		return -E2BIG;
+	}
+
+	cmd_done.device_id = device_id;
+	cmd_done.session_id = (void *)(uintptr_t)pkt->session_id;
+	cmd_done.status = hfi_map_err_status(pkt->error_type);
+	cmd_done.size = 0;
+
+	dprintk(CVP_DBG,
+		"%s: device_id=%d cmd_done.status=%d sessionid=%x\n",
+		__func__, device_id, cmd_done.status, cmd_done.session_id);
+	info->response_type = HAL_SESSION_DME_FRAME_CMD_DONE;
+	info->response.cmd = cmd_done;
+
+	return 0;
+}
+
+static int hfi_process_session_cvp_persist(u32 device_id,
+	struct hfi_msg_session_cvp_persist_packet_type *pkt,
+	struct msm_cvp_cb_info *info)
+{
+	struct msm_cvp_cb_cmd_done cmd_done = {0};
+
+	if (!pkt) {
+		dprintk(CVP_ERR, "%s: invalid param\n", __func__);
+		return -EINVAL;
+	} else if (pkt->size < sizeof(*pkt)) {
+		dprintk(CVP_ERR,
+				"%s: bad_pkt_size\n", __func__);
+		return -E2BIG;
+	}
+
+	cmd_done.device_id = device_id;
+	cmd_done.session_id = (void *)(uintptr_t)pkt->session_id;
+	cmd_done.status = hfi_map_err_status(pkt->error_type);
+	cmd_done.size = 0;
+
+	dprintk(CVP_DBG,
+		"%s: device_id=%d cmd_done.status=%d sessionid=%x\n",
+		__func__, device_id, cmd_done.status, cmd_done.session_id);
+	info->response_type = HAL_SESSION_PERSIST_CMD_DONE,
+	info->response.cmd = cmd_done;
+
+	return 0;
+}
+
 static void hfi_process_sys_get_prop_image_version(
 		struct hfi_msg_sys_property_info_packet *pkt)
 {
@@ -1065,20 +1082,12 @@ int cvp_hfi_process_msg_packet(u32 device_id,
 	case HFI_MSG_SYS_SESSION_END_DONE:
 		pkt_func = (pkt_func_def)hfi_process_session_end_done;
 		break;
-	case HFI_MSG_SESSION_REGISTER_BUFFERS_DONE:
-		pkt_func = (pkt_func_def)
-			hfi_process_session_register_buffer_done;
-		break;
 	case HFI_MSG_SESSION_CVP_SET_BUFFERS:
 		pkt_func = (pkt_func_def) hfi_process_session_set_buf_done;
 		break;
 	case HFI_MSG_SESSION_CVP_RELEASE_BUFFERS:
 		pkt_func = (pkt_func_def)hfi_process_session_rel_buf_done;
 		break;
-	case HFI_MSG_SESSION_UNREGISTER_BUFFERS_DONE:
-		pkt_func = (pkt_func_def)
-			hfi_process_session_unregister_buffer_done;
-		break;
 	case HFI_MSG_SYS_SESSION_ABORT_DONE:
 		pkt_func = (pkt_func_def)hfi_process_session_abort_done;
 		break;
@@ -1093,6 +1102,17 @@ int cvp_hfi_process_msg_packet(u32 device_id,
 			"Received HFI_MSG_SESSION_CVP_DFS from firmware");
 		pkt_func = (pkt_func_def)hfi_process_session_cvp_dfs;
 		break;
+	case HFI_MSG_SESSION_CVP_DME:
+		dprintk(CVP_DBG,
+			"Received HFI_MSG_SESSION_CVP_DME from firmware");
+		pkt_func = (pkt_func_def)hfi_process_session_cvp_dme;
+		break;
+	case HFI_MSG_SESSION_CVP_SET_PERSIST_BUFFERS:
+		dprintk(CVP_DBG,
+			"Received HFI_MSG_SESSION_CVP_PERSIST from firmware");
+		pkt_func = (pkt_func_def)hfi_process_session_cvp_persist;
+		break;
+
 	default:
 		dprintk(CVP_DBG, "Unable to parse message: %#x\n",
 				msg_hdr->packet);
diff --git a/drivers/media/platform/msm/cvp/msm_cvp.c b/drivers/media/platform/msm/cvp/msm_cvp.c
index eb54cad347d7..82607424ca90 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp.c
@@ -57,171 +57,6 @@ static enum hal_buffer get_hal_buftype(const char *str, unsigned int type)
 	return buftype;
 }
 
-void cvp_handle_session_register_buffer_done(enum hal_command_response cmd,
-		void *resp)
-{
-	struct msm_cvp_cb_cmd_done *response = resp;
-	struct msm_cvp_inst *inst;
-	struct msm_cvp_internal_buffer *cbuf;
-	struct v4l2_event event = {0};
-	u32 *data;
-	bool found;
-
-	if (!response) {
-		dprintk(CVP_ERR, "%s: invalid response\n", __func__);
-		return;
-	}
-	inst = cvp_get_inst(get_cvp_core(response->device_id),
-			response->session_id);
-	if (!inst) {
-		dprintk(CVP_ERR, "%s: invalid session %pK\n", __func__,
-			response->session_id);
-		return;
-	}
-
-	mutex_lock(&inst->cvpbufs.lock);
-	found = false;
-	list_for_each_entry(cbuf, &inst->cvpbufs.list, list) {
-		if (response->data.regbuf.client_data ==
-				cbuf->smem.device_addr) {
-			found = true;
-			break;
-		}
-	}
-	mutex_unlock(&inst->cvpbufs.lock);
-	if (!found) {
-		dprintk(CVP_ERR, "%s: client_data %x not found\n",
-			__func__, response->data.regbuf.client_data);
-		goto exit;
-	}
-	print_cvp_internal_buffer(CVP_DBG, "register_done", inst, cbuf);
-
-	event.type = V4L2_EVENT_MSM_CVP_REGISTER_BUFFER_DONE;
-	data = (u32 *)event.u.data;
-	data[0] = cbuf->buf.index;
-	data[1] = cbuf->buf.type;
-	data[2] = cbuf->buf.fd;
-	data[3] = cbuf->buf.offset;
-	v4l2_event_queue_fh(&inst->event_handler, &event);
-
-exit:
-	cvp_put_inst(inst);
-}
-
-void cvp_handle_session_unregister_buffer_done(enum hal_command_response cmd,
-		void *resp)
-{
-	int rc;
-	struct msm_cvp_cb_cmd_done *response = resp;
-	struct msm_cvp_inst *inst;
-	struct msm_cvp_internal_buffer *cbuf, *dummy;
-	struct v4l2_event event = {0};
-	u32 *data;
-	bool found;
-
-	if (!response) {
-		dprintk(CVP_ERR, "%s: invalid response\n", __func__);
-		return;
-	}
-	inst = cvp_get_inst(get_cvp_core(response->device_id),
-			response->session_id);
-	if (!inst) {
-		dprintk(CVP_ERR, "%s: invalid session %pK\n", __func__,
-			response->session_id);
-		return;
-	}
-
-	mutex_lock(&inst->cvpbufs.lock);
-	found = false;
-	list_for_each_entry_safe(cbuf, dummy, &inst->cvpbufs.list, list) {
-		if (response->data.unregbuf.client_data ==
-				cbuf->smem.device_addr) {
-			found = true;
-			break;
-		}
-	}
-	mutex_unlock(&inst->cvpbufs.lock);
-	if (!found) {
-		dprintk(CVP_ERR, "%s: client_data %x not found\n",
-			__func__, response->data.unregbuf.client_data);
-		goto exit;
-	}
-	print_cvp_internal_buffer(CVP_DBG, "unregister_done", inst, cbuf);
-
-	rc = msm_cvp_smem_unmap_dma_buf(inst, &cbuf->smem);
-	if (rc) {
-		print_cvp_internal_buffer(CVP_ERR, "unmap fail", inst, cbuf);
-		goto exit;
-	}
-
-	event.type = V4L2_EVENT_MSM_CVP_UNREGISTER_BUFFER_DONE;
-	data = (u32 *)event.u.data;
-	data[0] = cbuf->buf.index;
-	data[1] = cbuf->buf.type;
-	data[2] = cbuf->buf.fd;
-	data[3] = cbuf->buf.offset;
-	v4l2_event_queue_fh(&inst->event_handler, &event);
-
-	mutex_lock(&inst->cvpbufs.lock);
-	list_del(&cbuf->list);
-	mutex_unlock(&inst->cvpbufs.lock);
-	kfree(cbuf);
-	cbuf = NULL;
-exit:
-	cvp_put_inst(inst);
-}
-
-static void print_cvp_cycles(struct msm_cvp_inst *inst)
-{
-	struct msm_cvp_core *core;
-	struct msm_cvp_inst *temp;
-
-	if (!inst || !inst->core)
-		return;
-	core = inst->core;
-
-	mutex_lock(&core->lock);
-	list_for_each_entry(temp, &core->instances, list) {
-		if (temp->session_type == MSM_CVP_CORE) {
-			dprintk(CVP_ERR, "session %#x, vpss %d ise %d\n",
-				hash32_ptr(temp->session),
-				temp->clk_data.vpss_cycles,
-				temp->clk_data.ise_cycles);
-		}
-	}
-	mutex_unlock(&core->lock);
-}
-
-static bool msm_cvp_clock_aggregation(struct msm_cvp_inst *inst,
-		u32 vpss_cycles, u32 ise_cycles)
-{
-	struct msm_cvp_core *core;
-	struct msm_cvp_inst *temp;
-	u32 total_vpss_cycles = 0;
-	u32 total_ise_cycles = 0;
-
-	if (!inst || !inst->core) {
-		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
-		return false;
-	}
-	core = inst->core;
-
-	mutex_lock(&core->lock);
-	list_for_each_entry(temp, &core->instances, list) {
-		if (temp->session_type == MSM_CVP_CORE) {
-			total_vpss_cycles += inst->clk_data.vpss_cycles;
-			total_ise_cycles += inst->clk_data.ise_cycles;
-		}
-	}
-	mutex_unlock(&core->lock);
-
-	if ((total_vpss_cycles > MAX_CVP_VPSS_CYCLES) ||
-		(total_ise_cycles > MAX_CVP_ISE_CYCLES))
-		return false;
-
-	return true;
-}
-
 static int msm_cvp_scale_clocks_and_bus(struct msm_cvp_inst *inst)
 {
 	int rc = 0;
@@ -267,13 +102,45 @@ static int msm_cvp_get_session_info(struct msm_cvp_inst *inst,
 	return rc;
 }
 
+static int msm_cvp_session_get_iova_addr(
+	struct msm_cvp_inst *inst,
+	struct msm_cvp_internal_buffer *cbuf,
+	unsigned int search_fd, unsigned int search_size,
+	unsigned int *iova,
+	unsigned int *iova_size)
+{
+	bool found = false;
+
+	mutex_lock(&inst->cvpbufs.lock);
+	list_for_each_entry(cbuf, &inst->cvpbufs.list, list) {
+		if (cbuf->buf.fd == search_fd) {
+			found = true;
+			break;
+		}
+	}
+	mutex_unlock(&inst->cvpbufs.lock);
+	if (!found)
+		return -EINVAL;
+
+	*iova = cbuf->smem.device_addr;
+	if (search_size != cbuf->buf.size) {
+		dprintk(CVP_ERR,
+			"%s:: invalid size received fd = %d\n",
+			__func__, search_fd);
+		return -EINVAL;
+	}
+	*iova_size = cbuf->buf.size;
+	return 0;
+}
+
+/* DFS feature system call handling */
 static int msm_cvp_session_cvp_dfs_config(
 	struct msm_cvp_inst *inst,
-	struct msm_cvp_dfsconfig *dfs_config)
+	struct msm_cvp_dfs_config *dfs_config)
 {
 	int rc = 0;
 	struct hfi_device *hdev;
-	struct msm_cvp_dfsconfig vdfs_config;
+	struct msm_cvp_internal_dfsconfig internal_dfs_config;
 
 	dprintk(CVP_DBG, "%s:: Enter inst = %pK\n", __func__, inst);
 
@@ -282,10 +149,11 @@ static int msm_cvp_session_cvp_dfs_config(
 		return -EINVAL;
 	}
 	hdev = inst->core->device;
-	memcpy(&vdfs_config, dfs_config, sizeof(struct msm_cvp_dfsconfig));
+	memcpy(&internal_dfs_config.dfs_config.cvp_dfs_config,
+		dfs_config,	sizeof(struct msm_cvp_dfs_config));
 
 	rc = call_hfi_op(hdev, session_cvp_dfs_config,
-			(void *)inst->session, &vdfs_config);
+			(void *)inst->session, &internal_dfs_config);
 	if (!rc) {
 		rc = wait_for_sess_signal_receipt(inst,
 			HAL_SESSION_DFS_CONFIG_CMD_DONE);
@@ -303,11 +171,14 @@ static int msm_cvp_session_cvp_dfs_config(
 
 static int msm_cvp_session_cvp_dfs_frame(
 	struct msm_cvp_inst *inst,
-	struct msm_cvp_dfsframe *dfs_frame)
+	struct msm_cvp_dfs_frame *dfs_frame)
 {
 	int rc = 0;
 	struct hfi_device *hdev;
-	struct msm_cvp_dfsframe vdfs_frame;
+	struct msm_cvp_internal_dfsframe internal_dfs_frame;
+	struct msm_cvp_dfs_frame_kmd *dest_ptr = &internal_dfs_frame.dfs_frame;
+	struct msm_cvp_dfs_frame_kmd src_frame;
+	struct msm_cvp_internal_buffer *cbuf;
 
 	dprintk(CVP_DBG, "%s:: Enter inst = %pK\n", __func__, inst);
 
@@ -315,11 +186,60 @@ static int msm_cvp_session_cvp_dfs_frame(
 		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
 		return -EINVAL;
 	}
+	src_frame = *(struct msm_cvp_dfs_frame_kmd *)dfs_frame;
 	hdev = inst->core->device;
-	memcpy(&vdfs_frame, dfs_frame, sizeof(vdfs_frame));
+	memset(&internal_dfs_frame, 0,
+		sizeof(struct msm_cvp_internal_dfsframe));
+
+	memcpy(&internal_dfs_frame.dfs_frame, dfs_frame,
+		CVP_DFS_FRAME_CMD_SIZE*sizeof(unsigned int));
+
+	rc = msm_cvp_session_get_iova_addr(inst, cbuf,
+			src_frame.left_view_buffer_fd,
+			src_frame.left_view_buffer_size,
+			&dest_ptr->left_view_buffer_fd,
+			&dest_ptr->left_view_buffer_size);
+	if (rc) {
+		dprintk(CVP_ERR, "%s:: left buffer not registered. rc=%d\n",
+			__func__, rc);
+		return rc;
+	}
+
+	rc = msm_cvp_session_get_iova_addr(inst, cbuf,
+			src_frame.right_view_buffer_fd,
+			src_frame.right_view_buffer_size,
+			&dest_ptr->right_view_buffer_fd,
+			&dest_ptr->right_view_buffer_size);
+	if (rc) {
+		dprintk(CVP_ERR, "%s:: right buffer not registered. rc=%d\n",
+			__func__, rc);
+		return rc;
+	}
+
+	rc = msm_cvp_session_get_iova_addr(inst, cbuf,
+			src_frame.disparity_map_buffer_fd,
+			src_frame.disparity_map_buffer_size,
+			&dest_ptr->disparity_map_buffer_fd,
+			&dest_ptr->disparity_map_buffer_size);
+	if (rc) {
+		dprintk(CVP_ERR, "%s:: disparity map not registered. rc=%d\n",
+			__func__, rc);
+		return rc;
+	}
+
+	rc = msm_cvp_session_get_iova_addr(inst, cbuf,
+			src_frame.occlusion_mask_buffer_fd,
+			src_frame.occlusion_mask_buffer_size,
+			&dest_ptr->occlusion_mask_buffer_fd,
+			&dest_ptr->occlusion_mask_buffer_size);
+	if (rc) {
+		dprintk(CVP_ERR, "%s:: occlusion mask not registered. rc=%d\n",
+			__func__, rc);
+		return rc;
+	}
 
 	rc = call_hfi_op(hdev, session_cvp_dfs_frame,
-			(void *)inst->session, &vdfs_frame);
+			(void *)inst->session, &internal_dfs_frame);
 
 	if (rc) {
 		dprintk(CVP_ERR,
@@ -332,7 +252,7 @@ static int msm_cvp_session_cvp_dfs_frame(
 
 static int msm_cvp_session_cvp_dfs_frame_response(
 	struct msm_cvp_inst *inst,
-	struct msm_cvp_dfsframe *dfs_frame)
+	struct msm_cvp_dfs_frame *dfs_frame)
 {
 	int rc = 0;
 
@@ -348,73 +268,207 @@ static int msm_cvp_session_cvp_dfs_frame_response(
 		dprintk(CVP_ERR,
 			"%s: wait for signal failed, rc %d\n",
 			__func__, rc);
+	return rc;
+}
+
+/* DME feature system call handling */
+static int msm_cvp_session_cvp_dme_config(
+	struct msm_cvp_inst *inst,
+	struct msm_cvp_dme_config *dme_config)
+{
+	int rc = 0;
+	struct hfi_device *hdev;
+	struct msm_cvp_internal_dmeconfig internal_dme_config;
+
+	dprintk(CVP_DBG, "%s:: Enter inst = %d", __func__, inst);
+
+	if (!inst || !inst->core || !dme_config) {
+		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+	hdev = inst->core->device;
+	memcpy(&internal_dme_config.dme_config.cvp_dme_config,
+		dme_config, sizeof(struct msm_cvp_dme_config));
+
+	rc = call_hfi_op(hdev, session_cvp_dme_config,
+			(void *)inst->session, &internal_dme_config);
+	if (!rc) {
+		rc = wait_for_sess_signal_receipt(inst,
+			HAL_SESSION_DME_CONFIG_CMD_DONE);
+		if (rc)
+			dprintk(CVP_ERR,
+				"%s: wait for signal failed, rc %d\n",
+				__func__, rc);
+	} else {
+		dprintk(CVP_ERR, "%s Failed in call_hfi_op\n", __func__);
+	}
+	return rc;
+}
+
+static int msm_cvp_session_cvp_dme_frame(
+	struct msm_cvp_inst *inst,
+	struct msm_cvp_dme_frame *dme_frame)
+{
+	int rc = 0;
+	struct hfi_device *hdev;
+	struct msm_cvp_internal_dmeframe internal_dme_frame;
+	struct msm_cvp_dme_frame_kmd *dest_ptr = &internal_dme_frame.dme_frame;
+	struct msm_cvp_dme_frame_kmd src_frame;
+	struct msm_cvp_internal_buffer *cbuf;
+
+	dprintk(CVP_DBG, "%s:: Enter inst = %d", __func__, inst);
+
+	if (!inst || !inst->core || !dme_frame) {
+		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+	src_frame = *(struct msm_cvp_dme_frame_kmd *)dme_frame;
+	hdev = inst->core->device;
+	memset(&internal_dme_frame, 0,
+		sizeof(struct msm_cvp_internal_dmeframe));
+
+	memcpy(&internal_dme_frame.dme_frame, dme_frame,
+		CVP_DME_FRAME_CMD_SIZE*sizeof(unsigned int));
+
+	for (int i = 0; i < CVP_DME_BUF_NUM; i++) {
+		if (!src_frame.bufs[i].fd) {
+			dest_ptr->bufs[i].fd = src_frame.bufs[i].fd;
+			dest_ptr->bufs[i].size = src_frame.bufs[i].size;
+			continue;
+		}
+
+		rc = msm_cvp_session_get_iova_addr(inst, cbuf,
+				src_frame.bufs[i].fd,
+				src_frame.bufs[i].size,
+				&dest_ptr->bufs[i].fd,
+				&dest_ptr->bufs[i].size);
+		if (rc) {
+			dprintk(CVP_ERR,
+				"%s: %d buffer not registered. rc=%d\n",
+				__func__, i, rc);
+			return rc;
+		}
+
+	}
+
+	rc = call_hfi_op(hdev, session_cvp_dme_frame,
+			(void *)inst->session, &internal_dme_frame);
+
+	if (rc) {
+		dprintk(CVP_ERR,
+			"%s:: Failed in call_hfi_op\n",
+			__func__);
+	}
 
 	return rc;
 }
 
+static int msm_cvp_session_cvp_persist(
+	struct msm_cvp_inst *inst,
+	struct msm_cvp_persist_buf *pbuf_cmd)
+{
+	int rc = 0;
+	struct hfi_device *hdev;
+	struct msm_cvp_internal_persist_cmd internal_pcmd;
+	struct msm_cvp_persist_kmd *dest_ptr = &internal_pcmd.persist_cmd;
+	struct msm_cvp_persist_kmd src_frame;
+	struct msm_cvp_internal_buffer *cbuf;
+
+	dprintk(CVP_DBG, "%s:: Enter inst = %d", __func__, inst);
+
+	if (!inst || !inst->core || !pbuf_cmd) {
+		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+	src_frame = *(struct msm_cvp_persist_kmd *)pbuf_cmd;
+	hdev = inst->core->device;
+	memset(&internal_pcmd, 0,
+		sizeof(struct msm_cvp_internal_persist_cmd));
+
+	memcpy(&internal_pcmd.persist_cmd, pbuf_cmd,
+		CVP_PERSIST_CMD_SIZE*sizeof(unsigned int));
+
+	for (int i = 0; i < CVP_PSRSIST_BUF_NUM; i++) {
+		if (!src_frame.bufs[i].fd) {
+			dest_ptr->bufs[i].fd = src_frame.bufs[i].fd;
+			dest_ptr->bufs[i].size = src_frame.bufs[i].size;
+			continue;
+		}
+
+		rc = msm_cvp_session_get_iova_addr(inst, cbuf,
+				src_frame.bufs[i].fd,
+				src_frame.bufs[i].size,
+				&dest_ptr->bufs[i].fd,
+				&dest_ptr->bufs[i].size);
+		if (rc) {
+			dprintk(CVP_ERR,
+				"%s:: %d buffer not registered. rc=%d\n",
+				__func__, i, rc);
+			return rc;
+		}
+	}
+
+	rc = call_hfi_op(hdev, session_cvp_persist,
+			(void *)inst->session, &internal_pcmd);
+
+	if (rc)
+		dprintk(CVP_ERR, "%s: Failed in call_hfi_op\n", __func__);
+
+	return rc;
+}
+
+static int msm_cvp_session_cvp_dme_frame_response(
+	struct msm_cvp_inst *inst,
+	struct msm_cvp_dme_frame *dme_frame)
+{
+	int rc = 0;
+
+	dprintk(CVP_DBG, "%s:: Enter inst = %d", __func__, inst);
+
+	if (!inst || !inst->core || !dme_frame) {
+		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+	rc = wait_for_sess_signal_receipt(inst,
+			HAL_SESSION_DME_FRAME_CMD_DONE);
+	if (rc)
+		dprintk(CVP_ERR,
+			"%s: wait for signal failed, rc %d\n",
+			__func__, rc);
+	return rc;
+}
+
+static int msm_cvp_session_cvp_persist_response(
+	struct msm_cvp_inst *inst,
+	struct msm_cvp_persist_buf *pbuf_cmd)
+{
+	int rc = 0;
+
+	dprintk(CVP_DBG, "%s:: Enter inst = %d", __func__, inst);
+
+	if (!inst || !inst->core || !pbuf_cmd) {
+		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+	rc = wait_for_sess_signal_receipt(inst,
+			HAL_SESSION_PERSIST_CMD_DONE);
+	if (rc)
+		dprintk(CVP_ERR,
+			"%s: wait for signal failed, rc %d\n",
+			__func__, rc);
+	return rc;
+}
+
+
 
 static int msm_cvp_send_cmd(struct msm_cvp_inst *inst,
 		struct msm_cvp_send_cmd *send_cmd)
 {
-	int rc = 0;
-	bool found;
-	struct hfi_device *hdev;
-	struct msm_cvp_internal_send_cmd  *csend_cmd;
-	//struct cvp_register_buffer vbuf;
-	struct cvp_frame_data input_frame;
+	dprintk(CVP_ERR, "%s: UMD gave a deprecated cmd", __func__);
 
-	dprintk(CVP_DBG, "%s:: Enter 1", __func__);
-	if (!inst || !inst->core || !send_cmd) {
-		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
-		return -EINVAL;
-	}
-	hdev = inst->core->device;
-	//print_client_buffer(CVP_DBG, "register", inst, send_cmd);
-
-	mutex_lock(&inst->cvpbufs.lock);
-	found = false;
-	list_for_each_entry(csend_cmd, &inst->cvpbufs.list, list) {
-		if (csend_cmd->send_cmd.cmd_address_fd ==
-				send_cmd->cmd_address_fd &&
-			csend_cmd->send_cmd.cmd_size == send_cmd->cmd_size) {
-			found = true;
-			break;
-		}
-	}
-	mutex_unlock(&inst->cvpbufs.lock);
-	if (found)
-		return -EINVAL;
-
-	csend_cmd = kzalloc(
-		sizeof(struct msm_cvp_internal_send_cmd), GFP_KERNEL);
-	if (!csend_cmd) {
-		dprintk(CVP_ERR, "%s: csend_cmd alloc failed\n", __func__);
-		return -ENOMEM;
-	}
-	mutex_lock(&inst->cvpbufs.lock);
-	list_add_tail(&csend_cmd->list, &inst->cvpbufs.list);
-	mutex_unlock(&inst->cvpbufs.lock);
-
-	memset(&input_frame, 0, sizeof(struct cvp_frame_data));
-
-	rc = call_hfi_op(hdev, session_cvp_send_cmd,
-			(void *)inst->session, &input_frame);
-	if (rc)
-		goto exit;
-
-	return rc;
-
-exit:
-	if (csend_cmd->smem.device_addr)
-		msm_cvp_smem_unmap_dma_buf(inst, &csend_cmd->smem);
-	mutex_lock(&inst->cvpbufs.lock);
-	list_del(&csend_cmd->list);
-	mutex_unlock(&inst->cvpbufs.lock);
-	kfree(csend_cmd);
-	csend_cmd = NULL;
-
-	return rc;
+	return 0;
 }
+
 static int msm_cvp_request_power(struct msm_cvp_inst *inst,
 		struct msm_cvp_request_power *power)
 {
@@ -430,51 +484,6 @@ static int msm_cvp_request_power(struct msm_cvp_inst *inst,
 		__func__, power->clock_cycles_a, power->clock_cycles_b,
 		power->ddr_bw, power->sys_cache_bw);
 
-	rc = msm_cvp_clock_aggregation(inst, power->clock_cycles_a,
-			power->clock_cycles_b);
-	if (!rc) {
-		dprintk(CVP_ERR,
-			"%s: session %#x rejected, cycles: vpss %d, ise %d\n",
-			__func__, hash32_ptr(inst->session),
-			power->clock_cycles_a, power->clock_cycles_b);
-		print_cvp_cycles(inst);
-		msm_cvp_comm_kill_session(inst);
-		return -EOVERFLOW;
-	}
-
-	inst->clk_data.min_freq = max(power->clock_cycles_a,
-		power->clock_cycles_b);
-	/* convert client provided bps into kbps as expected by driver */
-	inst->clk_data.ddr_bw = power->ddr_bw / 1000;
-	inst->clk_data.sys_cache_bw = power->sys_cache_bw / 1000;
-	rc = msm_cvp_scale_clocks_and_bus(inst);
-	if (rc) {
-		dprintk(CVP_ERR,
-			"%s: failed to scale clocks and bus for inst %pK (%#x)\n",
-			__func__, inst, hash32_ptr(inst->session));
-		goto exit;
-	}
-
-	if (!inst->clk_data.min_freq && !inst->clk_data.ddr_bw &&
-		!inst->clk_data.sys_cache_bw) {
-		rc = msm_cvp_session_pause(inst);
-		if (rc) {
-			dprintk(CVP_ERR,
-				"%s: failed to pause inst %pK (%#x)\n",
-				__func__, inst, hash32_ptr(inst->session));
-			goto exit;
-		}
-	} else {
-		rc = msm_cvp_session_resume(inst);
-		if (rc) {
-			dprintk(CVP_ERR,
-				"%s: failed to resume inst %pK (%#x)\n",
-				__func__, inst, hash32_ptr(inst->session));
-			goto exit;
-		}
-	}
-
-exit:
 	return rc;
 }
 
@@ -485,7 +494,6 @@ static int msm_cvp_register_buffer(struct msm_cvp_inst *inst,
 	bool found;
 	struct hfi_device *hdev;
 	struct msm_cvp_internal_buffer *cbuf;
-	struct cvp_register_buffer vbuf;
 
 	if (!inst || !inst->core || !buf) {
 		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
@@ -497,8 +505,7 @@ static int msm_cvp_register_buffer(struct msm_cvp_inst *inst,
 	mutex_lock(&inst->cvpbufs.lock);
 	found = false;
 	list_for_each_entry(cbuf, &inst->cvpbufs.list, list) {
-		if (cbuf->buf.index == buf->index &&
-			cbuf->buf.fd == buf->fd &&
+		if (cbuf->buf.fd == buf->fd &&
 			cbuf->buf.offset == buf->offset) {
 			found = true;
 			break;
@@ -524,26 +531,13 @@ static int msm_cvp_register_buffer(struct msm_cvp_inst *inst,
 	cbuf->smem.fd = buf->fd;
 	cbuf->smem.offset = buf->offset;
 	cbuf->smem.size = buf->size;
+	cbuf->smem.flags = buf->flags;
 	rc = msm_cvp_smem_map_dma_buf(inst, &cbuf->smem);
 	if (rc) {
 		print_client_buffer(CVP_ERR, "map failed", inst, buf);
 		goto exit;
 	}
 
-	memset(&vbuf, 0, sizeof(struct cvp_register_buffer));
-	vbuf.index = buf->index;
-	vbuf.type = get_hal_buftype(__func__, buf->type);
-	vbuf.size = buf->size;
-	vbuf.device_addr = cbuf->smem.device_addr;
-	vbuf.client_data = cbuf->smem.device_addr;
-	vbuf.response_required = true;
-	rc = call_hfi_op(hdev, session_register_buffer,
-			(void *)inst->session, &vbuf);
-	if (rc) {
-		print_cvp_internal_buffer(CVP_ERR,
-			"register failed", inst, cbuf);
-		goto exit;
-	}
 	return rc;
 
 exit:
@@ -565,7 +559,6 @@ static int msm_cvp_unregister_buffer(struct msm_cvp_inst *inst,
 	bool found;
 	struct hfi_device *hdev;
 	struct msm_cvp_internal_buffer *cbuf;
-	struct cvp_unregister_buffer vbuf;
 
 	if (!inst || !inst->core || !buf) {
 		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
@@ -577,10 +570,13 @@ static int msm_cvp_unregister_buffer(struct msm_cvp_inst *inst,
 	mutex_lock(&inst->cvpbufs.lock);
 	found = false;
 	list_for_each_entry(cbuf, &inst->cvpbufs.list, list) {
-		if (cbuf->buf.index == buf->index &&
-			cbuf->buf.fd == buf->fd &&
+		if (cbuf->buf.fd == buf->fd &&
 			cbuf->buf.offset == buf->offset) {
 			found = true;
+			if (cbuf->smem.device_addr)
+				msm_cvp_smem_unmap_dma_buf(inst, &cbuf->smem);
+			list_del(&cbuf->list);
+			kfree(cbuf);
 			break;
 		}
 	}
@@ -590,19 +586,6 @@ static int msm_cvp_unregister_buffer(struct msm_cvp_inst *inst,
 		return -EINVAL;
 	}
 
-	memset(&vbuf, 0, sizeof(struct cvp_unregister_buffer));
-	vbuf.index = cbuf->buf.index;
-	vbuf.type = get_hal_buftype(__func__, cbuf->buf.type);
-	vbuf.size = cbuf->buf.size;
-	vbuf.device_addr = cbuf->smem.device_addr;
-	vbuf.client_data = cbuf->smem.device_addr;
-	vbuf.response_required = true;
-	rc = call_hfi_op(hdev, session_unregister_buffer,
-			(void *)inst->session, &vbuf);
-	if (rc)
-		print_cvp_internal_buffer(CVP_ERR,
-			"unregister failed", inst, cbuf);
-
 	return rc;
 }
 
@@ -661,26 +644,66 @@ int msm_cvp_handle_syscall(struct msm_cvp_inst *inst, struct msm_cvp_arg *arg)
 	}
 	case MSM_CVP_HFI_DFS_CONFIG_CMD:
 	{
-		struct msm_cvp_dfsconfig *dfsconfig =
-			(struct msm_cvp_dfsconfig *)&arg->data.dfsconfig;
+		struct msm_cvp_dfs_config *dfs_config =
+			(struct msm_cvp_dfs_config *)&arg->data.dfs_config;
 
-		rc = msm_cvp_session_cvp_dfs_config(inst, dfsconfig);
+		rc = msm_cvp_session_cvp_dfs_config(inst, dfs_config);
 		break;
 	}
 	case MSM_CVP_HFI_DFS_FRAME_CMD:
 	{
-		struct msm_cvp_dfsframe *dfsframe =
-			(struct msm_cvp_dfsframe *)&arg->data.dfsframe;
+		struct msm_cvp_dfs_frame *dfs_frame =
+			(struct msm_cvp_dfs_frame *)&arg->data.dfs_frame;
 
-		rc = msm_cvp_session_cvp_dfs_frame(inst, dfsframe);
+		rc = msm_cvp_session_cvp_dfs_frame(inst, dfs_frame);
 		break;
 	}
 	case MSM_CVP_HFI_DFS_FRAME_CMD_RESPONSE:
 	{
-		struct msm_cvp_dfsframe *dfsframe =
-			(struct msm_cvp_dfsframe *)&arg->data.dfsframe;
+		struct msm_cvp_dfs_frame *dfs_frame =
+			(struct msm_cvp_dfs_frame *)&arg->data.dfs_frame;
 
-		rc = msm_cvp_session_cvp_dfs_frame_response(inst, dfsframe);
+		rc = msm_cvp_session_cvp_dfs_frame_response(inst, dfs_frame);
+		break;
+	}
+	case MSM_CVP_HFI_DME_CONFIG_CMD:
+	{
+		struct msm_cvp_dme_config *dme_config =
+			(struct msm_cvp_dme_config *)&arg->data.dme_config;
+
+		rc = msm_cvp_session_cvp_dme_config(inst, dme_config);
+		break;
+	}
+	case MSM_CVP_HFI_DME_FRAME_CMD:
+	{
+		struct msm_cvp_dme_frame *dme_frame =
+			(struct msm_cvp_dme_frame *)&arg->data.dme_frame;
+
+		rc = msm_cvp_session_cvp_dme_frame(inst, dme_frame);
+		break;
+	}
+	case MSM_CVP_HFI_DME_FRAME_CMD_RESPONSE:
+	{
+		struct msm_cvp_dme_frame *dmeframe =
+			(struct msm_cvp_dme_frame *)&arg->data.dme_frame;
+
+		rc = msm_cvp_session_cvp_dme_frame_response(inst, dmeframe);
+		break;
+	}
+	case MSM_CVP_HFI_PERSIST_CMD:
+	{
+		struct msm_cvp_persist_buf *pbuf_cmd =
+			(struct msm_cvp_persist_buf *)&arg->data.pbuf_cmd;
+
+		rc = msm_cvp_session_cvp_persist(inst, pbuf_cmd);
+		break;
+	}
+	case MSM_CVP_HFI_PERSIST_CMD_RESPONSE:
+	{
+		struct msm_cvp_persist_buf *pbuf_cmd =
+			(struct msm_cvp_persist_buf *)&arg->data.pbuf_cmd;
+
+		rc = msm_cvp_session_cvp_persist_response(inst, pbuf_cmd);
 		break;
 	}
 	default:
diff --git a/drivers/media/platform/msm/cvp/msm_cvp.h b/drivers/media/platform/msm/cvp/msm_cvp.h
index 56098eefa0d5..5311023b02f2 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp.h
+++ b/drivers/media/platform/msm/cvp/msm_cvp.h
@@ -11,10 +11,6 @@
 #include "msm_cvp_clocks.h"
 #include "msm_cvp_debug.h"
 
-void cvp_handle_session_register_buffer_done(enum hal_command_response cmd,
-		void *resp);
-void cvp_handle_session_unregister_buffer_done(enum hal_command_response cmd,
-		void *resp);
 int msm_cvp_handle_syscall(struct msm_cvp_inst *inst, struct msm_cvp_arg *arg);
 int msm_cvp_session_init(struct msm_cvp_inst *inst);
 int msm_cvp_session_deinit(struct msm_cvp_inst *inst);
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_common.c b/drivers/media/platform/msm/cvp/msm_cvp_common.c
index 2e97c3ef1f74..e608bd15d68e 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_common.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_common.c
@@ -585,7 +585,7 @@ struct msm_cvp_inst *cvp_get_inst(struct msm_cvp_core *core,
 	return inst;
 }
 
-static void cvp_handle_session_dfs_cmd_done(enum hal_command_response cmd,
+static void cvp_handle_session_cmd_done(enum hal_command_response cmd,
 	void *data)
 {
 	struct msm_cvp_cb_cmd_done *response = data;
@@ -1679,11 +1679,6 @@ enum hal_buffer msm_cvp_comm_get_hal_output_buffer(struct msm_cvp_inst *inst)
 		return HAL_BUFFER_OUTPUT;
 }
 
-static void handle_dfs(enum hal_command_response cmd, void *data)
-{
-	dprintk(CVP_ERR, "%s: is called\n", __func__);
-}
-
 void cvp_handle_cmd_response(enum hal_command_response cmd, void *data)
 {
 	dprintk(CVP_DBG, "Command response = %d\n", cmd);
@@ -1700,9 +1695,6 @@ void cvp_handle_cmd_response(enum hal_command_response cmd, void *data)
 	case HAL_SESSION_CVP_OPERATION_CONFIG:
 		handle_operation_config(cmd, data);
 		break;
-	case HAL_SESSION_CVP_DFS:
-		handle_dfs(cmd, data);
-		break;
 	case HAL_SESSION_RELEASE_RESOURCE_DONE:
 		handle_release_res_done(cmd, data);
 		break;
@@ -1729,15 +1721,12 @@ void cvp_handle_cmd_response(enum hal_command_response cmd, void *data)
 	case HAL_SESSION_RELEASE_BUFFER_DONE:
 		handle_session_release_buf_done(cmd, data);
 		break;
-	case HAL_SESSION_REGISTER_BUFFER_DONE:
-		cvp_handle_session_register_buffer_done(cmd, data);
-		break;
-	case HAL_SESSION_UNREGISTER_BUFFER_DONE:
-		cvp_handle_session_unregister_buffer_done(cmd, data);
-		break;
 	case HAL_SESSION_DFS_CONFIG_CMD_DONE:
 	case HAL_SESSION_DFS_FRAME_CMD_DONE:
-		cvp_handle_session_dfs_cmd_done(cmd, data);
+	case HAL_SESSION_DME_CONFIG_CMD_DONE:
+	case HAL_SESSION_DME_FRAME_CMD_DONE:
+	case HAL_SESSION_PERSIST_CMD_DONE:
+		cvp_handle_session_cmd_done(cmd, data);
 		break;
 	default:
 		dprintk(CVP_DBG, "response unhandled: %d\n", cmd);
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_internal.h b/drivers/media/platform/msm/cvp/msm_cvp_internal.h
index c3deebaa1f84..3b580fad4e80 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_internal.h
+++ b/drivers/media/platform/msm/cvp/msm_cvp_internal.h
@@ -526,12 +526,6 @@ struct msm_cvp_internal_send_cmd {
 	struct msm_cvp_send_cmd send_cmd;
 };
 
-struct msm_cvp_internal_dfsconfig {
-	struct list_head list;
-	struct msm_smem smem;
-	struct msm_cvp_dfsconfig dfsconfig;
-};
-
 void msm_cvp_comm_handle_thermal_event(void);
 int msm_cvp_smem_alloc(size_t size, u32 align, u32 flags,
 	enum hal_buffer buffer_type, int map_kernel,
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_platform.c b/drivers/media/platform/msm/cvp/msm_cvp_platform.c
index dfc2855a3bc7..d8080820814a 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_platform.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_platform.c
@@ -94,7 +94,7 @@ static struct msm_cvp_common_data sm8250_common_data[] = {
 	},
 	{
 		.key = "qcom,sw-power-collapse",
-		.value = 1,
+		.value = 0,
 	},
 	{
 		.key = "qcom,domain-attr-non-fatal-faults",
diff --git a/drivers/media/platform/msm/cvp/msm_cvp_res_parse.c b/drivers/media/platform/msm/cvp/msm_cvp_res_parse.c
index ca47d009f01e..422b6b64186e 100644
--- a/drivers/media/platform/msm/cvp/msm_cvp_res_parse.c
+++ b/drivers/media/platform/msm/cvp/msm_cvp_res_parse.c
@@ -907,8 +907,17 @@ static int msm_cvp_setup_context_bank(struct msm_cvp_platform_resources *res,
 		goto remove_cb;
 	}
 
-	if (cb->is_secure)
+	if (cb->is_secure) {
 		secure_vmid = get_secure_vmid(cb);
+		rc = iommu_domain_set_attr(cb->mapping->domain,
+			DOMAIN_ATTR_SECURE_VMID, &secure_vmid);
+		if (rc) {
+			dprintk(CVP_ERR,
+				"%s - Couldn't arm_iommu_set_attr vmid\n",
+				__func__);
+			goto release_mapping;
+		}
+	}
 
 	if (res->cache_pagetables) {
 		int cache_pagetables = 1;
diff --git a/drivers/media/platform/msm/cvp/msm_v4l2_cvp.c b/drivers/media/platform/msm/cvp/msm_v4l2_cvp.c
index 79a84aa79e6b..ef3ea6c686e8 100644
--- a/drivers/media/platform/msm/cvp/msm_v4l2_cvp.c
+++ b/drivers/media/platform/msm/cvp/msm_v4l2_cvp.c
@@ -63,16 +63,15 @@ static int msm_cvp_v4l2_open(struct file *filp)
 
 static int msm_cvp_v4l2_close(struct file *filp)
 {
-	int rc = 0;
 	struct msm_cvp_inst *cvp_inst;
 
 	trace_msm_v4l2_cvp_close_start("msm v4l2_close start");
 	cvp_inst = get_cvp_inst(filp, NULL);
 
-	rc = msm_cvp_close(cvp_inst);
+	//rc = msm_cvp_close(cvp_inst);
 	filp->private_data = NULL;
 	trace_msm_v4l2_cvp_close_end("msm v4l2_close end");
-	return rc;
+	return 0;
 }
 
 static int msm_cvp_v4l2_querycap(struct file *filp, void *fh,
diff --git a/drivers/media/platform/msm/cvp/msm_v4l2_private.c b/drivers/media/platform/msm/cvp/msm_v4l2_private.c
index 530f18e909fa..35196a311ff6 100644
--- a/drivers/media/platform/msm/cvp/msm_v4l2_private.c
+++ b/drivers/media/platform/msm/cvp/msm_v4l2_private.c
@@ -105,87 +105,77 @@ static int convert_from_user(struct msm_cvp_arg *kp, unsigned long arg)
 	}
 	case MSM_CVP_HFI_DFS_CONFIG_CMD:
 	{
-		struct msm_cvp_dfsconfig *k, *u;
+		struct msm_cvp_dfs_config *k, *u;
 
-		dprintk(CVP_DBG, "%s: MSM_CVP_HFI_DFS_CONFIG_CMD\n",
-				__func__);
-		k = &kp->data.dfsconfig;
-		u = &up->data.dfsconfig;
-		if (get_user(k->cmd_address, &u->cmd_address) ||
-			get_user(k->cmd_size, &u->cmd_size) ||
-			get_user(k->packet_type, &u->packet_type) ||
-			get_user(k->session_id, &u->session_id) ||
-			get_user(k->srcbuffer_format, &u->srcbuffer_format) ||
-			get_user(
-			k->left_plane_info.stride[HFI_MAX_PLANES - 1],
-			&u->left_plane_info.stride[HFI_MAX_PLANES - 1]) ||
-			get_user(
-			k->left_plane_info.buf_size[HFI_MAX_PLANES - 1],
-			&u->left_plane_info.buf_size[HFI_MAX_PLANES - 1]) ||
-			get_user(
-			k->right_plane_info.stride[HFI_MAX_PLANES - 1],
-			&u->right_plane_info.stride[HFI_MAX_PLANES - 1]) ||
-			get_user(
-			k->right_plane_info.buf_size[HFI_MAX_PLANES - 1],
-			&u->right_plane_info.buf_size[HFI_MAX_PLANES - 1]) ||
-			get_user(k->width, &u->width) ||
-			get_user(k->height, &u->height) ||
-			get_user(k->occlusionmask_enable,
-				&u->occlusionmask_enable) ||
-			get_user(k->occlusioncost, &u->occlusioncost) ||
-			get_user(k->occlusionshift, &u->occlusionshift) ||
-			get_user(k->maxdisparity, &u->maxdisparity) ||
-			get_user(k->disparityoffset, &u->disparityoffset) ||
-			get_user(k->medianfilter_enable,
-				&u->medianfilter_enable) ||
-			get_user(k->occlusionbound, &u->occlusionbound) ||
-			get_user(k->occlusionfilling_enable,
-				&u->occlusionfilling_enable) ||
-			get_user(k->occlusionmaskdump,
-				&u->occlusionmaskdump) ||
-			get_user(k->clientdata.transactionid,
-				&u->clientdata.transactionid) ||
-			get_user(k->clientdata.client_data1,
-				&u->clientdata.client_data1) ||
-			get_user(k->clientdata.client_data2,
-				&u->clientdata.client_data2))
-			return -EFAULT;
-		for (i = 0; i < MAX_DFS_HFI_PARAMS; i++)
-			if (get_user(k->reserved[i], &u->reserved[i]))
+		dprintk(CVP_DBG, "%s: MSM_CVP_HFI_DFS_CONFIG_CMD\n", __func__);
+		k = &kp->data.dfs_config;
+		u = &up->data.dfs_config;
+		for (i = 0; i < CVP_DFS_CONFIG_CMD_SIZE; i++)
+			if (get_user(k->cvp_dfs_config[i],
+				&u->cvp_dfs_config[i]))
 				return -EFAULT;
 		break;
 	}
 	case MSM_CVP_HFI_DFS_FRAME_CMD:
 	case MSM_CVP_HFI_DFS_FRAME_CMD_RESPONSE:
 	{
-		struct msm_cvp_dfsframe *k, *u;
+		struct msm_cvp_dfs_frame *k, *u;
 
-		dprintk(CVP_DBG, "%s: Type =%d\n",
-							__func__, kp->type);
-		k = &kp->data.dfsframe;
-		u = &up->data.dfsframe;
-		if (get_user(k->cmd_address, &u->cmd_address) ||
-			get_user(k->cmd_size, &u->cmd_size) ||
-			get_user(k->packet_type, &u->packet_type) ||
-			get_user(k->session_id, &u->session_id) ||
-			get_user(k->left_buffer_index,
-				&u->left_buffer_index) ||
-			get_user(k->right_buffer_index,
-				&u->right_buffer_index) ||
-			get_user(k->disparitymap_buffer_idx,
-				&u->disparitymap_buffer_idx) ||
-			get_user(k->occlusionmask_buffer_idx,
-				&u->occlusionmask_buffer_idx) ||
-			get_user(k->clientdata.transactionid,
-				&u->clientdata.transactionid) ||
-			get_user(k->clientdata.client_data1,
-				&u->clientdata.client_data1) ||
-			get_user(k->clientdata.client_data2,
-				&u->clientdata.client_data2))
-			return -EFAULT;
+		dprintk(CVP_DBG, "%s: Type =%d\n", __func__, kp->type);
+		k = &kp->data.dfs_frame;
+		u = &up->data.dfs_frame;
+		for (i = 0; i < CVP_DFS_FRAME_CMD_SIZE; i++)
+			if (get_user(k->frame_data[i], &u->frame_data[i]))
+				return -EFAULT;
 
 		break;
 	}
+	case MSM_CVP_HFI_DME_CONFIG_CMD:
+	{
+		struct msm_cvp_dme_config *k, *u;
+
+		dprintk(CVP_DBG, "%s: MSM_CVP_HFI_DFS_CONFIG_CMD\n", __func__);
+		k = &kp->data.dme_config;
+		u = &up->data.dme_config;
+		for (i = 0; i < CVP_DME_CONFIG_CMD_SIZE; i++)
+			if (get_user(k->cvp_dme_config[i],
+				&u->cvp_dme_config[i]))
+				return -EFAULT;
+		break;
+	}
+	case MSM_CVP_HFI_DME_FRAME_CMD:
+	case MSM_CVP_HFI_DME_FRAME_CMD_RESPONSE:
+	{
+		struct msm_cvp_dme_frame *k, *u;
+
+		dprintk(CVP_DBG, "%s: type = %d\n",
+					__func__, kp->type);
+		k = &kp->data.dme_frame;
+		u = &up->data.dme_frame;
+
+		for (i = 0; i < CVP_DME_FRAME_CMD_SIZE; i++)
+			if (get_user(k->frame_data[i], &u->frame_data[i]))
+				return -EFAULT;
+
+		break;
+	}
+	case MSM_CVP_HFI_PERSIST_CMD:
+	case MSM_CVP_HFI_PERSIST_CMD_RESPONSE:
+	{
+		struct msm_cvp_persist_buf *k, *u;
+
+		dprintk(CVP_DBG, "%s: type = %d\n",
+					__func__, kp->type);
+		k = &kp->data.pbuf_cmd;
+		u = &up->data.pbuf_cmd;
+
+		for (i = 0; i < CVP_PERSIST_CMD_SIZE; i++)
+			if (get_user(k->persist_data[i], &u->persist_data[i]))
+				return -EFAULT;
+
+		break;
+	}
+
 	default:
 		dprintk(CVP_ERR, "%s: unknown cmd type 0x%x\n",
 			__func__, kp->type);
@@ -297,87 +287,78 @@ static int convert_to_user(struct msm_cvp_arg *kp, unsigned long arg)
 	}
 	case MSM_CVP_HFI_DFS_CONFIG_CMD:
 	{
-		struct msm_cvp_dfsconfig *k, *u;
+		struct msm_cvp_dfs_config *k, *u;
 
 		dprintk(CVP_DBG, "%s: MSM_CVP_HFI_DFS_CONFIG_CMD\n",
 					__func__);
 
-		k = &kp->data.dfsconfig;
-		u = &up->data.dfsconfig;
-		if (put_user(k->cmd_address, &u->cmd_address) ||
-			put_user(k->cmd_size, &u->cmd_size) ||
-			put_user(k->packet_type, &u->packet_type) ||
-			put_user(k->session_id, &u->session_id) ||
-			put_user(k->srcbuffer_format, &u->srcbuffer_format) ||
-			put_user(
-			k->left_plane_info.stride[HFI_MAX_PLANES - 1],
-			&u->left_plane_info.stride[HFI_MAX_PLANES - 1]) ||
-			put_user(
-			k->left_plane_info.buf_size[HFI_MAX_PLANES - 1],
-			&u->left_plane_info.buf_size[HFI_MAX_PLANES - 1]) ||
-			put_user(
-			k->right_plane_info.stride[HFI_MAX_PLANES - 1],
-			&u->right_plane_info.stride[HFI_MAX_PLANES - 1]) ||
-			put_user(
-			k->right_plane_info.buf_size[HFI_MAX_PLANES - 1],
-			&u->right_plane_info.buf_size[HFI_MAX_PLANES - 1])
-			|| put_user(k->width, &u->width) ||
-			put_user(k->height, &u->height) ||
-			put_user(k->occlusionmask_enable,
-				&u->occlusionmask_enable) ||
-			put_user(k->occlusioncost, &u->occlusioncost) ||
-			put_user(k->occlusionshift, &u->occlusionshift) ||
-			put_user(k->maxdisparity, &u->maxdisparity) ||
-			put_user(
-				k->disparityoffset, &u->disparityoffset) ||
-			put_user(k->medianfilter_enable,
-				&u->medianfilter_enable) ||
-			put_user(k->occlusionbound, &u->occlusionbound) ||
-			put_user(k->occlusionfilling_enable,
-				&u->occlusionfilling_enable) ||
-			put_user(k->occlusionmaskdump,
-				&u->occlusionmaskdump) ||
-			put_user(k->clientdata.transactionid,
-				&u->clientdata.transactionid) ||
-			put_user(k->clientdata.client_data1,
-				&u->clientdata.client_data1) ||
-			put_user(k->clientdata.client_data2,
-				&u->clientdata.client_data2))
-			return -EFAULT;
-		for (i = 0; i < MAX_DFS_HFI_PARAMS; i++)
-			if (put_user(k->reserved[i], &u->reserved[i]))
+		k = &kp->data.dfs_config;
+		u = &up->data.dfs_config;
+		for (i = 0; i < CVP_DFS_CONFIG_CMD_SIZE; i++)
+			if (put_user(k->cvp_dfs_config[i],
+				&u->cvp_dfs_config[i]))
 				return -EFAULT;
 		break;
 	}
 	case MSM_CVP_HFI_DFS_FRAME_CMD:
 	case MSM_CVP_HFI_DFS_FRAME_CMD_RESPONSE:
 	{
-		struct msm_cvp_dfsframe *k, *u;
+		struct msm_cvp_dfs_frame *k, *u;
 
 		dprintk(CVP_DBG, "%s: type = %d\n",
 					__func__, kp->type);
-		k = &kp->data.dfsframe;
-		u = &up->data.dfsframe;
+		k = &kp->data.dfs_frame;
+		u = &up->data.dfs_frame;
+
+		for (i = 0; i < CVP_DFS_FRAME_CMD_SIZE; i++)
+			if (put_user(k->frame_data[i], &u->frame_data[i]))
+				return -EFAULT;
+
+		break;
+	}
+	case MSM_CVP_HFI_DME_CONFIG_CMD:
+	{
+		struct msm_cvp_dme_config *k, *u;
+
+		dprintk(CVP_DBG, "%s: MSM_CVP_HFI_DME_CONFIG_CMD\n", __func__);
+		k = &kp->data.dme_config;
+		u = &up->data.dme_config;
+		for (i = 0; i < CVP_DME_CONFIG_CMD_SIZE; i++)
+			if (put_user(k->cvp_dme_config[i],
+				&u->cvp_dme_config[i]))
+				return -EFAULT;
+		break;
+	}
+	case MSM_CVP_HFI_DME_FRAME_CMD:
+	case MSM_CVP_HFI_DME_FRAME_CMD_RESPONSE:
+	{
+		struct msm_cvp_dme_frame *k, *u;
+
+		dprintk(CVP_DBG, "%s: type = %d\n",
+					__func__, kp->type);
+		k = &kp->data.dme_frame;
+		u = &up->data.dme_frame;
+
+		for (i = 0; i < CVP_DME_FRAME_CMD_SIZE; i++)
+			if (put_user(k->frame_data[i], &u->frame_data[i]))
+				return -EFAULT;
+
+		break;
+	}
+	case MSM_CVP_HFI_PERSIST_CMD:
+	case MSM_CVP_HFI_PERSIST_CMD_RESPONSE:
+	{
+		struct msm_cvp_persist_buf *k, *u;
+
+		dprintk(CVP_DBG, "%s: type = %d\n",
+					__func__, kp->type);
+		k = &kp->data.pbuf_cmd;
+		u = &up->data.pbuf_cmd;
+
+		for (i = 0; i < CVP_PERSIST_CMD_SIZE; i++)
+			if (put_user(k->persist_data[i], &u->persist_data[i]))
+				return -EFAULT;
 
-		if (put_user(k->cmd_address, &u->cmd_address) ||
-			put_user(k->cmd_size, &u->cmd_size) ||
-			put_user(k->packet_type, &u->packet_type) ||
-			put_user(k->session_id, &u->session_id) ||
-			put_user(k->left_buffer_index,
-				&u->left_buffer_index) ||
-			put_user(k->right_buffer_index,
-				&u->right_buffer_index) ||
-			put_user(k->disparitymap_buffer_idx,
-				&u->disparitymap_buffer_idx) ||
-			put_user(k->occlusionmask_buffer_idx,
-				&u->occlusionmask_buffer_idx) ||
-			put_user(k->clientdata.transactionid,
-				&u->clientdata.transactionid) ||
-			put_user(k->clientdata.client_data1,
-				&u->clientdata.client_data1) ||
-			put_user(k->clientdata.client_data2,
-				&u->clientdata.client_data2))
-			return -EFAULT;
 		break;
 	}
 	default:
diff --git a/include/uapi/media/msm_cvp_private.h b/include/uapi/media/msm_cvp_private.h
index 2be53e628ef0..82f69c23135d 100644
--- a/include/uapi/media/msm_cvp_private.h
+++ b/include/uapi/media/msm_cvp_private.h
@@ -8,6 +8,7 @@
 #include <linux/videodev2.h>
 
 #define MAX_DFS_HFI_PARAMS 20
+#define HFI_MAX_PLANES 4
 
 /* VIDIOC private cvp command */
 #define VIDIOC_CVP_CMD \
@@ -58,6 +59,16 @@
 
 #define MSM_CVP_HFI_DFS_FRAME_CMD_RESPONSE  (MSM_CVP_CMD_START + 8)
 
+#define MSM_CVP_HFI_DME_CONFIG_CMD  (MSM_CVP_CMD_START + 9)
+
+#define MSM_CVP_HFI_DME_FRAME_CMD  (MSM_CVP_CMD_START + 10)
+
+#define MSM_CVP_HFI_DME_FRAME_CMD_RESPONSE  (MSM_CVP_CMD_START + 11)
+
+#define MSM_CVP_HFI_PERSIST_CMD  (MSM_CVP_CMD_START + 12)
+
+#define MSM_CVP_HFI_PERSIST_CMD_RESPONSE  (MSM_CVP_CMD_START + 13)
+
 /* flags */
 #define MSM_CVP_FLAG_UNSECURE			0x00000000
 #define MSM_CVP_FLAG_SECURE			0x00000001
@@ -125,15 +136,6 @@ struct msm_cvp_send_cmd {
 	unsigned int reserved[10];
 };
 
-/**
- * enum HFI_COLOR_PLANE_TYPE - define the type of plane
- */
-enum HFI_COLOR_PLANE_TYPE {
-	HFI_COLOR_PLANE_METADATA,
-	HFI_COLOR_PLANE_PICDATA,
-	HFI_MAX_PLANES
-};
-
 /**
  * struct msm_cvp_color_plane_info - color plane info
  * @stride:      stride of plane
@@ -157,77 +159,40 @@ struct msm_cvp_client_data {
 	unsigned int client_data2;
 };
 
-/**
- * struct msm_cvp_dfsconfig - dfs config packet
- * @cmd_size:               command size in bytes
- * @cmd_address:            command address
- * @size:                   packet size in bytes
- * @packet_type:            HFI_CMD_SESSION_CVP_DFS
- * @session_id:             id value associated with a session
- * @srcbuffer_format:       buffer format of source imagesize
- * @left_plane_info:        left view buffer plane info
- * @right_plane_info:       right view buffer plane info
- * @width:                  image width
- * @height:                 image height
- * @occlusionmask_enable:   0: disable, 1: enable
- * @occlusioncost:          occlusion cost threshold
- * @occlusionbound:         occlusion bound
- * @occlusionshift:         occlusion shift
- * @maxdisparity:           max disparitymap in integer precision
- * @disparityoffset:        disparity offset
- * @medianfilter_enable:    enable median filter on disparity map
- * @occlusionfilling_enable:0: disable, 1: enable
- * @occlusionmaskdump:      0: disable, 1: enable
- * @clientdata:             client data for mapping command
- *                          and message pairs
- */
-struct msm_cvp_dfsconfig {
-	unsigned int cmd_size;
-	unsigned int cmd_address;
-	unsigned int size;
-	unsigned int packet_type;
-	unsigned int session_id;
-	unsigned int srcbuffer_format;
-	struct msm_cvp_color_plane_info left_plane_info;
-	struct msm_cvp_color_plane_info right_plane_info;
-	unsigned int width;
-	unsigned int height;
-	unsigned int occlusionmask_enable;
-	unsigned int occlusioncost;
-	unsigned int occlusionbound;
-	unsigned int occlusionshift;
-	unsigned int maxdisparity;
-	unsigned int disparityoffset;
-	unsigned int medianfilter_enable;
-	unsigned int occlusionfilling_enable;
-	unsigned int occlusionmaskdump;
-	struct msm_cvp_client_data clientdata;
-	unsigned int reserved[MAX_DFS_HFI_PARAMS];
+#define CVP_COLOR_PLANE_INFO_SIZE \
+	sizeof(struct msm_cvp_color_plane_info)
+#define CVP_CLIENT_DATA_SIZE	sizeof(struct msm_cvp_client_data)
+#define CVP_DFS_CONFIG_CMD_SIZE   38
+#define CVP_DFS_FRAME_CMD_SIZE 16
+#define CVP_DFS_FRAME_BUFFERS_OFFSET 8
+
+#define CVP_DME_CONFIG_CMD_SIZE   181
+#define CVP_DME_FRAME_CMD_SIZE 28
+#define CVP_DME_FRAME_BUFFERS_OFFSET 12
+#define CVP_DME_BUF_NUM	8
+
+#define CVP_PERSIST_CMD_SIZE 11
+#define CVP_PERSIST_BUFFERS_OFFSET 7
+#define CVP_PSRSIST_BUF_NUM	2
+
+struct msm_cvp_dfs_config {
+	unsigned int cvp_dfs_config[CVP_DFS_CONFIG_CMD_SIZE];
 };
 
-/**
- * struct msm_cvp_dfsframe - dfs frame packet
- * @cmd_size:                command size in bytes
- * @cmd_address:             command address
- * @size:                    packet size in bytes
- * @packet_type:             HFI_CMD_SESSION_CVP_DFS
- * @session_id:              id value associated with a session
- * @left_buffer_index:       left buffer index
- * @right_buffer_index:      right buffer index
- * @disparitymap_buffer_idx: disparity map buffer index
- * @occlusionmask_buffer_idx:occlusion mask buffer index
- */
-struct msm_cvp_dfsframe {
-	unsigned int cmd_size;
-	unsigned int cmd_address;
-	unsigned int size;
-	unsigned int packet_type;
-	unsigned int session_id;
-	unsigned int left_buffer_index;
-	unsigned int right_buffer_index;
-	unsigned int disparitymap_buffer_idx;
-	unsigned int occlusionmask_buffer_idx;
-	struct msm_cvp_client_data clientdata;
+struct msm_cvp_dfs_frame {
+	unsigned int frame_data[CVP_DFS_FRAME_CMD_SIZE];
+};
+
+struct msm_cvp_dme_config {
+	unsigned int cvp_dme_config[CVP_DME_CONFIG_CMD_SIZE];
+};
+
+struct msm_cvp_dme_frame {
+	unsigned int frame_data[CVP_DME_FRAME_CMD_SIZE];
+};
+
+struct msm_cvp_persist_buf {
+	unsigned int persist_data[CVP_PERSIST_CMD_SIZE];
 };
 
 /**
@@ -238,8 +203,8 @@ struct msm_cvp_dfsframe {
  * @regbuf:        buffer to be registered
  * @unregbuf:      buffer to be unregistered
  * @send_cmd:      sending generic HFI command
- * @dfsconfig:     sending DFS config command
- * @dfsframe:      sending DFS frame command
+ * @dfs_config:    sending DFS config command
+ * @dfs_frame:     sending DFS frame command
  */
 struct msm_cvp_arg {
 	unsigned int type;
@@ -249,8 +214,11 @@ struct msm_cvp_arg {
 		struct msm_cvp_buffer regbuf;
 		struct msm_cvp_buffer unregbuf;
 		struct msm_cvp_send_cmd send_cmd;
-		struct msm_cvp_dfsconfig dfsconfig;
-		struct msm_cvp_dfsframe dfsframe;
+		struct msm_cvp_dfs_config dfs_config;
+		struct msm_cvp_dfs_frame dfs_frame;
+		struct msm_cvp_dme_config dme_config;
+		struct msm_cvp_dme_frame dme_frame;
+		struct msm_cvp_persist_buf pbuf_cmd;
 	} data;
 	unsigned int reserved[12];
 };